#ifndef __clang_analyzer__
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: Devices.proto
// Protobuf C++ Version: 7.36.0

#include "Devices.pb.h"

#include <algorithm>
#include <type_traits>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/generated_message_tctable_impl.h"
#include "google/protobuf/internal_visibility.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/reflection_ops.h"
#include "google/protobuf/wire_format.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
#ifdef PROTOBUF_MESSAGE_GLOBALS
namespace {
PROTOBUF_CONSTINIT ::google::protobuf::internal::ReflectionData
    file_reflection_data[] = {
        // ::usbguard::IPC::listDevicesRequest
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::listDevicesResponse
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::listDevices
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::applyDevicePolicyRequest
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::applyDevicePolicyResponse
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::applyDevicePolicy
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::DevicePresenceChangedSignal
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::DevicePolicyChangedSignal
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::DevicePolicyAppliedSignal
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
        // ::usbguard::IPC::PropertyParameterChangedSignal
        {&::_pbi::kDescriptorMethods, &::descriptor_table_Devices_2eproto, /* tracker*/ nullptr,},
};
}  // namespace
#endif
namespace usbguard {
namespace IPC {
class listDevicesRequest::_Internal {
 public:
  using HasBits = decltype(::std::declval<listDevicesRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(listDevicesRequest, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

constexpr listDevicesRequest::ParseTableT_ listDevicesRequest::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(listDevicesRequest, _impl_._has_bits_),
      0, // no _extensions_
      1, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967294,  // skipmap
      offsetof(ParseTableT_, field_entries),
      1,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::listDevicesRequest>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // required string query = 1;
      {::_pbi::TcParser::FastBS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(listDevicesRequest, _impl_.query_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required string query = 1;
      {PROTOBUF_FIELD_OFFSET(listDevicesRequest, _impl_.query_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr listDevicesRequest::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : query_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()) {}

template <typename>
constexpr listDevicesRequest::listDevicesRequest(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL listDevicesRequest::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) listDevicesRequest(arena);
}
constexpr auto listDevicesRequest::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(listDevicesRequest), alignof(listDevicesRequest));
}
constexpr auto listDevicesRequest::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          listDevicesRequest::IsInitializedImpl,
          &listDevicesRequest::MergeImpl,
          Super_::GetNewImpl<listDevicesRequest>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &listDevicesRequest::SharedDtor,
          Super_::GetClearImpl<listDevicesRequest>(), &listDevicesRequest::ByteSizeLong,
              &listDevicesRequest::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(listDevicesRequest, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[0],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct listDevicesRequestGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr listDevicesRequestGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 listDevicesRequest_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(listDevicesRequest::InternalGenerateClassData_(
            _default, &listDevicesRequest_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<listDevicesRequest>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~listDevicesRequestGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) listDevicesRequest _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<listDevicesRequest>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(listDevicesRequestGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST listDevicesRequestGlobalsTypeInternal listDevicesRequest_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* listDevicesRequest_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return listDevicesRequest_globals_.GetClassData();
#else
  return listDevicesRequest_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class applyDevicePolicyResponse::_Internal {
 public:
  using HasBits = decltype(::std::declval<applyDevicePolicyResponse>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(applyDevicePolicyResponse, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

constexpr applyDevicePolicyResponse::ParseTableT_ applyDevicePolicyResponse::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(applyDevicePolicyResponse, _impl_._has_bits_),
      0, // no _extensions_
      2, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967293,  // skipmap
      offsetof(ParseTableT_, field_entries),
      1,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::applyDevicePolicyResponse>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // required uint32 rule_id = 2;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(applyDevicePolicyResponse, _impl_.rule_id_), 0>(),
       {16, 0, 0,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicyResponse, _impl_.rule_id_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required uint32 rule_id = 2;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicyResponse, _impl_.rule_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr applyDevicePolicyResponse::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : rule_id_{0u} {}

template <typename>
constexpr applyDevicePolicyResponse::applyDevicePolicyResponse(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL applyDevicePolicyResponse::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) applyDevicePolicyResponse(arena);
}
constexpr auto applyDevicePolicyResponse::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(applyDevicePolicyResponse), alignof(applyDevicePolicyResponse));
}
constexpr auto applyDevicePolicyResponse::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          applyDevicePolicyResponse::IsInitializedImpl,
          &applyDevicePolicyResponse::MergeImpl,
          Super_::GetNewImpl<applyDevicePolicyResponse>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &applyDevicePolicyResponse::SharedDtor,
          Super_::GetClearImpl<applyDevicePolicyResponse>(), &applyDevicePolicyResponse::ByteSizeLong,
              &applyDevicePolicyResponse::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(applyDevicePolicyResponse, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[4],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct applyDevicePolicyResponseGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr applyDevicePolicyResponseGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 applyDevicePolicyResponse_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(applyDevicePolicyResponse::InternalGenerateClassData_(
            _default, &applyDevicePolicyResponse_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<applyDevicePolicyResponse>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~applyDevicePolicyResponseGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) applyDevicePolicyResponse _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<applyDevicePolicyResponse>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(applyDevicePolicyResponseGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST applyDevicePolicyResponseGlobalsTypeInternal applyDevicePolicyResponse_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* applyDevicePolicyResponse_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return applyDevicePolicyResponse_globals_.GetClassData();
#else
  return applyDevicePolicyResponse_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class applyDevicePolicyRequest::_Internal {
 public:
  using HasBits = decltype(::std::declval<applyDevicePolicyRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

constexpr applyDevicePolicyRequest::ParseTableT_ applyDevicePolicyRequest::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::applyDevicePolicyRequest>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // required uint32 id = 1;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(applyDevicePolicyRequest, _impl_.id_), 0>(),
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.id_)}},
      // required uint32 target = 2;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(applyDevicePolicyRequest, _impl_.target_), 1>(),
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.target_)}},
      // required bool permanent = 3;
      {::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(applyDevicePolicyRequest, _impl_.permanent_), 2>(),
       {24, 2, 0,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.permanent_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required uint32 id = 1;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required uint32 target = 2;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.target_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required bool permanent = 3;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.permanent_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr applyDevicePolicyRequest::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : id_{0u},
        target_{0u},
        permanent_{false} {}

template <typename>
constexpr applyDevicePolicyRequest::applyDevicePolicyRequest(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL applyDevicePolicyRequest::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) applyDevicePolicyRequest(arena);
}
constexpr auto applyDevicePolicyRequest::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(applyDevicePolicyRequest), alignof(applyDevicePolicyRequest));
}
constexpr auto applyDevicePolicyRequest::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          applyDevicePolicyRequest::IsInitializedImpl,
          &applyDevicePolicyRequest::MergeImpl,
          Super_::GetNewImpl<applyDevicePolicyRequest>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &applyDevicePolicyRequest::SharedDtor,
          Super_::GetClearImpl<applyDevicePolicyRequest>(), &applyDevicePolicyRequest::ByteSizeLong,
              &applyDevicePolicyRequest::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[3],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct applyDevicePolicyRequestGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr applyDevicePolicyRequestGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 applyDevicePolicyRequest_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(applyDevicePolicyRequest::InternalGenerateClassData_(
            _default, &applyDevicePolicyRequest_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<applyDevicePolicyRequest>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~applyDevicePolicyRequestGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) applyDevicePolicyRequest _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<applyDevicePolicyRequest>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequestGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST applyDevicePolicyRequestGlobalsTypeInternal applyDevicePolicyRequest_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* applyDevicePolicyRequest_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return applyDevicePolicyRequest_globals_.GetClassData();
#else
  return applyDevicePolicyRequest_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class PropertyParameterChangedSignal::_Internal {
 public:
  using HasBits = decltype(::std::declval<PropertyParameterChangedSignal>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

constexpr PropertyParameterChangedSignal::ParseTableT_ PropertyParameterChangedSignal::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::PropertyParameterChangedSignal>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // required string name = 1;
      {::_pbi::TcParser::FastBS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_.name_)}},
      // required string value_old = 2;
      {::_pbi::TcParser::FastBS1,
       {18, 1, 0,
        PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_.value_old_)}},
      // required string value_new = 3;
      {::_pbi::TcParser::FastBS1,
       {26, 2, 0,
        PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_.value_new_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required string name = 1;
      {PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_.name_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // required string value_old = 2;
      {PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_.value_old_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // required string value_new = 3;
      {PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_.value_new_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr PropertyParameterChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        value_old_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        value_new_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()) {}

template <typename>
constexpr PropertyParameterChangedSignal::PropertyParameterChangedSignal(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL PropertyParameterChangedSignal::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) PropertyParameterChangedSignal(arena);
}
constexpr auto PropertyParameterChangedSignal::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PropertyParameterChangedSignal), alignof(PropertyParameterChangedSignal));
}
constexpr auto PropertyParameterChangedSignal::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          PropertyParameterChangedSignal::IsInitializedImpl,
          &PropertyParameterChangedSignal::MergeImpl,
          Super_::GetNewImpl<PropertyParameterChangedSignal>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &PropertyParameterChangedSignal::SharedDtor,
          Super_::GetClearImpl<PropertyParameterChangedSignal>(), &PropertyParameterChangedSignal::ByteSizeLong,
              &PropertyParameterChangedSignal::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignal, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[9],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct PropertyParameterChangedSignalGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr PropertyParameterChangedSignalGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 PropertyParameterChangedSignal_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(PropertyParameterChangedSignal::InternalGenerateClassData_(
            _default, &PropertyParameterChangedSignal_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<PropertyParameterChangedSignal>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~PropertyParameterChangedSignalGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) PropertyParameterChangedSignal _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<PropertyParameterChangedSignal>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(PropertyParameterChangedSignalGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST PropertyParameterChangedSignalGlobalsTypeInternal PropertyParameterChangedSignal_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* PropertyParameterChangedSignal_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return PropertyParameterChangedSignal_globals_.GetClassData();
#else
  return PropertyParameterChangedSignal_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class DevicePresenceChangedSignal::_Internal {
 public:
  using HasBits = decltype(::std::declval<DevicePresenceChangedSignal>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000000f) ^ 0x0000000f) != 0;
  }
};

constexpr DevicePresenceChangedSignal::ParseTableT_ DevicePresenceChangedSignal::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_._has_bits_),
      0, // no _extensions_
      4, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967280,  // skipmap
      offsetof(ParseTableT_, field_entries),
      4,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::DevicePresenceChangedSignal>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // required string device_rule = 4;
      {::_pbi::TcParser::FastBS1,
       {34, 0, 0,
        PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.device_rule_)}},
      // required uint32 id = 1;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePresenceChangedSignal, _impl_.id_), 1>(),
       {8, 1, 0,
        PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.id_)}},
      // required uint32 event = 2;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePresenceChangedSignal, _impl_.event_), 2>(),
       {16, 2, 0,
        PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.event_)}},
      // required uint32 target = 3;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePresenceChangedSignal, _impl_.target_), 3>(),
       {24, 3, 0,
        PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.target_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required uint32 id = 1;
      {PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.id_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required uint32 event = 2;
      {PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.event_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required uint32 target = 3;
      {PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.target_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required string device_rule = 4;
      {PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.device_rule_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr DevicePresenceChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : device_rule_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        id_{0u},
        event_{0u},
        target_{0u} {}

template <typename>
constexpr DevicePresenceChangedSignal::DevicePresenceChangedSignal(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL DevicePresenceChangedSignal::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) DevicePresenceChangedSignal(arena);
}
constexpr auto DevicePresenceChangedSignal::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(DevicePresenceChangedSignal), alignof(DevicePresenceChangedSignal));
}
constexpr auto DevicePresenceChangedSignal::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          DevicePresenceChangedSignal::IsInitializedImpl,
          &DevicePresenceChangedSignal::MergeImpl,
          Super_::GetNewImpl<DevicePresenceChangedSignal>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &DevicePresenceChangedSignal::SharedDtor,
          Super_::GetClearImpl<DevicePresenceChangedSignal>(), &DevicePresenceChangedSignal::ByteSizeLong,
              &DevicePresenceChangedSignal::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[6],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct DevicePresenceChangedSignalGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr DevicePresenceChangedSignalGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 DevicePresenceChangedSignal_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(DevicePresenceChangedSignal::InternalGenerateClassData_(
            _default, &DevicePresenceChangedSignal_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<DevicePresenceChangedSignal>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~DevicePresenceChangedSignalGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) DevicePresenceChangedSignal _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<DevicePresenceChangedSignal>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignalGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST DevicePresenceChangedSignalGlobalsTypeInternal DevicePresenceChangedSignal_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* DevicePresenceChangedSignal_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return DevicePresenceChangedSignal_globals_.GetClassData();
#else
  return DevicePresenceChangedSignal_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class DevicePolicyChangedSignal::_Internal {
 public:
  using HasBits = decltype(::std::declval<DevicePolicyChangedSignal>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000001f) ^ 0x0000001f) != 0;
  }
};

constexpr DevicePolicyChangedSignal::ParseTableT_ DevicePolicyChangedSignal::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_._has_bits_),
      0, // no _extensions_
      5, 56,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967264,  // skipmap
      offsetof(ParseTableT_, field_entries),
      5,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::DevicePolicyChangedSignal>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // required uint32 id = 1;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyChangedSignal, _impl_.id_), 1>(),
       {8, 1, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.id_)}},
      // required uint32 target_old = 2;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyChangedSignal, _impl_.target_old_), 2>(),
       {16, 2, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.target_old_)}},
      // required uint32 target_new = 3;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyChangedSignal, _impl_.target_new_), 3>(),
       {24, 3, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.target_new_)}},
      // required string device_rule = 4;
      {::_pbi::TcParser::FastBS1,
       {34, 0, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.device_rule_)}},
      // required uint32 rule_id = 5;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyChangedSignal, _impl_.rule_id_), 4>(),
       {40, 4, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.rule_id_)}},
      {::_pbi::TcParser::MiniParse, {}},
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // required uint32 id = 1;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.id_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required uint32 target_old = 2;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.target_old_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required uint32 target_new = 3;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.target_new_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required string device_rule = 4;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.device_rule_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // required uint32 rule_id = 5;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.rule_id_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr DevicePolicyChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : device_rule_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        id_{0u},
        target_old_{0u},
        target_new_{0u},
        rule_id_{0u} {}

template <typename>
constexpr DevicePolicyChangedSignal::DevicePolicyChangedSignal(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL DevicePolicyChangedSignal::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) DevicePolicyChangedSignal(arena);
}
constexpr auto DevicePolicyChangedSignal::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(DevicePolicyChangedSignal), alignof(DevicePolicyChangedSignal));
}
constexpr auto DevicePolicyChangedSignal::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          DevicePolicyChangedSignal::IsInitializedImpl,
          &DevicePolicyChangedSignal::MergeImpl,
          Super_::GetNewImpl<DevicePolicyChangedSignal>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &DevicePolicyChangedSignal::SharedDtor,
          Super_::GetClearImpl<DevicePolicyChangedSignal>(), &DevicePolicyChangedSignal::ByteSizeLong,
              &DevicePolicyChangedSignal::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[7],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct DevicePolicyChangedSignalGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr DevicePolicyChangedSignalGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 DevicePolicyChangedSignal_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(DevicePolicyChangedSignal::InternalGenerateClassData_(
            _default, &DevicePolicyChangedSignal_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<DevicePolicyChangedSignal>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~DevicePolicyChangedSignalGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) DevicePolicyChangedSignal _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<DevicePolicyChangedSignal>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignalGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST DevicePolicyChangedSignalGlobalsTypeInternal DevicePolicyChangedSignal_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* DevicePolicyChangedSignal_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return DevicePolicyChangedSignal_globals_.GetClassData();
#else
  return DevicePolicyChangedSignal_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class DevicePolicyAppliedSignal::_Internal {
 public:
  using HasBits = decltype(::std::declval<DevicePolicyAppliedSignal>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000000f) ^ 0x0000000f) != 0;
  }
};

constexpr DevicePolicyAppliedSignal::ParseTableT_ DevicePolicyAppliedSignal::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_._has_bits_),
      0, // no _extensions_
      4, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967280,  // skipmap
      offsetof(ParseTableT_, field_entries),
      4,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::DevicePolicyAppliedSignal>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // required uint32 rule_id = 4;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyAppliedSignal, _impl_.rule_id_), 3>(),
       {32, 3, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.rule_id_)}},
      // required uint32 id = 1;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyAppliedSignal, _impl_.id_), 1>(),
       {8, 1, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.id_)}},
      // required uint32 target_new = 2;
      {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(DevicePolicyAppliedSignal, _impl_.target_new_), 2>(),
       {16, 2, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.target_new_)}},
      // required string device_rule = 3;
      {::_pbi::TcParser::FastBS1,
       {26, 0, 0,
        PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.device_rule_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required uint32 id = 1;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.id_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required uint32 target_new = 2;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.target_new_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
      // required string device_rule = 3;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.device_rule_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // required uint32 rule_id = 4;
      {PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.rule_id_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr DevicePolicyAppliedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : device_rule_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        id_{0u},
        target_new_{0u},
        rule_id_{0u} {}

template <typename>
constexpr DevicePolicyAppliedSignal::DevicePolicyAppliedSignal(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL DevicePolicyAppliedSignal::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) DevicePolicyAppliedSignal(arena);
}
constexpr auto DevicePolicyAppliedSignal::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(DevicePolicyAppliedSignal), alignof(DevicePolicyAppliedSignal));
}
constexpr auto DevicePolicyAppliedSignal::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          DevicePolicyAppliedSignal::IsInitializedImpl,
          &DevicePolicyAppliedSignal::MergeImpl,
          Super_::GetNewImpl<DevicePolicyAppliedSignal>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &DevicePolicyAppliedSignal::SharedDtor,
          Super_::GetClearImpl<DevicePolicyAppliedSignal>(), &DevicePolicyAppliedSignal::ByteSizeLong,
              &DevicePolicyAppliedSignal::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[8],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct DevicePolicyAppliedSignalGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr DevicePolicyAppliedSignalGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 DevicePolicyAppliedSignal_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(DevicePolicyAppliedSignal::InternalGenerateClassData_(
            _default, &DevicePolicyAppliedSignal_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<DevicePolicyAppliedSignal>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~DevicePolicyAppliedSignalGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) DevicePolicyAppliedSignal _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<DevicePolicyAppliedSignal>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignalGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST DevicePolicyAppliedSignalGlobalsTypeInternal DevicePolicyAppliedSignal_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* DevicePolicyAppliedSignal_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return DevicePolicyAppliedSignal_globals_.GetClassData();
#else
  return DevicePolicyAppliedSignal_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class listDevicesResponse::_Internal {
 public:
  using HasBits = decltype(::std::declval<listDevicesResponse>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(listDevicesResponse, _impl_._has_bits_);
};

constexpr listDevicesResponse::ParseTableT_ listDevicesResponse::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(listDevicesResponse, _impl_._has_bits_),
      0, // no _extensions_
      1, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967294,  // skipmap
      offsetof(ParseTableT_, field_entries),
      1,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::listDevicesResponse>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated .usbguard.IPC.Rule devices = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(listDevicesResponse, _impl_.devices_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .usbguard.IPC.Rule devices = 1;
      {PROTOBUF_FIELD_OFFSET(listDevicesResponse, _impl_.devices_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::Rule>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::Rule_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr listDevicesResponse::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : devices_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::usbguard::IPC::listDevicesResponse,
            PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesResponse, _impl_.devices_)>()
         }
     {}

template <typename>
constexpr listDevicesResponse::listDevicesResponse(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL listDevicesResponse::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) listDevicesResponse(arena);
}
constexpr auto listDevicesResponse::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(listDevicesResponse), alignof(listDevicesResponse));
}
constexpr auto listDevicesResponse::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          listDevicesResponse::IsInitializedImpl,
          &listDevicesResponse::MergeImpl,
          Super_::GetNewImpl<listDevicesResponse>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &listDevicesResponse::SharedDtor,
          Super_::GetClearImpl<listDevicesResponse>(), &listDevicesResponse::ByteSizeLong,
              &listDevicesResponse::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(listDevicesResponse, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[1],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct listDevicesResponseGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr listDevicesResponseGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 listDevicesResponse_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(listDevicesResponse::InternalGenerateClassData_(
            _default, &listDevicesResponse_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<listDevicesResponse>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~listDevicesResponseGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) listDevicesResponse _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<listDevicesResponse>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(listDevicesResponseGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST listDevicesResponseGlobalsTypeInternal listDevicesResponse_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* listDevicesResponse_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return listDevicesResponse_globals_.GetClassData();
#else
  return listDevicesResponse_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class applyDevicePolicy::_Internal {
 public:
  using HasBits = decltype(::std::declval<applyDevicePolicy>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

constexpr applyDevicePolicy::ParseTableT_ applyDevicePolicy::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      3,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::applyDevicePolicy>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // required .usbguard.IPC.MessageHeader header = 1;
      {::_pbi::TcParser::FastMtS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.header_)}},
      // required .usbguard.IPC.applyDevicePolicyRequest request = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.request_)}},
      // optional .usbguard.IPC.applyDevicePolicyResponse response = 3;
      {::_pbi::TcParser::FastMtS1,
       {26, 2, 2,
        PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.response_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required .usbguard.IPC.MessageHeader header = 1;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.header_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // required .usbguard.IPC.applyDevicePolicyRequest request = 2;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.request_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .usbguard.IPC.applyDevicePolicyResponse response = 3;
      {PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.response_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::MessageHeader>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::MessageHeader_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::applyDevicePolicyRequest>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::applyDevicePolicyRequest_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::applyDevicePolicyResponse>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::applyDevicePolicyResponse_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr applyDevicePolicy::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : header_{nullptr},
        request_{nullptr},
        response_{nullptr} {}

template <typename>
constexpr applyDevicePolicy::applyDevicePolicy(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL applyDevicePolicy::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) applyDevicePolicy(arena);
}
constexpr auto applyDevicePolicy::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(applyDevicePolicy), alignof(applyDevicePolicy));
}
constexpr auto applyDevicePolicy::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          applyDevicePolicy::IsInitializedImpl,
          &applyDevicePolicy::MergeImpl,
          Super_::GetNewImpl<applyDevicePolicy>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &applyDevicePolicy::SharedDtor,
          Super_::GetClearImpl<applyDevicePolicy>(), &applyDevicePolicy::ByteSizeLong,
              &applyDevicePolicy::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[5],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct applyDevicePolicyGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr applyDevicePolicyGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 applyDevicePolicy_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(applyDevicePolicy::InternalGenerateClassData_(
            _default, &applyDevicePolicy_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<applyDevicePolicy>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~applyDevicePolicyGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) applyDevicePolicy _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<applyDevicePolicy>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(applyDevicePolicyGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST applyDevicePolicyGlobalsTypeInternal applyDevicePolicy_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* applyDevicePolicy_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return applyDevicePolicy_globals_.GetClassData();
#else
  return applyDevicePolicy_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class listDevices::_Internal {
 public:
  using HasBits = decltype(::std::declval<listDevices>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(listDevices, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

constexpr listDevices::ParseTableT_ listDevices::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(listDevices, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      3,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::MpUnknownFields,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::usbguard::IPC::listDevices>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // required .usbguard.IPC.MessageHeader header = 1;
      {::_pbi::TcParser::FastMtS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(listDevices, _impl_.header_)}},
      // required .usbguard.IPC.listDevicesRequest request = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(listDevices, _impl_.request_)}},
      // optional .usbguard.IPC.listDevicesResponse response = 3;
      {::_pbi::TcParser::FastMtS1,
       {26, 2, 2,
        PROTOBUF_FIELD_OFFSET(listDevices, _impl_.response_)}},
    }}, {{
      65535, 65535
    }}, {{
      // required .usbguard.IPC.MessageHeader header = 1;
      {PROTOBUF_FIELD_OFFSET(listDevices, _impl_.header_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // required .usbguard.IPC.listDevicesRequest request = 2;
      {PROTOBUF_FIELD_OFFSET(listDevices, _impl_.request_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .usbguard.IPC.listDevicesResponse response = 3;
      {PROTOBUF_FIELD_OFFSET(listDevices, _impl_.response_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::MessageHeader>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::MessageHeader_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::listDevicesRequest>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::listDevicesRequest_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::usbguard::IPC::listDevicesResponse>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::usbguard::IPC::listDevicesResponse_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr listDevices::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : header_{nullptr},
        request_{nullptr},
        response_{nullptr} {}

template <typename>
constexpr listDevices::listDevices(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : Super_(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL listDevices::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) listDevices(arena);
}
constexpr auto listDevices::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(listDevices), alignof(listDevices));
}
constexpr auto listDevices::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          listDevices::IsInitializedImpl,
          &listDevices::MergeImpl,
          Super_::GetNewImpl<listDevices>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &listDevices::SharedDtor,
          Super_::GetClearImpl<listDevices>(), &listDevices::ByteSizeLong,
              &listDevices::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(listDevices, _impl_._cached_size_),
          false,
      },
#ifdef PROTOBUF_MESSAGE_GLOBALS
      &file_reflection_data[2],
#else   // !PROTOBUF_MESSAGE_GLOBALS
      &::_pbi::kDescriptorMethods,
      &descriptor_table_Devices_2eproto,
      nullptr,  // tracker
#endif  // PROTOBUF_MESSAGE_GLOBALS
  };
}
struct listDevicesGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr listDevicesGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 listDevices_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(listDevices::InternalGenerateClassData_(
            _default, &listDevices_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<listDevices>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~listDevicesGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) listDevices _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<listDevices>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(listDevicesGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST listDevicesGlobalsTypeInternal listDevices_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* listDevices_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return listDevices_globals_.GetClassData();
#else
  return listDevices_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
}  // namespace IPC
}  // namespace usbguard
static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
    file_level_enum_descriptors_Devices_2eproto = nullptr;
static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
    file_level_service_descriptors_Devices_2eproto = nullptr;
const ::uint32_t
    TableStruct_Devices_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
        protodesc_cold) = {
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesRequest, _impl_._has_bits_),
        4, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesRequest, _impl_.query_),
        0,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesResponse, _impl_._has_bits_),
        4, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesResponse, _impl_.devices_),
        0,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevices, _impl_._has_bits_),
        6, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevices, _impl_.header_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevices, _impl_.request_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevices, _impl_.response_),
        0,
        1,
        2,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicyRequest, _impl_._has_bits_),
        6, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicyRequest, _impl_.id_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicyRequest, _impl_.target_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicyRequest, _impl_.permanent_),
        0,
        1,
        2,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicyResponse, _impl_._has_bits_),
        4, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicyResponse, _impl_.rule_id_),
        0,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicy, _impl_._has_bits_),
        6, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicy, _impl_.header_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicy, _impl_.request_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::applyDevicePolicy, _impl_.response_),
        0,
        1,
        2,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePresenceChangedSignal, _impl_._has_bits_),
        7, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePresenceChangedSignal, _impl_.id_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePresenceChangedSignal, _impl_.event_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePresenceChangedSignal, _impl_.target_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePresenceChangedSignal, _impl_.device_rule_),
        1,
        2,
        3,
        0,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyChangedSignal, _impl_._has_bits_),
        8, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyChangedSignal, _impl_.id_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyChangedSignal, _impl_.target_old_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyChangedSignal, _impl_.target_new_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyChangedSignal, _impl_.device_rule_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyChangedSignal, _impl_.rule_id_),
        1,
        2,
        3,
        0,
        4,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyAppliedSignal, _impl_._has_bits_),
        7, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyAppliedSignal, _impl_.id_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyAppliedSignal, _impl_.target_new_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyAppliedSignal, _impl_.device_rule_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::DevicePolicyAppliedSignal, _impl_.rule_id_),
        1,
        2,
        0,
        3,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::PropertyParameterChangedSignal, _impl_._has_bits_),
        6, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::PropertyParameterChangedSignal, _impl_.name_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::PropertyParameterChangedSignal, _impl_.value_old_),
        PROTOBUF_FIELD_OFFSET(::usbguard::IPC::PropertyParameterChangedSignal, _impl_.value_new_),
        0,
        1,
        2,
};

static const ::_pbi::MigrationSchema
    schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
        {0, sizeof(::usbguard::IPC::listDevicesRequest)},
        {5, sizeof(::usbguard::IPC::listDevicesResponse)},
        {10, sizeof(::usbguard::IPC::listDevices)},
        {19, sizeof(::usbguard::IPC::applyDevicePolicyRequest)},
        {28, sizeof(::usbguard::IPC::applyDevicePolicyResponse)},
        {33, sizeof(::usbguard::IPC::applyDevicePolicy)},
        {42, sizeof(::usbguard::IPC::DevicePresenceChangedSignal)},
        {53, sizeof(::usbguard::IPC::DevicePolicyChangedSignal)},
        {66, sizeof(::usbguard::IPC::DevicePolicyAppliedSignal)},
        {77, sizeof(::usbguard::IPC::PropertyParameterChangedSignal)},
};
static const ::_pbi::MessageGlobalsBase* PROTOBUF_NONNULL const
    file_message_globals[] = {
        &::usbguard::IPC::listDevicesRequest_globals_,
        &::usbguard::IPC::listDevicesResponse_globals_,
        &::usbguard::IPC::listDevices_globals_,
        &::usbguard::IPC::applyDevicePolicyRequest_globals_,
        &::usbguard::IPC::applyDevicePolicyResponse_globals_,
        &::usbguard::IPC::applyDevicePolicy_globals_,
        &::usbguard::IPC::DevicePresenceChangedSignal_globals_,
        &::usbguard::IPC::DevicePolicyChangedSignal_globals_,
        &::usbguard::IPC::DevicePolicyAppliedSignal_globals_,
        &::usbguard::IPC::PropertyParameterChangedSignal_globals_,
};
const char descriptor_table_protodef_Devices_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
    protodesc_cold) = {
    "\n\rDevices.proto\022\014usbguard.IPC\032\rMessage.p"
    "roto\032\nRule.proto\"#\n\022listDevicesRequest\022\r"
    "\n\005query\030\001 \002(\t\":\n\023listDevicesResponse\022#\n\007"
    "devices\030\001 \003(\0132\022.usbguard.IPC.Rule\"\242\001\n\013li"
    "stDevices\022+\n\006header\030\001 \002(\0132\033.usbguard.IPC"
    ".MessageHeader\0221\n\007request\030\002 \002(\0132 .usbgua"
    "rd.IPC.listDevicesRequest\0223\n\010response\030\003 "
    "\001(\0132!.usbguard.IPC.listDevicesResponse\"I"
    "\n\030applyDevicePolicyRequest\022\n\n\002id\030\001 \002(\r\022\016"
    "\n\006target\030\002 \002(\r\022\021\n\tpermanent\030\003 \002(\010\",\n\031app"
    "lyDevicePolicyResponse\022\017\n\007rule_id\030\002 \002(\r\""
    "\264\001\n\021applyDevicePolicy\022+\n\006header\030\001 \002(\0132\033."
    "usbguard.IPC.MessageHeader\0227\n\007request\030\002 "
    "\002(\0132&.usbguard.IPC.applyDevicePolicyRequ"
    "est\0229\n\010response\030\003 \001(\0132\'.usbguard.IPC.app"
    "lyDevicePolicyResponse\"]\n\033DevicePresence"
    "ChangedSignal\022\n\n\002id\030\001 \002(\r\022\r\n\005event\030\002 \002(\r"
    "\022\016\n\006target\030\003 \002(\r\022\023\n\013device_rule\030\004 \002(\t\"u\n"
    "\031DevicePolicyChangedSignal\022\n\n\002id\030\001 \002(\r\022\022"
    "\n\ntarget_old\030\002 \002(\r\022\022\n\ntarget_new\030\003 \002(\r\022\023"
    "\n\013device_rule\030\004 \002(\t\022\017\n\007rule_id\030\005 \002(\r\"a\n\031"
    "DevicePolicyAppliedSignal\022\n\n\002id\030\001 \002(\r\022\022\n"
    "\ntarget_new\030\002 \002(\r\022\023\n\013device_rule\030\003 \002(\t\022\017"
    "\n\007rule_id\030\004 \002(\r\"T\n\036PropertyParameterChan"
    "gedSignal\022\014\n\004name\030\001 \002(\t\022\021\n\tvalue_old\030\002 \002"
    "(\t\022\021\n\tvalue_new\030\003 \002(\t"
};
static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const
    descriptor_table_Devices_2eproto_deps[2] = {
        &::descriptor_table_Message_2eproto,
        &::descriptor_table_Rule_2eproto,
};
static ::absl::once_flag descriptor_table_Devices_2eproto_once;
PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_Devices_2eproto = {
    false,
    false,
    1021,
    descriptor_table_protodef_Devices_2eproto,
    "Devices.proto",
    &descriptor_table_Devices_2eproto_once,
    descriptor_table_Devices_2eproto_deps,
    2,
    10,
    schemas,
    file_message_globals,
    TableStruct_Devices_2eproto::offsets,
    file_level_enum_descriptors_Devices_2eproto,
    file_level_service_descriptors_Devices_2eproto,
};
namespace usbguard {
namespace IPC {
// ===================================================================

listDevicesRequest::listDevicesRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, listDevicesRequest_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.listDevicesRequest)
}
PROTOBUF_NDEBUG_INLINE listDevicesRequest::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::listDevicesRequest& from_msg)
      : _has_bits_{from._has_bits_},
        query_(arena, from.query_) {}

listDevicesRequest::listDevicesRequest(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const listDevicesRequest& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, listDevicesRequest_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  listDevicesRequest* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.listDevicesRequest)
}
PROTOBUF_NDEBUG_INLINE listDevicesRequest::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : query_(arena) {}

inline void listDevicesRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
listDevicesRequest::~listDevicesRequest() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.listDevicesRequest)
  SharedDtor(*this);
}
inline void listDevicesRequest::SharedDtor(MessageLite& self) {
  listDevicesRequest& this_ = static_cast<listDevicesRequest&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.query_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull listDevicesRequest_class_data_ =
        listDevicesRequest::InternalGenerateClassData_(listDevicesRequest_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
listDevicesRequest::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&listDevicesRequest_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(listDevicesRequest_class_data_.tc_table);
  return listDevicesRequest_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
listDevicesRequest::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&listDevicesRequest_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&listDevicesRequest_globals_));
  return listDevicesRequest_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const listDevicesRequest::ParseTableT_
    listDevicesRequest::_table_ =
        listDevicesRequest::InternalGenerateParseTable_(listDevicesRequest_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void listDevicesRequest::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.listDevicesRequest)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    this_._impl_.query_.ClearNonDefaultToEmpty();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL listDevicesRequest::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const listDevicesRequest& this_ = static_cast<const listDevicesRequest&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL listDevicesRequest::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const listDevicesRequest& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.listDevicesRequest)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required string query = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_query();
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.listDevicesRequest)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t listDevicesRequest::ByteSizeLong(const MessageLite& base) {
  const listDevicesRequest& this_ = static_cast<const listDevicesRequest&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t listDevicesRequest::ByteSizeLong() const {
  const listDevicesRequest& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.listDevicesRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

   {
    // required string query = 1;
    cached_has_bits = this_._impl_._has_bits_[0];
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_query());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void listDevicesRequest::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<listDevicesRequest*>(&to_msg);
  auto& from = static_cast<const listDevicesRequest&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.listDevicesRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _this->_internal_set_query(from._internal_query());
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void listDevicesRequest::CopyFrom(const listDevicesRequest& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.listDevicesRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool listDevicesRequest::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const listDevicesRequest&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void listDevicesRequest::InternalSwap(listDevicesRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.query_, &other->_impl_.query_, arena);
}

::google::protobuf::Metadata listDevicesRequest::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

void listDevicesResponse::clear_devices() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.devices_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
listDevicesResponse::listDevicesResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, listDevicesResponse_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.listDevicesResponse)
}
PROTOBUF_NDEBUG_INLINE listDevicesResponse::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::listDevicesResponse& from_msg)
      : _has_bits_{from._has_bits_},
        devices_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::usbguard::IPC::listDevicesResponse,
              PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesResponse, _impl_.devices_)>()
          , arena, from.devices_
        }
     {}

listDevicesResponse::listDevicesResponse(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const listDevicesResponse& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, listDevicesResponse_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  listDevicesResponse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.listDevicesResponse)
}
PROTOBUF_NDEBUG_INLINE listDevicesResponse::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : devices_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::usbguard::IPC::listDevicesResponse,
            PROTOBUF_FIELD_OFFSET(::usbguard::IPC::listDevicesResponse, _impl_.devices_)>()
         }
     {}

inline void listDevicesResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
listDevicesResponse::~listDevicesResponse() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.listDevicesResponse)
  SharedDtor(*this);
}
inline void listDevicesResponse::SharedDtor(MessageLite& self) {
  listDevicesResponse& this_ = static_cast<listDevicesResponse&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull listDevicesResponse_class_data_ =
        listDevicesResponse::InternalGenerateClassData_(listDevicesResponse_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
listDevicesResponse::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&listDevicesResponse_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(listDevicesResponse_class_data_.tc_table);
  return listDevicesResponse_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
listDevicesResponse::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&listDevicesResponse_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&listDevicesResponse_globals_));
  return listDevicesResponse_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const listDevicesResponse::ParseTableT_
    listDevicesResponse::_table_ =
        listDevicesResponse::InternalGenerateParseTable_(listDevicesResponse_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void listDevicesResponse::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.listDevicesResponse)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _impl_.devices_.Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL listDevicesResponse::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const listDevicesResponse& this_ = static_cast<const listDevicesResponse&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL listDevicesResponse::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const listDevicesResponse& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.listDevicesResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .usbguard.IPC.Rule devices = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_devices_size());
         i < n; i++) {
      const auto& repfield = this_._internal_devices().Get(i);
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          1, repfield, repfield.GetCachedSize(), target,
          stream);
    }
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.listDevicesResponse)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t listDevicesResponse::ByteSizeLong(const MessageLite& base) {
  const listDevicesResponse& this_ = static_cast<const listDevicesResponse&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t listDevicesResponse::ByteSizeLong() const {
  const listDevicesResponse& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.listDevicesResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
   {
    // repeated .usbguard.IPC.Rule devices = 1;
    cached_has_bits = this_._impl_._has_bits_[0];
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_devices_size();
      for (const auto& msg : this_._internal_devices()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void listDevicesResponse::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<listDevicesResponse*>(&to_msg);
  auto& from = static_cast<const listDevicesResponse&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.listDevicesResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _this->_internal_mutable_devices()->InternalMergeFromWithArena(
        ::google::protobuf::MessageLite::internal_visibility(), arena,
        from._internal_devices());
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void listDevicesResponse::CopyFrom(const listDevicesResponse& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.listDevicesResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool listDevicesResponse::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const listDevicesResponse&>(msg);
  if (!::google::protobuf::internal::AllAreInitialized(this_._internal_devices()))
    return false;
  return true;
}

void listDevicesResponse::InternalSwap(listDevicesResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.devices_.InternalSwap(&other->_impl_.devices_);
}

::google::protobuf::Metadata listDevicesResponse::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

void listDevices::clear_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.header_ != nullptr) _impl_.header_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
listDevices::listDevices(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, listDevices_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.listDevices)
}
PROTOBUF_NDEBUG_INLINE listDevices::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::listDevices& from_msg)
      : _has_bits_{from._has_bits_} {}

listDevices::listDevices(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const listDevices& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, listDevices_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  listDevices* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.header_ = (CheckHasBit(cached_has_bits, 0x00000001U))
                 ? Super_::CopyConstruct(arena, *from._impl_.header_)
                 : nullptr;
  _impl_.request_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                 ? Super_::CopyConstruct(arena, *from._impl_.request_)
                 : nullptr;
  _impl_.response_ = (CheckHasBit(cached_has_bits, 0x00000004U))
                 ? Super_::CopyConstruct(arena, *from._impl_.response_)
                 : nullptr;

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.listDevices)
}
PROTOBUF_NDEBUG_INLINE listDevices::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
     {}

inline void listDevices::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, header_),
           0,
           offsetof(Impl_, response_) -
               offsetof(Impl_, header_) +
               sizeof(Impl_::response_));
}
listDevices::~listDevices() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.listDevices)
  SharedDtor(*this);
}
inline void listDevices::SharedDtor(MessageLite& self) {
  listDevices& this_ = static_cast<listDevices&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.header_;
  delete this_._impl_.request_;
  delete this_._impl_.response_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull listDevices_class_data_ =
        listDevices::InternalGenerateClassData_(listDevices_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
listDevices::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&listDevices_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(listDevices_class_data_.tc_table);
  return listDevices_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
listDevices::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&listDevices_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&listDevices_globals_));
  return listDevices_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const listDevices::ParseTableT_
    listDevices::_table_ =
        listDevices::InternalGenerateParseTable_(listDevices_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void listDevices::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.listDevices)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(this_._impl_.header_ != nullptr);
      this_._impl_.header_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(this_._impl_.request_ != nullptr);
      this_._impl_.request_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(this_._impl_.response_ != nullptr);
      this_._impl_.response_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL listDevices::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const listDevices& this_ = static_cast<const listDevices&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL listDevices::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const listDevices& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.listDevices)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required .usbguard.IPC.MessageHeader header = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.header_, this_._impl_.header_->GetCachedSize(), target,
        stream);
  }

  // required .usbguard.IPC.listDevicesRequest request = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.request_, this_._impl_.request_->GetCachedSize(), target,
        stream);
  }

  // optional .usbguard.IPC.listDevicesResponse response = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        3, *this_._impl_.response_, this_._impl_.response_->GetCachedSize(), target,
        stream);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.listDevices)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t listDevices::ByteSizeLong(const MessageLite& base) {
  const listDevices& this_ = static_cast<const listDevices&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t listDevices::ByteSizeLong() const {
  const listDevices& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.listDevices)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // required .usbguard.IPC.MessageHeader header = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.header_);
    }
    // required .usbguard.IPC.listDevicesRequest request = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_);
    }
  }
   {
    // optional .usbguard.IPC.listDevicesResponse response = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_);
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void listDevices::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<listDevices*>(&to_msg);
  auto& from = static_cast<const listDevices&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.listDevices)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(from._impl_.header_ != nullptr);
      if (_this->_impl_.header_ == nullptr) {
        _this->_impl_.header_ = Super_::CopyConstruct(arena, *from._impl_.header_);
      } else {
        _this->_impl_.header_->MergeFrom(*from._impl_.header_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.request_ != nullptr);
      if (_this->_impl_.request_ == nullptr) {
        _this->_impl_.request_ = Super_::CopyConstruct(arena, *from._impl_.request_);
      } else {
        _this->_impl_.request_->MergeFrom(*from._impl_.request_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(from._impl_.response_ != nullptr);
      if (_this->_impl_.response_ == nullptr) {
        _this->_impl_.response_ = Super_::CopyConstruct(arena, *from._impl_.response_);
      } else {
        _this->_impl_.response_->MergeFrom(*from._impl_.response_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void listDevices::CopyFrom(const listDevices& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.listDevices)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool listDevices::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const listDevices&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000001U)) {
    if (!this_._impl_.header_->IsInitialized()) return false;
  }
  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000002U)) {
    if (!this_._impl_.request_->IsInitialized()) return false;
  }
  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000004U)) {
    if (!this_._impl_.response_->IsInitialized()) return false;
  }
  return true;
}

void listDevices::InternalSwap(listDevices* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(listDevices, _impl_.response_)
      + sizeof(listDevices::_impl_.response_)
      - PROTOBUF_FIELD_OFFSET(listDevices, _impl_.header_)>(
          reinterpret_cast<char*>(&_impl_.header_),
          reinterpret_cast<char*>(&other->_impl_.header_));
}

::google::protobuf::Metadata listDevices::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

applyDevicePolicyRequest::applyDevicePolicyRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, applyDevicePolicyRequest_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.applyDevicePolicyRequest)
}
applyDevicePolicyRequest::applyDevicePolicyRequest(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const applyDevicePolicyRequest& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, applyDevicePolicyRequest_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE applyDevicePolicyRequest::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
     {}

inline void applyDevicePolicyRequest::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           0,
           offsetof(Impl_, permanent_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::permanent_));
}
applyDevicePolicyRequest::~applyDevicePolicyRequest() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.applyDevicePolicyRequest)
  SharedDtor(*this);
}
inline void applyDevicePolicyRequest::SharedDtor(MessageLite& self) {
  applyDevicePolicyRequest& this_ = static_cast<applyDevicePolicyRequest&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull applyDevicePolicyRequest_class_data_ =
        applyDevicePolicyRequest::InternalGenerateClassData_(applyDevicePolicyRequest_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
applyDevicePolicyRequest::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&applyDevicePolicyRequest_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(applyDevicePolicyRequest_class_data_.tc_table);
  return applyDevicePolicyRequest_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
applyDevicePolicyRequest::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&applyDevicePolicyRequest_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&applyDevicePolicyRequest_globals_));
  return applyDevicePolicyRequest_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const applyDevicePolicyRequest::ParseTableT_
    applyDevicePolicyRequest::_table_ =
        applyDevicePolicyRequest::InternalGenerateParseTable_(applyDevicePolicyRequest_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void applyDevicePolicyRequest::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.applyDevicePolicyRequest)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    ::memset(&this_._impl_.id_, 0,
             static_cast<::size_t>(
                 reinterpret_cast<char*>(&this_._impl_.permanent_) -
                 reinterpret_cast<char*>(&this_._impl_.id_)) +
                 sizeof(_impl_.permanent_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL applyDevicePolicyRequest::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const applyDevicePolicyRequest& this_ = static_cast<const applyDevicePolicyRequest&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL applyDevicePolicyRequest::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const applyDevicePolicyRequest& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.applyDevicePolicyRequest)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required uint32 id = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        1, this_._internal_id(), target);
  }

  // required uint32 target = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_target(), target);
  }

  // required bool permanent = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        3, this_._internal_permanent(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.applyDevicePolicyRequest)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t applyDevicePolicyRequest::ByteSizeLong(const MessageLite& base) {
  const applyDevicePolicyRequest& this_ = static_cast<const applyDevicePolicyRequest&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t applyDevicePolicyRequest::ByteSizeLong() const {
  const applyDevicePolicyRequest& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.applyDevicePolicyRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000004U & cached_has_bits) * 2;
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // required uint32 id = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_id());
    }
    // required uint32 target = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_target());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void applyDevicePolicyRequest::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<applyDevicePolicyRequest*>(&to_msg);
  auto& from = static_cast<const applyDevicePolicyRequest&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.applyDevicePolicyRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.id_ = from._impl_.id_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.target_ = from._impl_.target_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.permanent_ = from._impl_.permanent_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void applyDevicePolicyRequest::CopyFrom(const applyDevicePolicyRequest& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.applyDevicePolicyRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool applyDevicePolicyRequest::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const applyDevicePolicyRequest&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void applyDevicePolicyRequest::InternalSwap(applyDevicePolicyRequest* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.permanent_)
      + sizeof(applyDevicePolicyRequest::_impl_.permanent_)
      - PROTOBUF_FIELD_OFFSET(applyDevicePolicyRequest, _impl_.id_)>(
          reinterpret_cast<char*>(&_impl_.id_),
          reinterpret_cast<char*>(&other->_impl_.id_));
}

::google::protobuf::Metadata applyDevicePolicyRequest::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

applyDevicePolicyResponse::applyDevicePolicyResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, applyDevicePolicyResponse_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.applyDevicePolicyResponse)
}
applyDevicePolicyResponse::applyDevicePolicyResponse(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const applyDevicePolicyResponse& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, applyDevicePolicyResponse_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE applyDevicePolicyResponse::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
     {}

inline void applyDevicePolicyResponse::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.rule_id_ = {};
}
applyDevicePolicyResponse::~applyDevicePolicyResponse() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.applyDevicePolicyResponse)
  SharedDtor(*this);
}
inline void applyDevicePolicyResponse::SharedDtor(MessageLite& self) {
  applyDevicePolicyResponse& this_ = static_cast<applyDevicePolicyResponse&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull applyDevicePolicyResponse_class_data_ =
        applyDevicePolicyResponse::InternalGenerateClassData_(applyDevicePolicyResponse_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
applyDevicePolicyResponse::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&applyDevicePolicyResponse_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(applyDevicePolicyResponse_class_data_.tc_table);
  return applyDevicePolicyResponse_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
applyDevicePolicyResponse::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&applyDevicePolicyResponse_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&applyDevicePolicyResponse_globals_));
  return applyDevicePolicyResponse_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const applyDevicePolicyResponse::ParseTableT_
    applyDevicePolicyResponse::_table_ =
        applyDevicePolicyResponse::InternalGenerateParseTable_(applyDevicePolicyResponse_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void applyDevicePolicyResponse::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.applyDevicePolicyResponse)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  this_._impl_.rule_id_ = 0u;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL applyDevicePolicyResponse::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const applyDevicePolicyResponse& this_ = static_cast<const applyDevicePolicyResponse&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL applyDevicePolicyResponse::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const applyDevicePolicyResponse& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.applyDevicePolicyResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required uint32 rule_id = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_rule_id(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.applyDevicePolicyResponse)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t applyDevicePolicyResponse::ByteSizeLong(const MessageLite& base) {
  const applyDevicePolicyResponse& this_ = static_cast<const applyDevicePolicyResponse&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t applyDevicePolicyResponse::ByteSizeLong() const {
  const applyDevicePolicyResponse& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.applyDevicePolicyResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

   {
    // required uint32 rule_id = 2;
    cached_has_bits = this_._impl_._has_bits_[0];
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_rule_id());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void applyDevicePolicyResponse::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<applyDevicePolicyResponse*>(&to_msg);
  auto& from = static_cast<const applyDevicePolicyResponse&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.applyDevicePolicyResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _this->_impl_.rule_id_ = from._impl_.rule_id_;
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void applyDevicePolicyResponse::CopyFrom(const applyDevicePolicyResponse& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.applyDevicePolicyResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool applyDevicePolicyResponse::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const applyDevicePolicyResponse&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void applyDevicePolicyResponse::InternalSwap(applyDevicePolicyResponse* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.rule_id_, other->_impl_.rule_id_);
}

::google::protobuf::Metadata applyDevicePolicyResponse::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

void applyDevicePolicy::clear_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.header_ != nullptr) _impl_.header_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
applyDevicePolicy::applyDevicePolicy(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, applyDevicePolicy_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.applyDevicePolicy)
}
PROTOBUF_NDEBUG_INLINE applyDevicePolicy::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::applyDevicePolicy& from_msg)
      : _has_bits_{from._has_bits_} {}

applyDevicePolicy::applyDevicePolicy(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const applyDevicePolicy& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, applyDevicePolicy_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  applyDevicePolicy* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.header_ = (CheckHasBit(cached_has_bits, 0x00000001U))
                 ? Super_::CopyConstruct(arena, *from._impl_.header_)
                 : nullptr;
  _impl_.request_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                 ? Super_::CopyConstruct(arena, *from._impl_.request_)
                 : nullptr;
  _impl_.response_ = (CheckHasBit(cached_has_bits, 0x00000004U))
                 ? Super_::CopyConstruct(arena, *from._impl_.response_)
                 : nullptr;

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.applyDevicePolicy)
}
PROTOBUF_NDEBUG_INLINE applyDevicePolicy::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
     {}

inline void applyDevicePolicy::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, header_),
           0,
           offsetof(Impl_, response_) -
               offsetof(Impl_, header_) +
               sizeof(Impl_::response_));
}
applyDevicePolicy::~applyDevicePolicy() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.applyDevicePolicy)
  SharedDtor(*this);
}
inline void applyDevicePolicy::SharedDtor(MessageLite& self) {
  applyDevicePolicy& this_ = static_cast<applyDevicePolicy&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.header_;
  delete this_._impl_.request_;
  delete this_._impl_.response_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull applyDevicePolicy_class_data_ =
        applyDevicePolicy::InternalGenerateClassData_(applyDevicePolicy_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
applyDevicePolicy::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&applyDevicePolicy_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(applyDevicePolicy_class_data_.tc_table);
  return applyDevicePolicy_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
applyDevicePolicy::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&applyDevicePolicy_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&applyDevicePolicy_globals_));
  return applyDevicePolicy_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const applyDevicePolicy::ParseTableT_
    applyDevicePolicy::_table_ =
        applyDevicePolicy::InternalGenerateParseTable_(applyDevicePolicy_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void applyDevicePolicy::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.applyDevicePolicy)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(this_._impl_.header_ != nullptr);
      this_._impl_.header_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(this_._impl_.request_ != nullptr);
      this_._impl_.request_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(this_._impl_.response_ != nullptr);
      this_._impl_.response_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL applyDevicePolicy::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const applyDevicePolicy& this_ = static_cast<const applyDevicePolicy&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL applyDevicePolicy::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const applyDevicePolicy& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.applyDevicePolicy)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required .usbguard.IPC.MessageHeader header = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.header_, this_._impl_.header_->GetCachedSize(), target,
        stream);
  }

  // required .usbguard.IPC.applyDevicePolicyRequest request = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.request_, this_._impl_.request_->GetCachedSize(), target,
        stream);
  }

  // optional .usbguard.IPC.applyDevicePolicyResponse response = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        3, *this_._impl_.response_, this_._impl_.response_->GetCachedSize(), target,
        stream);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.applyDevicePolicy)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t applyDevicePolicy::ByteSizeLong(const MessageLite& base) {
  const applyDevicePolicy& this_ = static_cast<const applyDevicePolicy&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t applyDevicePolicy::ByteSizeLong() const {
  const applyDevicePolicy& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.applyDevicePolicy)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // required .usbguard.IPC.MessageHeader header = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.header_);
    }
    // required .usbguard.IPC.applyDevicePolicyRequest request = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.request_);
    }
  }
   {
    // optional .usbguard.IPC.applyDevicePolicyResponse response = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.response_);
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void applyDevicePolicy::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<applyDevicePolicy*>(&to_msg);
  auto& from = static_cast<const applyDevicePolicy&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.applyDevicePolicy)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(from._impl_.header_ != nullptr);
      if (_this->_impl_.header_ == nullptr) {
        _this->_impl_.header_ = Super_::CopyConstruct(arena, *from._impl_.header_);
      } else {
        _this->_impl_.header_->MergeFrom(*from._impl_.header_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.request_ != nullptr);
      if (_this->_impl_.request_ == nullptr) {
        _this->_impl_.request_ = Super_::CopyConstruct(arena, *from._impl_.request_);
      } else {
        _this->_impl_.request_->MergeFrom(*from._impl_.request_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(from._impl_.response_ != nullptr);
      if (_this->_impl_.response_ == nullptr) {
        _this->_impl_.response_ = Super_::CopyConstruct(arena, *from._impl_.response_);
      } else {
        _this->_impl_.response_->MergeFrom(*from._impl_.response_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void applyDevicePolicy::CopyFrom(const applyDevicePolicy& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.applyDevicePolicy)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool applyDevicePolicy::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const applyDevicePolicy&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000001U)) {
    if (!this_._impl_.header_->IsInitialized()) return false;
  }
  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000002U)) {
    if (!this_._impl_.request_->IsInitialized()) return false;
  }
  if (CheckHasBit(this_._impl_._has_bits_[0], 0x00000004U)) {
    if (!this_._impl_.response_->IsInitialized()) return false;
  }
  return true;
}

void applyDevicePolicy::InternalSwap(applyDevicePolicy* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.response_)
      + sizeof(applyDevicePolicy::_impl_.response_)
      - PROTOBUF_FIELD_OFFSET(applyDevicePolicy, _impl_.header_)>(
          reinterpret_cast<char*>(&_impl_.header_),
          reinterpret_cast<char*>(&other->_impl_.header_));
}

::google::protobuf::Metadata applyDevicePolicy::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

DevicePresenceChangedSignal::DevicePresenceChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, DevicePresenceChangedSignal_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.DevicePresenceChangedSignal)
}
PROTOBUF_NDEBUG_INLINE DevicePresenceChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::DevicePresenceChangedSignal& from_msg)
      : _has_bits_{from._has_bits_},
        device_rule_(arena, from.device_rule_) {}

DevicePresenceChangedSignal::DevicePresenceChangedSignal(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const DevicePresenceChangedSignal& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, DevicePresenceChangedSignal_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  DevicePresenceChangedSignal* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, id_),
           offsetof(Impl_, target_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::target_));

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.DevicePresenceChangedSignal)
}
PROTOBUF_NDEBUG_INLINE DevicePresenceChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : device_rule_(arena) {}

inline void DevicePresenceChangedSignal::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           0,
           offsetof(Impl_, target_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::target_));
}
DevicePresenceChangedSignal::~DevicePresenceChangedSignal() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.DevicePresenceChangedSignal)
  SharedDtor(*this);
}
inline void DevicePresenceChangedSignal::SharedDtor(MessageLite& self) {
  DevicePresenceChangedSignal& this_ = static_cast<DevicePresenceChangedSignal&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.device_rule_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull DevicePresenceChangedSignal_class_data_ =
        DevicePresenceChangedSignal::InternalGenerateClassData_(DevicePresenceChangedSignal_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DevicePresenceChangedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&DevicePresenceChangedSignal_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(DevicePresenceChangedSignal_class_data_.tc_table);
  return DevicePresenceChangedSignal_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DevicePresenceChangedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&DevicePresenceChangedSignal_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&DevicePresenceChangedSignal_globals_));
  return DevicePresenceChangedSignal_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const DevicePresenceChangedSignal::ParseTableT_
    DevicePresenceChangedSignal::_table_ =
        DevicePresenceChangedSignal::InternalGenerateParseTable_(DevicePresenceChangedSignal_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void DevicePresenceChangedSignal::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.DevicePresenceChangedSignal)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    this_._impl_.device_rule_.ClearNonDefaultToEmpty();
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000000eU)) {
    ::memset(&this_._impl_.id_, 0,
             static_cast<::size_t>(
                 reinterpret_cast<char*>(&this_._impl_.target_) -
                 reinterpret_cast<char*>(&this_._impl_.id_)) +
                 sizeof(_impl_.target_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL DevicePresenceChangedSignal::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const DevicePresenceChangedSignal& this_ = static_cast<const DevicePresenceChangedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL DevicePresenceChangedSignal::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const DevicePresenceChangedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.DevicePresenceChangedSignal)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required uint32 id = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        1, this_._internal_id(), target);
  }

  // required uint32 event = 2;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_event(), target);
  }

  // required uint32 target = 3;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        3, this_._internal_target(), target);
  }

  // required string device_rule = 4;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_device_rule();
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.DevicePresenceChangedSignal)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t DevicePresenceChangedSignal::ByteSizeLong(const MessageLite& base) {
  const DevicePresenceChangedSignal& this_ = static_cast<const DevicePresenceChangedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t DevicePresenceChangedSignal::ByteSizeLong() const {
  const DevicePresenceChangedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.DevicePresenceChangedSignal)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    // required string device_rule = 4;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_device_rule());
    }
    // required uint32 id = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_id());
    }
    // required uint32 event = 2;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_event());
    }
    // required uint32 target = 3;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_target());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void DevicePresenceChangedSignal::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<DevicePresenceChangedSignal*>(&to_msg);
  auto& from = static_cast<const DevicePresenceChangedSignal&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.DevicePresenceChangedSignal)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_set_device_rule(from._internal_device_rule());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.id_ = from._impl_.id_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.event_ = from._impl_.event_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.target_ = from._impl_.target_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void DevicePresenceChangedSignal::CopyFrom(const DevicePresenceChangedSignal& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.DevicePresenceChangedSignal)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool DevicePresenceChangedSignal::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const DevicePresenceChangedSignal&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void DevicePresenceChangedSignal::InternalSwap(DevicePresenceChangedSignal* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.device_rule_, &other->_impl_.device_rule_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.target_)
      + sizeof(DevicePresenceChangedSignal::_impl_.target_)
      - PROTOBUF_FIELD_OFFSET(DevicePresenceChangedSignal, _impl_.id_)>(
          reinterpret_cast<char*>(&_impl_.id_),
          reinterpret_cast<char*>(&other->_impl_.id_));
}

::google::protobuf::Metadata DevicePresenceChangedSignal::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

DevicePolicyChangedSignal::DevicePolicyChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, DevicePolicyChangedSignal_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.DevicePolicyChangedSignal)
}
PROTOBUF_NDEBUG_INLINE DevicePolicyChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::DevicePolicyChangedSignal& from_msg)
      : _has_bits_{from._has_bits_},
        device_rule_(arena, from.device_rule_) {}

DevicePolicyChangedSignal::DevicePolicyChangedSignal(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const DevicePolicyChangedSignal& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, DevicePolicyChangedSignal_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  DevicePolicyChangedSignal* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, id_),
           offsetof(Impl_, rule_id_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::rule_id_));

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.DevicePolicyChangedSignal)
}
PROTOBUF_NDEBUG_INLINE DevicePolicyChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : device_rule_(arena) {}

inline void DevicePolicyChangedSignal::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           0,
           offsetof(Impl_, rule_id_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::rule_id_));
}
DevicePolicyChangedSignal::~DevicePolicyChangedSignal() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.DevicePolicyChangedSignal)
  SharedDtor(*this);
}
inline void DevicePolicyChangedSignal::SharedDtor(MessageLite& self) {
  DevicePolicyChangedSignal& this_ = static_cast<DevicePolicyChangedSignal&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.device_rule_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull DevicePolicyChangedSignal_class_data_ =
        DevicePolicyChangedSignal::InternalGenerateClassData_(DevicePolicyChangedSignal_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DevicePolicyChangedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&DevicePolicyChangedSignal_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(DevicePolicyChangedSignal_class_data_.tc_table);
  return DevicePolicyChangedSignal_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DevicePolicyChangedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&DevicePolicyChangedSignal_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&DevicePolicyChangedSignal_globals_));
  return DevicePolicyChangedSignal_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const DevicePolicyChangedSignal::ParseTableT_
    DevicePolicyChangedSignal::_table_ =
        DevicePolicyChangedSignal::InternalGenerateParseTable_(DevicePolicyChangedSignal_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void DevicePolicyChangedSignal::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.DevicePolicyChangedSignal)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    this_._impl_.device_rule_.ClearNonDefaultToEmpty();
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000001eU)) {
    ::memset(&this_._impl_.id_, 0,
             static_cast<::size_t>(
                 reinterpret_cast<char*>(&this_._impl_.rule_id_) -
                 reinterpret_cast<char*>(&this_._impl_.id_)) +
                 sizeof(_impl_.rule_id_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL DevicePolicyChangedSignal::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const DevicePolicyChangedSignal& this_ = static_cast<const DevicePolicyChangedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL DevicePolicyChangedSignal::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const DevicePolicyChangedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.DevicePolicyChangedSignal)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required uint32 id = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        1, this_._internal_id(), target);
  }

  // required uint32 target_old = 2;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_target_old(), target);
  }

  // required uint32 target_new = 3;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        3, this_._internal_target_new(), target);
  }

  // required string device_rule = 4;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_device_rule();
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }

  // required uint32 rule_id = 5;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        5, this_._internal_rule_id(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.DevicePolicyChangedSignal)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t DevicePolicyChangedSignal::ByteSizeLong(const MessageLite& base) {
  const DevicePolicyChangedSignal& this_ = static_cast<const DevicePolicyChangedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t DevicePolicyChangedSignal::ByteSizeLong() const {
  const DevicePolicyChangedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.DevicePolicyChangedSignal)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {
    // required string device_rule = 4;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_device_rule());
    }
    // required uint32 id = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_id());
    }
    // required uint32 target_old = 2;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_target_old());
    }
    // required uint32 target_new = 3;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_target_new());
    }
    // required uint32 rule_id = 5;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_rule_id());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void DevicePolicyChangedSignal::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<DevicePolicyChangedSignal*>(&to_msg);
  auto& from = static_cast<const DevicePolicyChangedSignal&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.DevicePolicyChangedSignal)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_set_device_rule(from._internal_device_rule());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.id_ = from._impl_.id_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.target_old_ = from._impl_.target_old_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.target_new_ = from._impl_.target_new_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.rule_id_ = from._impl_.rule_id_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void DevicePolicyChangedSignal::CopyFrom(const DevicePolicyChangedSignal& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.DevicePolicyChangedSignal)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool DevicePolicyChangedSignal::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const DevicePolicyChangedSignal&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void DevicePolicyChangedSignal::InternalSwap(DevicePolicyChangedSignal* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.device_rule_, &other->_impl_.device_rule_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.rule_id_)
      + sizeof(DevicePolicyChangedSignal::_impl_.rule_id_)
      - PROTOBUF_FIELD_OFFSET(DevicePolicyChangedSignal, _impl_.id_)>(
          reinterpret_cast<char*>(&_impl_.id_),
          reinterpret_cast<char*>(&other->_impl_.id_));
}

::google::protobuf::Metadata DevicePolicyChangedSignal::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

DevicePolicyAppliedSignal::DevicePolicyAppliedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, DevicePolicyAppliedSignal_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.DevicePolicyAppliedSignal)
}
PROTOBUF_NDEBUG_INLINE DevicePolicyAppliedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::DevicePolicyAppliedSignal& from_msg)
      : _has_bits_{from._has_bits_},
        device_rule_(arena, from.device_rule_) {}

DevicePolicyAppliedSignal::DevicePolicyAppliedSignal(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const DevicePolicyAppliedSignal& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, DevicePolicyAppliedSignal_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  DevicePolicyAppliedSignal* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, id_),
           offsetof(Impl_, rule_id_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::rule_id_));

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.DevicePolicyAppliedSignal)
}
PROTOBUF_NDEBUG_INLINE DevicePolicyAppliedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : device_rule_(arena) {}

inline void DevicePolicyAppliedSignal::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, id_),
           0,
           offsetof(Impl_, rule_id_) -
               offsetof(Impl_, id_) +
               sizeof(Impl_::rule_id_));
}
DevicePolicyAppliedSignal::~DevicePolicyAppliedSignal() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.DevicePolicyAppliedSignal)
  SharedDtor(*this);
}
inline void DevicePolicyAppliedSignal::SharedDtor(MessageLite& self) {
  DevicePolicyAppliedSignal& this_ = static_cast<DevicePolicyAppliedSignal&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.device_rule_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull DevicePolicyAppliedSignal_class_data_ =
        DevicePolicyAppliedSignal::InternalGenerateClassData_(DevicePolicyAppliedSignal_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DevicePolicyAppliedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&DevicePolicyAppliedSignal_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(DevicePolicyAppliedSignal_class_data_.tc_table);
  return DevicePolicyAppliedSignal_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
DevicePolicyAppliedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&DevicePolicyAppliedSignal_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&DevicePolicyAppliedSignal_globals_));
  return DevicePolicyAppliedSignal_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const DevicePolicyAppliedSignal::ParseTableT_
    DevicePolicyAppliedSignal::_table_ =
        DevicePolicyAppliedSignal::InternalGenerateParseTable_(DevicePolicyAppliedSignal_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void DevicePolicyAppliedSignal::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.DevicePolicyAppliedSignal)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    this_._impl_.device_rule_.ClearNonDefaultToEmpty();
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000000eU)) {
    ::memset(&this_._impl_.id_, 0,
             static_cast<::size_t>(
                 reinterpret_cast<char*>(&this_._impl_.rule_id_) -
                 reinterpret_cast<char*>(&this_._impl_.id_)) +
                 sizeof(_impl_.rule_id_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL DevicePolicyAppliedSignal::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const DevicePolicyAppliedSignal& this_ = static_cast<const DevicePolicyAppliedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL DevicePolicyAppliedSignal::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const DevicePolicyAppliedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.DevicePolicyAppliedSignal)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required uint32 id = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        1, this_._internal_id(), target);
  }

  // required uint32 target_new = 2;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        2, this_._internal_target_new(), target);
  }

  // required string device_rule = 3;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_device_rule();
    target = stream->WriteStringMaybeAliased(3, _s, target);
  }

  // required uint32 rule_id = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
        4, this_._internal_rule_id(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.DevicePolicyAppliedSignal)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t DevicePolicyAppliedSignal::ByteSizeLong(const MessageLite& base) {
  const DevicePolicyAppliedSignal& this_ = static_cast<const DevicePolicyAppliedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t DevicePolicyAppliedSignal::ByteSizeLong() const {
  const DevicePolicyAppliedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.DevicePolicyAppliedSignal)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    // required string device_rule = 3;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_device_rule());
    }
    // required uint32 id = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_id());
    }
    // required uint32 target_new = 2;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_target_new());
    }
    // required uint32 rule_id = 4;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
          this_._internal_rule_id());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void DevicePolicyAppliedSignal::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<DevicePolicyAppliedSignal*>(&to_msg);
  auto& from = static_cast<const DevicePolicyAppliedSignal&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.DevicePolicyAppliedSignal)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_set_device_rule(from._internal_device_rule());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.id_ = from._impl_.id_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.target_new_ = from._impl_.target_new_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.rule_id_ = from._impl_.rule_id_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void DevicePolicyAppliedSignal::CopyFrom(const DevicePolicyAppliedSignal& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.DevicePolicyAppliedSignal)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool DevicePolicyAppliedSignal::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const DevicePolicyAppliedSignal&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void DevicePolicyAppliedSignal::InternalSwap(DevicePolicyAppliedSignal* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.device_rule_, &other->_impl_.device_rule_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.rule_id_)
      + sizeof(DevicePolicyAppliedSignal::_impl_.rule_id_)
      - PROTOBUF_FIELD_OFFSET(DevicePolicyAppliedSignal, _impl_.id_)>(
          reinterpret_cast<char*>(&_impl_.id_),
          reinterpret_cast<char*>(&other->_impl_.id_));
}

::google::protobuf::Metadata DevicePolicyAppliedSignal::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

PropertyParameterChangedSignal::PropertyParameterChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, PropertyParameterChangedSignal_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:usbguard.IPC.PropertyParameterChangedSignal)
}
PROTOBUF_NDEBUG_INLINE PropertyParameterChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::usbguard::IPC::PropertyParameterChangedSignal& from_msg)
      : _has_bits_{from._has_bits_},
        name_(arena, from.name_),
        value_old_(arena, from.value_old_),
        value_new_(arena, from.value_new_) {}

PropertyParameterChangedSignal::PropertyParameterChangedSignal(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const PropertyParameterChangedSignal& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : Super_(arena, PropertyParameterChangedSignal_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : Super_(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  PropertyParameterChangedSignal* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:usbguard.IPC.PropertyParameterChangedSignal)
}
PROTOBUF_NDEBUG_INLINE PropertyParameterChangedSignal::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : name_(arena),
        value_old_(arena),
        value_new_(arena) {}

inline void PropertyParameterChangedSignal::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
PropertyParameterChangedSignal::~PropertyParameterChangedSignal() {
  // @@protoc_insertion_point(destructor:usbguard.IPC.PropertyParameterChangedSignal)
  SharedDtor(*this);
}
inline void PropertyParameterChangedSignal::SharedDtor(MessageLite& self) {
  PropertyParameterChangedSignal& this_ = static_cast<PropertyParameterChangedSignal&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.name_.Destroy();
  this_._impl_.value_old_.Destroy();
  this_._impl_.value_new_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull PropertyParameterChangedSignal_class_data_ =
        PropertyParameterChangedSignal::InternalGenerateClassData_(PropertyParameterChangedSignal_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
PropertyParameterChangedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&PropertyParameterChangedSignal_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(PropertyParameterChangedSignal_class_data_.tc_table);
  return PropertyParameterChangedSignal_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
PropertyParameterChangedSignal::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&PropertyParameterChangedSignal_globals_);
  ::google::protobuf::internal::PrefetchToLocalCache(
      ::google::protobuf::internal::MessageGlobalsBase::ToParseTableBase(&PropertyParameterChangedSignal_globals_));
  return PropertyParameterChangedSignal_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const PropertyParameterChangedSignal::ParseTableT_
    PropertyParameterChangedSignal::_table_ =
        PropertyParameterChangedSignal::InternalGenerateParseTable_(PropertyParameterChangedSignal_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void PropertyParameterChangedSignal::Clear() {
  auto& this_ [[maybe_unused]] = *this;
  // @@protoc_insertion_point(message_clear_start:usbguard.IPC.PropertyParameterChangedSignal)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      this_._impl_.name_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      this_._impl_.value_old_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      this_._impl_.value_new_.ClearNonDefaultToEmpty();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL PropertyParameterChangedSignal::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const PropertyParameterChangedSignal& this_ = static_cast<const PropertyParameterChangedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL PropertyParameterChangedSignal::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const PropertyParameterChangedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:usbguard.IPC.PropertyParameterChangedSignal)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // required string name = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    const ::std::string& _s = this_._internal_name();
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // required string value_old = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    const ::std::string& _s = this_._internal_value_old();
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  // required string value_new = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    const ::std::string& _s = this_._internal_value_new();
    target = stream->WriteStringMaybeAliased(3, _s, target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:usbguard.IPC.PropertyParameterChangedSignal)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t PropertyParameterChangedSignal::ByteSizeLong(const MessageLite& base) {
  const PropertyParameterChangedSignal& this_ = static_cast<const PropertyParameterChangedSignal&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t PropertyParameterChangedSignal::ByteSizeLong() const {
  const PropertyParameterChangedSignal& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:usbguard.IPC.PropertyParameterChangedSignal)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits [[maybe_unused]] = 0;

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    // required string name = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_name());
    }
    // required string value_old = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_value_old());
    }
    // required string value_new = 3;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_value_new());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}

void PropertyParameterChangedSignal::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<PropertyParameterChangedSignal*>(&to_msg);
  auto& from = static_cast<const PropertyParameterChangedSignal&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:usbguard.IPC.PropertyParameterChangedSignal)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_set_name(from._internal_name());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_set_value_old(from._internal_value_old());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_internal_set_value_new(from._internal_value_new());
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}

void PropertyParameterChangedSignal::CopyFrom(const PropertyParameterChangedSignal& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:usbguard.IPC.PropertyParameterChangedSignal)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool PropertyParameterChangedSignal::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const PropertyParameterChangedSignal&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void PropertyParameterChangedSignal::InternalSwap(PropertyParameterChangedSignal* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.value_old_, &other->_impl_.value_old_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.value_new_, &other->_impl_.value_new_, arena);
}

::google::protobuf::Metadata PropertyParameterChangedSignal::GetMetadata() const {
  return Super_::GetMetadataImpl(GetClassData()->full());
}
// @@protoc_insertion_point(namespace_scope)
}  // namespace IPC
}  // namespace usbguard
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type
    _static_init2_ [[maybe_unused]] =
        (::_pbi::AddDescriptors(&descriptor_table_Devices_2eproto),
         ::std::false_type{});
#include "google/protobuf/port_undef.inc"
#endif
