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

#ifndef Devices_2eproto_2epb_2eh
#define Devices_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7036000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/unknown_field_set.h"
#include "Message.pb.h"
#include "Rule.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_Devices_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_Devices_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_Devices_2eproto;
}  // extern "C"
namespace usbguard {
namespace IPC {
class DevicePolicyAppliedSignal;
struct DevicePolicyAppliedSignalGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DevicePolicyAppliedSignalGlobalsTypeInternal DevicePolicyAppliedSignal_globals_;
extern const ::google::protobuf::internal::ClassDataFull DevicePolicyAppliedSignal_class_data_;
#else
extern const DevicePolicyAppliedSignalGlobalsTypeInternal DevicePolicyAppliedSignal_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DevicePolicyChangedSignal;
struct DevicePolicyChangedSignalGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DevicePolicyChangedSignalGlobalsTypeInternal DevicePolicyChangedSignal_globals_;
extern const ::google::protobuf::internal::ClassDataFull DevicePolicyChangedSignal_class_data_;
#else
extern const DevicePolicyChangedSignalGlobalsTypeInternal DevicePolicyChangedSignal_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DevicePresenceChangedSignal;
struct DevicePresenceChangedSignalGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DevicePresenceChangedSignalGlobalsTypeInternal DevicePresenceChangedSignal_globals_;
extern const ::google::protobuf::internal::ClassDataFull DevicePresenceChangedSignal_class_data_;
#else
extern const DevicePresenceChangedSignalGlobalsTypeInternal DevicePresenceChangedSignal_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class PropertyParameterChangedSignal;
struct PropertyParameterChangedSignalGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern PropertyParameterChangedSignalGlobalsTypeInternal PropertyParameterChangedSignal_globals_;
extern const ::google::protobuf::internal::ClassDataFull PropertyParameterChangedSignal_class_data_;
#else
extern const PropertyParameterChangedSignalGlobalsTypeInternal PropertyParameterChangedSignal_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class applyDevicePolicy;
struct applyDevicePolicyGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern applyDevicePolicyGlobalsTypeInternal applyDevicePolicy_globals_;
extern const ::google::protobuf::internal::ClassDataFull applyDevicePolicy_class_data_;
#else
extern const applyDevicePolicyGlobalsTypeInternal applyDevicePolicy_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class applyDevicePolicyRequest;
struct applyDevicePolicyRequestGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern applyDevicePolicyRequestGlobalsTypeInternal applyDevicePolicyRequest_globals_;
extern const ::google::protobuf::internal::ClassDataFull applyDevicePolicyRequest_class_data_;
#else
extern const applyDevicePolicyRequestGlobalsTypeInternal applyDevicePolicyRequest_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class applyDevicePolicyResponse;
struct applyDevicePolicyResponseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern applyDevicePolicyResponseGlobalsTypeInternal applyDevicePolicyResponse_globals_;
extern const ::google::protobuf::internal::ClassDataFull applyDevicePolicyResponse_class_data_;
#else
extern const applyDevicePolicyResponseGlobalsTypeInternal applyDevicePolicyResponse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class listDevices;
struct listDevicesGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern listDevicesGlobalsTypeInternal listDevices_globals_;
extern const ::google::protobuf::internal::ClassDataFull listDevices_class_data_;
#else
extern const listDevicesGlobalsTypeInternal listDevices_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class listDevicesRequest;
struct listDevicesRequestGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern listDevicesRequestGlobalsTypeInternal listDevicesRequest_globals_;
extern const ::google::protobuf::internal::ClassDataFull listDevicesRequest_class_data_;
#else
extern const listDevicesRequestGlobalsTypeInternal listDevicesRequest_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class listDevicesResponse;
struct listDevicesResponseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern listDevicesResponseGlobalsTypeInternal listDevicesResponse_globals_;
extern const ::google::protobuf::internal::ClassDataFull listDevicesResponse_class_data_;
#else
extern const listDevicesResponseGlobalsTypeInternal listDevicesResponse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace IPC
}  // namespace usbguard
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace usbguard {
namespace IPC {

// ===================================================================


// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED listDevicesRequest final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.listDevicesRequest) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline listDevicesRequest() : listDevicesRequest(nullptr) {}
  ~listDevicesRequest() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(listDevicesRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(listDevicesRequest));
  }
#endif

  template <typename = void>
  explicit constexpr listDevicesRequest(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline listDevicesRequest(const listDevicesRequest& from) : listDevicesRequest(nullptr, from) {}
  inline listDevicesRequest(listDevicesRequest&& from) noexcept : listDevicesRequest(nullptr, ::std::move(from)) {}
  inline listDevicesRequest& operator=(const listDevicesRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline listDevicesRequest& operator=(listDevicesRequest&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const listDevicesRequest& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<listDevicesRequest>(&listDevicesRequest_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(listDevicesRequest& a, listDevicesRequest& b) { a.Swap(&b); }
  inline void Swap(listDevicesRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(listDevicesRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] listDevicesRequest* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<listDevicesRequest>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const listDevicesRequest& from);
  using Super_::MergeFrom;
  void MergeFrom(const listDevicesRequest& from) { listDevicesRequest::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(listDevicesRequest* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.listDevicesRequest"; }

  explicit listDevicesRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  listDevicesRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const listDevicesRequest& from);
  listDevicesRequest(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, listDevicesRequest&& from) noexcept
      : listDevicesRequest(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kQueryFieldNumber = 1,
  };
  // required string query = 1;
  [[nodiscard]] bool has_query() const;
  void clear_query() ;
  [[nodiscard]] const ::std::string& query() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_query(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_query();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_query();
  void set_allocated_query(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_query() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_query(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_query();

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.listDevicesRequest)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const listDevicesRequest& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr query_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED applyDevicePolicyResponse final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.applyDevicePolicyResponse) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline applyDevicePolicyResponse() : applyDevicePolicyResponse(nullptr) {}
  ~applyDevicePolicyResponse() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(applyDevicePolicyResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(applyDevicePolicyResponse));
  }
#endif

  template <typename = void>
  explicit constexpr applyDevicePolicyResponse(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline applyDevicePolicyResponse(const applyDevicePolicyResponse& from) : applyDevicePolicyResponse(nullptr, from) {}
  inline applyDevicePolicyResponse(applyDevicePolicyResponse&& from) noexcept : applyDevicePolicyResponse(nullptr, ::std::move(from)) {}
  inline applyDevicePolicyResponse& operator=(const applyDevicePolicyResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline applyDevicePolicyResponse& operator=(applyDevicePolicyResponse&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const applyDevicePolicyResponse& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<applyDevicePolicyResponse>(&applyDevicePolicyResponse_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(applyDevicePolicyResponse& a, applyDevicePolicyResponse& b) { a.Swap(&b); }
  inline void Swap(applyDevicePolicyResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(applyDevicePolicyResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] applyDevicePolicyResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<applyDevicePolicyResponse>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const applyDevicePolicyResponse& from);
  using Super_::MergeFrom;
  void MergeFrom(const applyDevicePolicyResponse& from) { applyDevicePolicyResponse::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(applyDevicePolicyResponse* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.applyDevicePolicyResponse"; }

  explicit applyDevicePolicyResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  applyDevicePolicyResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const applyDevicePolicyResponse& from);
  applyDevicePolicyResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, applyDevicePolicyResponse&& from) noexcept
      : applyDevicePolicyResponse(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kRuleIdFieldNumber = 2,
  };
  // required uint32 rule_id = 2;
  [[nodiscard]] bool has_rule_id() const;
  void clear_rule_id() ;
  [[nodiscard]] ::uint32_t rule_id() const;
  void set_rule_id(::uint32_t value);

  private:
  ::uint32_t _internal_rule_id() const;
  void _internal_set_rule_id(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.applyDevicePolicyResponse)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const applyDevicePolicyResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t rule_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED applyDevicePolicyRequest final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.applyDevicePolicyRequest) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline applyDevicePolicyRequest() : applyDevicePolicyRequest(nullptr) {}
  ~applyDevicePolicyRequest() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(applyDevicePolicyRequest* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(applyDevicePolicyRequest));
  }
#endif

  template <typename = void>
  explicit constexpr applyDevicePolicyRequest(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline applyDevicePolicyRequest(const applyDevicePolicyRequest& from) : applyDevicePolicyRequest(nullptr, from) {}
  inline applyDevicePolicyRequest(applyDevicePolicyRequest&& from) noexcept : applyDevicePolicyRequest(nullptr, ::std::move(from)) {}
  inline applyDevicePolicyRequest& operator=(const applyDevicePolicyRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline applyDevicePolicyRequest& operator=(applyDevicePolicyRequest&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const applyDevicePolicyRequest& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<applyDevicePolicyRequest>(&applyDevicePolicyRequest_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(applyDevicePolicyRequest& a, applyDevicePolicyRequest& b) { a.Swap(&b); }
  inline void Swap(applyDevicePolicyRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(applyDevicePolicyRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] applyDevicePolicyRequest* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<applyDevicePolicyRequest>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const applyDevicePolicyRequest& from);
  using Super_::MergeFrom;
  void MergeFrom(const applyDevicePolicyRequest& from) { applyDevicePolicyRequest::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(applyDevicePolicyRequest* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.applyDevicePolicyRequest"; }

  explicit applyDevicePolicyRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  applyDevicePolicyRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const applyDevicePolicyRequest& from);
  applyDevicePolicyRequest(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, applyDevicePolicyRequest&& from) noexcept
      : applyDevicePolicyRequest(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kIdFieldNumber = 1,
    kTargetFieldNumber = 2,
    kPermanentFieldNumber = 3,
  };
  // required uint32 id = 1;
  [[nodiscard]] bool has_id() const;
  void clear_id() ;
  [[nodiscard]] ::uint32_t id() const;
  void set_id(::uint32_t value);

  private:
  ::uint32_t _internal_id() const;
  void _internal_set_id(::uint32_t value);

  public:
  // required uint32 target = 2;
  [[nodiscard]] bool has_target() const;
  void clear_target() ;
  [[nodiscard]] ::uint32_t target() const;
  void set_target(::uint32_t value);

  private:
  ::uint32_t _internal_target() const;
  void _internal_set_target(::uint32_t value);

  public:
  // required bool permanent = 3;
  [[nodiscard]] bool has_permanent() const;
  void clear_permanent() ;
  [[nodiscard]] bool permanent() const;
  void set_permanent(bool value);

  private:
  bool _internal_permanent() const;
  void _internal_set_permanent(bool value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.applyDevicePolicyRequest)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const applyDevicePolicyRequest& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t id_;
    ::uint32_t target_;
    bool permanent_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED PropertyParameterChangedSignal final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.PropertyParameterChangedSignal) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline PropertyParameterChangedSignal() : PropertyParameterChangedSignal(nullptr) {}
  ~PropertyParameterChangedSignal() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(PropertyParameterChangedSignal* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(PropertyParameterChangedSignal));
  }
#endif

  template <typename = void>
  explicit constexpr PropertyParameterChangedSignal(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline PropertyParameterChangedSignal(const PropertyParameterChangedSignal& from) : PropertyParameterChangedSignal(nullptr, from) {}
  inline PropertyParameterChangedSignal(PropertyParameterChangedSignal&& from) noexcept : PropertyParameterChangedSignal(nullptr, ::std::move(from)) {}
  inline PropertyParameterChangedSignal& operator=(const PropertyParameterChangedSignal& from) {
    CopyFrom(from);
    return *this;
  }
  inline PropertyParameterChangedSignal& operator=(PropertyParameterChangedSignal&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const PropertyParameterChangedSignal& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<PropertyParameterChangedSignal>(&PropertyParameterChangedSignal_globals_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(PropertyParameterChangedSignal& a, PropertyParameterChangedSignal& b) { a.Swap(&b); }
  inline void Swap(PropertyParameterChangedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PropertyParameterChangedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] PropertyParameterChangedSignal* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<PropertyParameterChangedSignal>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const PropertyParameterChangedSignal& from);
  using Super_::MergeFrom;
  void MergeFrom(const PropertyParameterChangedSignal& from) { PropertyParameterChangedSignal::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(PropertyParameterChangedSignal* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.PropertyParameterChangedSignal"; }

  explicit PropertyParameterChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  PropertyParameterChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PropertyParameterChangedSignal& from);
  PropertyParameterChangedSignal(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PropertyParameterChangedSignal&& from) noexcept
      : PropertyParameterChangedSignal(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
    kValueOldFieldNumber = 2,
    kValueNewFieldNumber = 3,
  };
  // required string name = 1;
  [[nodiscard]] bool has_name() const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // required string value_old = 2;
  [[nodiscard]] bool has_value_old() const;
  void clear_value_old() ;
  [[nodiscard]] const ::std::string& value_old() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_value_old(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_value_old();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_value_old();
  void set_allocated_value_old(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_value_old() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_value_old(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_value_old();

  public:
  // required string value_new = 3;
  [[nodiscard]] bool has_value_new() const;
  void clear_value_new() ;
  [[nodiscard]] const ::std::string& value_new() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_value_new(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_value_new();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_value_new();
  void set_allocated_value_new(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_value_new() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_value_new(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_value_new();

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.PropertyParameterChangedSignal)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const PropertyParameterChangedSignal& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr value_old_;
    ::google::protobuf::internal::ArenaStringPtr value_new_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DevicePresenceChangedSignal final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.DevicePresenceChangedSignal) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline DevicePresenceChangedSignal() : DevicePresenceChangedSignal(nullptr) {}
  ~DevicePresenceChangedSignal() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DevicePresenceChangedSignal* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DevicePresenceChangedSignal));
  }
#endif

  template <typename = void>
  explicit constexpr DevicePresenceChangedSignal(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline DevicePresenceChangedSignal(const DevicePresenceChangedSignal& from) : DevicePresenceChangedSignal(nullptr, from) {}
  inline DevicePresenceChangedSignal(DevicePresenceChangedSignal&& from) noexcept : DevicePresenceChangedSignal(nullptr, ::std::move(from)) {}
  inline DevicePresenceChangedSignal& operator=(const DevicePresenceChangedSignal& from) {
    CopyFrom(from);
    return *this;
  }
  inline DevicePresenceChangedSignal& operator=(DevicePresenceChangedSignal&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DevicePresenceChangedSignal& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DevicePresenceChangedSignal>(&DevicePresenceChangedSignal_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(DevicePresenceChangedSignal& a, DevicePresenceChangedSignal& b) { a.Swap(&b); }
  inline void Swap(DevicePresenceChangedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DevicePresenceChangedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] DevicePresenceChangedSignal* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DevicePresenceChangedSignal>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const DevicePresenceChangedSignal& from);
  using Super_::MergeFrom;
  void MergeFrom(const DevicePresenceChangedSignal& from) { DevicePresenceChangedSignal::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DevicePresenceChangedSignal* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.DevicePresenceChangedSignal"; }

  explicit DevicePresenceChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DevicePresenceChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DevicePresenceChangedSignal& from);
  DevicePresenceChangedSignal(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DevicePresenceChangedSignal&& from) noexcept
      : DevicePresenceChangedSignal(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDeviceRuleFieldNumber = 4,
    kIdFieldNumber = 1,
    kEventFieldNumber = 2,
    kTargetFieldNumber = 3,
  };
  // required string device_rule = 4;
  [[nodiscard]] bool has_device_rule() const;
  void clear_device_rule() ;
  [[nodiscard]] const ::std::string& device_rule() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_device_rule(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_device_rule();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_device_rule();
  void set_allocated_device_rule(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_device_rule() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_device_rule(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_device_rule();

  public:
  // required uint32 id = 1;
  [[nodiscard]] bool has_id() const;
  void clear_id() ;
  [[nodiscard]] ::uint32_t id() const;
  void set_id(::uint32_t value);

  private:
  ::uint32_t _internal_id() const;
  void _internal_set_id(::uint32_t value);

  public:
  // required uint32 event = 2;
  [[nodiscard]] bool has_event() const;
  void clear_event() ;
  [[nodiscard]] ::uint32_t event() const;
  void set_event(::uint32_t value);

  private:
  ::uint32_t _internal_event() const;
  void _internal_set_event(::uint32_t value);

  public:
  // required uint32 target = 3;
  [[nodiscard]] bool has_target() const;
  void clear_target() ;
  [[nodiscard]] ::uint32_t target() const;
  void set_target(::uint32_t value);

  private:
  ::uint32_t _internal_target() const;
  void _internal_set_target(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.DevicePresenceChangedSignal)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DevicePresenceChangedSignal& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr device_rule_;
    ::uint32_t id_;
    ::uint32_t event_;
    ::uint32_t target_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DevicePolicyChangedSignal final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.DevicePolicyChangedSignal) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline DevicePolicyChangedSignal() : DevicePolicyChangedSignal(nullptr) {}
  ~DevicePolicyChangedSignal() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DevicePolicyChangedSignal* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DevicePolicyChangedSignal));
  }
#endif

  template <typename = void>
  explicit constexpr DevicePolicyChangedSignal(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline DevicePolicyChangedSignal(const DevicePolicyChangedSignal& from) : DevicePolicyChangedSignal(nullptr, from) {}
  inline DevicePolicyChangedSignal(DevicePolicyChangedSignal&& from) noexcept : DevicePolicyChangedSignal(nullptr, ::std::move(from)) {}
  inline DevicePolicyChangedSignal& operator=(const DevicePolicyChangedSignal& from) {
    CopyFrom(from);
    return *this;
  }
  inline DevicePolicyChangedSignal& operator=(DevicePolicyChangedSignal&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DevicePolicyChangedSignal& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DevicePolicyChangedSignal>(&DevicePolicyChangedSignal_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(DevicePolicyChangedSignal& a, DevicePolicyChangedSignal& b) { a.Swap(&b); }
  inline void Swap(DevicePolicyChangedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DevicePolicyChangedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] DevicePolicyChangedSignal* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DevicePolicyChangedSignal>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const DevicePolicyChangedSignal& from);
  using Super_::MergeFrom;
  void MergeFrom(const DevicePolicyChangedSignal& from) { DevicePolicyChangedSignal::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DevicePolicyChangedSignal* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.DevicePolicyChangedSignal"; }

  explicit DevicePolicyChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DevicePolicyChangedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DevicePolicyChangedSignal& from);
  DevicePolicyChangedSignal(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DevicePolicyChangedSignal&& from) noexcept
      : DevicePolicyChangedSignal(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDeviceRuleFieldNumber = 4,
    kIdFieldNumber = 1,
    kTargetOldFieldNumber = 2,
    kTargetNewFieldNumber = 3,
    kRuleIdFieldNumber = 5,
  };
  // required string device_rule = 4;
  [[nodiscard]] bool has_device_rule() const;
  void clear_device_rule() ;
  [[nodiscard]] const ::std::string& device_rule() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_device_rule(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_device_rule();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_device_rule();
  void set_allocated_device_rule(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_device_rule() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_device_rule(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_device_rule();

  public:
  // required uint32 id = 1;
  [[nodiscard]] bool has_id() const;
  void clear_id() ;
  [[nodiscard]] ::uint32_t id() const;
  void set_id(::uint32_t value);

  private:
  ::uint32_t _internal_id() const;
  void _internal_set_id(::uint32_t value);

  public:
  // required uint32 target_old = 2;
  [[nodiscard]] bool has_target_old() const;
  void clear_target_old() ;
  [[nodiscard]] ::uint32_t target_old() const;
  void set_target_old(::uint32_t value);

  private:
  ::uint32_t _internal_target_old() const;
  void _internal_set_target_old(::uint32_t value);

  public:
  // required uint32 target_new = 3;
  [[nodiscard]] bool has_target_new() const;
  void clear_target_new() ;
  [[nodiscard]] ::uint32_t target_new() const;
  void set_target_new(::uint32_t value);

  private:
  ::uint32_t _internal_target_new() const;
  void _internal_set_target_new(::uint32_t value);

  public:
  // required uint32 rule_id = 5;
  [[nodiscard]] bool has_rule_id() const;
  void clear_rule_id() ;
  [[nodiscard]] ::uint32_t rule_id() const;
  void set_rule_id(::uint32_t value);

  private:
  ::uint32_t _internal_rule_id() const;
  void _internal_set_rule_id(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.DevicePolicyChangedSignal)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DevicePolicyChangedSignal& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr device_rule_;
    ::uint32_t id_;
    ::uint32_t target_old_;
    ::uint32_t target_new_;
    ::uint32_t rule_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DevicePolicyAppliedSignal final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.DevicePolicyAppliedSignal) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline DevicePolicyAppliedSignal() : DevicePolicyAppliedSignal(nullptr) {}
  ~DevicePolicyAppliedSignal() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DevicePolicyAppliedSignal* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DevicePolicyAppliedSignal));
  }
#endif

  template <typename = void>
  explicit constexpr DevicePolicyAppliedSignal(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline DevicePolicyAppliedSignal(const DevicePolicyAppliedSignal& from) : DevicePolicyAppliedSignal(nullptr, from) {}
  inline DevicePolicyAppliedSignal(DevicePolicyAppliedSignal&& from) noexcept : DevicePolicyAppliedSignal(nullptr, ::std::move(from)) {}
  inline DevicePolicyAppliedSignal& operator=(const DevicePolicyAppliedSignal& from) {
    CopyFrom(from);
    return *this;
  }
  inline DevicePolicyAppliedSignal& operator=(DevicePolicyAppliedSignal&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DevicePolicyAppliedSignal& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DevicePolicyAppliedSignal>(&DevicePolicyAppliedSignal_globals_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(DevicePolicyAppliedSignal& a, DevicePolicyAppliedSignal& b) { a.Swap(&b); }
  inline void Swap(DevicePolicyAppliedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DevicePolicyAppliedSignal* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] DevicePolicyAppliedSignal* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DevicePolicyAppliedSignal>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const DevicePolicyAppliedSignal& from);
  using Super_::MergeFrom;
  void MergeFrom(const DevicePolicyAppliedSignal& from) { DevicePolicyAppliedSignal::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DevicePolicyAppliedSignal* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.DevicePolicyAppliedSignal"; }

  explicit DevicePolicyAppliedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DevicePolicyAppliedSignal(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DevicePolicyAppliedSignal& from);
  DevicePolicyAppliedSignal(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DevicePolicyAppliedSignal&& from) noexcept
      : DevicePolicyAppliedSignal(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDeviceRuleFieldNumber = 3,
    kIdFieldNumber = 1,
    kTargetNewFieldNumber = 2,
    kRuleIdFieldNumber = 4,
  };
  // required string device_rule = 3;
  [[nodiscard]] bool has_device_rule() const;
  void clear_device_rule() ;
  [[nodiscard]] const ::std::string& device_rule() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_device_rule(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_device_rule();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_device_rule();
  void set_allocated_device_rule(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_device_rule() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_device_rule(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_device_rule();

  public:
  // required uint32 id = 1;
  [[nodiscard]] bool has_id() const;
  void clear_id() ;
  [[nodiscard]] ::uint32_t id() const;
  void set_id(::uint32_t value);

  private:
  ::uint32_t _internal_id() const;
  void _internal_set_id(::uint32_t value);

  public:
  // required uint32 target_new = 2;
  [[nodiscard]] bool has_target_new() const;
  void clear_target_new() ;
  [[nodiscard]] ::uint32_t target_new() const;
  void set_target_new(::uint32_t value);

  private:
  ::uint32_t _internal_target_new() const;
  void _internal_set_target_new(::uint32_t value);

  public:
  // required uint32 rule_id = 4;
  [[nodiscard]] bool has_rule_id() const;
  void clear_rule_id() ;
  [[nodiscard]] ::uint32_t rule_id() const;
  void set_rule_id(::uint32_t value);

  private:
  ::uint32_t _internal_rule_id() const;
  void _internal_set_rule_id(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.DevicePolicyAppliedSignal)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DevicePolicyAppliedSignal& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr device_rule_;
    ::uint32_t id_;
    ::uint32_t target_new_;
    ::uint32_t rule_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED listDevicesResponse final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.listDevicesResponse) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline listDevicesResponse() : listDevicesResponse(nullptr) {}
  ~listDevicesResponse() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(listDevicesResponse* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(listDevicesResponse));
  }
#endif

  template <typename = void>
  explicit constexpr listDevicesResponse(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline listDevicesResponse(const listDevicesResponse& from) : listDevicesResponse(nullptr, from) {}
  inline listDevicesResponse(listDevicesResponse&& from) noexcept : listDevicesResponse(nullptr, ::std::move(from)) {}
  inline listDevicesResponse& operator=(const listDevicesResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline listDevicesResponse& operator=(listDevicesResponse&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const listDevicesResponse& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<listDevicesResponse>(&listDevicesResponse_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(listDevicesResponse& a, listDevicesResponse& b) { a.Swap(&b); }
  inline void Swap(listDevicesResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(listDevicesResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] listDevicesResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<listDevicesResponse>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const listDevicesResponse& from);
  using Super_::MergeFrom;
  void MergeFrom(const listDevicesResponse& from) { listDevicesResponse::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(listDevicesResponse* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.listDevicesResponse"; }

  explicit listDevicesResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  listDevicesResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const listDevicesResponse& from);
  listDevicesResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, listDevicesResponse&& from) noexcept
      : listDevicesResponse(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDevicesFieldNumber = 1,
  };
  // repeated .usbguard.IPC.Rule devices = 1;
  [[nodiscard]] int devices_size() const;
  private:
  int _internal_devices_size() const;

  public:
  void clear_devices() ;
  [[nodiscard]] const ::usbguard::IPC::Rule& devices(int index) const;
  [[nodiscard]] ::usbguard::IPC::Rule* PROTOBUF_NONNULL mutable_devices(int index);
  ::usbguard::IPC::Rule* PROTOBUF_NONNULL add_devices();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>&
  devices() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL
  mutable_devices();

  private:
  const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>& _internal_devices() const;
  ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL _internal_mutable_devices();

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.listDevicesResponse)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          1, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const listDevicesResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::usbguard::IPC::Rule > devices_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED applyDevicePolicy final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.applyDevicePolicy) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline applyDevicePolicy() : applyDevicePolicy(nullptr) {}
  ~applyDevicePolicy() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(applyDevicePolicy* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(applyDevicePolicy));
  }
#endif

  template <typename = void>
  explicit constexpr applyDevicePolicy(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline applyDevicePolicy(const applyDevicePolicy& from) : applyDevicePolicy(nullptr, from) {}
  inline applyDevicePolicy(applyDevicePolicy&& from) noexcept : applyDevicePolicy(nullptr, ::std::move(from)) {}
  inline applyDevicePolicy& operator=(const applyDevicePolicy& from) {
    CopyFrom(from);
    return *this;
  }
  inline applyDevicePolicy& operator=(applyDevicePolicy&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const applyDevicePolicy& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<applyDevicePolicy>(&applyDevicePolicy_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(applyDevicePolicy& a, applyDevicePolicy& b) { a.Swap(&b); }
  inline void Swap(applyDevicePolicy* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(applyDevicePolicy* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] applyDevicePolicy* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<applyDevicePolicy>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const applyDevicePolicy& from);
  using Super_::MergeFrom;
  void MergeFrom(const applyDevicePolicy& from) { applyDevicePolicy::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(applyDevicePolicy* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.applyDevicePolicy"; }

  explicit applyDevicePolicy(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  applyDevicePolicy(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const applyDevicePolicy& from);
  applyDevicePolicy(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, applyDevicePolicy&& from) noexcept
      : applyDevicePolicy(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kHeaderFieldNumber = 1,
    kRequestFieldNumber = 2,
    kResponseFieldNumber = 3,
  };
  // required .usbguard.IPC.MessageHeader header = 1;
  [[nodiscard]] bool has_header() const;
  void clear_header() ;
  [[nodiscard]] const ::usbguard::IPC::MessageHeader& header() const;
  [[nodiscard]] ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE release_header();
  ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL mutable_header();
  void set_allocated_header(::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_header(::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE unsafe_arena_release_header();

  private:
  const ::usbguard::IPC::MessageHeader& _internal_header() const;
  ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL _internal_mutable_header();

  public:
  // required .usbguard.IPC.applyDevicePolicyRequest request = 2;
  [[nodiscard]] bool has_request() const;
  void clear_request() ;
  [[nodiscard]] const ::usbguard::IPC::applyDevicePolicyRequest& request() const;
  [[nodiscard]] ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE release_request();
  ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NONNULL mutable_request();
  void set_allocated_request(::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_request(::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE unsafe_arena_release_request();

  private:
  const ::usbguard::IPC::applyDevicePolicyRequest& _internal_request() const;
  ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NONNULL _internal_mutable_request();

  public:
  // optional .usbguard.IPC.applyDevicePolicyResponse response = 3;
  [[nodiscard]] bool has_response() const;
  void clear_response() ;
  [[nodiscard]] const ::usbguard::IPC::applyDevicePolicyResponse& response() const;
  [[nodiscard]] ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE release_response();
  ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NONNULL mutable_response();
  void set_allocated_response(::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_response(::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE unsafe_arena_release_response();

  private:
  const ::usbguard::IPC::applyDevicePolicyResponse& _internal_response() const;
  ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NONNULL _internal_mutable_response();

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.applyDevicePolicy)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          3, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const applyDevicePolicy& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE header_;
    ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE request_;
    ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE response_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED listDevices final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.listDevices) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline listDevices() : listDevices(nullptr) {}
  ~listDevices() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(listDevices* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(listDevices));
  }
#endif

  template <typename = void>
  explicit constexpr listDevices(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline listDevices(const listDevices& from) : listDevices(nullptr, from) {}
  inline listDevices(listDevices&& from) noexcept : listDevices(nullptr, ::std::move(from)) {}
  inline listDevices& operator=(const listDevices& from) {
    CopyFrom(from);
    return *this;
  }
  inline listDevices& operator=(listDevices&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const listDevices& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<listDevices>(&listDevices_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(listDevices& a, listDevices& b) { a.Swap(&b); }
  inline void Swap(listDevices* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(listDevices* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] listDevices* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<listDevices>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const listDevices& from);
  using Super_::MergeFrom;
  void MergeFrom(const listDevices& from) { listDevices::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(listDevices* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.listDevices"; }

  explicit listDevices(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  listDevices(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const listDevices& from);
  listDevices(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, listDevices&& from) noexcept
      : listDevices(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kHeaderFieldNumber = 1,
    kRequestFieldNumber = 2,
    kResponseFieldNumber = 3,
  };
  // required .usbguard.IPC.MessageHeader header = 1;
  [[nodiscard]] bool has_header() const;
  void clear_header() ;
  [[nodiscard]] const ::usbguard::IPC::MessageHeader& header() const;
  [[nodiscard]] ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE release_header();
  ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL mutable_header();
  void set_allocated_header(::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_header(::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE unsafe_arena_release_header();

  private:
  const ::usbguard::IPC::MessageHeader& _internal_header() const;
  ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL _internal_mutable_header();

  public:
  // required .usbguard.IPC.listDevicesRequest request = 2;
  [[nodiscard]] bool has_request() const;
  void clear_request() ;
  [[nodiscard]] const ::usbguard::IPC::listDevicesRequest& request() const;
  [[nodiscard]] ::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE release_request();
  ::usbguard::IPC::listDevicesRequest* PROTOBUF_NONNULL mutable_request();
  void set_allocated_request(::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_request(::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE unsafe_arena_release_request();

  private:
  const ::usbguard::IPC::listDevicesRequest& _internal_request() const;
  ::usbguard::IPC::listDevicesRequest* PROTOBUF_NONNULL _internal_mutable_request();

  public:
  // optional .usbguard.IPC.listDevicesResponse response = 3;
  [[nodiscard]] bool has_response() const;
  void clear_response() ;
  [[nodiscard]] const ::usbguard::IPC::listDevicesResponse& response() const;
  [[nodiscard]] ::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE release_response();
  ::usbguard::IPC::listDevicesResponse* PROTOBUF_NONNULL mutable_response();
  void set_allocated_response(::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_response(::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE unsafe_arena_release_response();

  private:
  const ::usbguard::IPC::listDevicesResponse& _internal_response() const;
  ::usbguard::IPC::listDevicesResponse* PROTOBUF_NONNULL _internal_mutable_response();

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.listDevices)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          3, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const listDevices& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE header_;
    ::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE request_;
    ::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE response_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Devices_2eproto;
};

// ===================================================================




// ===================================================================


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// listDevicesRequest

// required string query = 1;
inline bool listDevicesRequest::has_query() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void listDevicesRequest::clear_query() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& listDevicesRequest::query() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listDevicesRequest.query)
  return _internal_query();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void listDevicesRequest::set_query(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.query_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.listDevicesRequest.query)
}
inline ::std::string* PROTOBUF_NONNULL listDevicesRequest::mutable_query()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_query();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listDevicesRequest.query)
  return _s;
}
inline const ::std::string& listDevicesRequest::_internal_query() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.query_.Get();
}
inline void listDevicesRequest::_internal_set_query(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.query_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL listDevicesRequest::_internal_mutable_query() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.query_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE listDevicesRequest::release_query() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listDevicesRequest.query)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.query_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.query_.Set("", GetArena());
  }
  return released;
}
inline void listDevicesRequest::set_allocated_query(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.query_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.query_.IsDefault()) {
    _impl_.query_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listDevicesRequest.query)
}

// -------------------------------------------------------------------

// listDevicesResponse

// repeated .usbguard.IPC.Rule devices = 1;
inline int listDevicesResponse::_internal_devices_size() const {
  return _internal_devices().size();
}
inline int listDevicesResponse::devices_size() const {
  return _internal_devices_size();
}
inline const ::usbguard::IPC::Rule& listDevicesResponse::devices(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listDevicesResponse.devices)
  return _internal_devices().Get(index);
}
inline ::usbguard::IPC::Rule* PROTOBUF_NONNULL listDevicesResponse::mutable_devices(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listDevicesResponse.devices)
  return _internal_mutable_devices()->Mutable(index);
}
inline ::usbguard::IPC::Rule* PROTOBUF_NONNULL listDevicesResponse::add_devices()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::usbguard::IPC::Rule* _add =
      _internal_mutable_devices()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:usbguard.IPC.listDevicesResponse.devices)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>& listDevicesResponse::devices() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:usbguard.IPC.listDevicesResponse.devices)
  return _internal_devices();
}
inline ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL
listDevicesResponse::mutable_devices() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:usbguard.IPC.listDevicesResponse.devices)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_devices();
}
inline const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>&
listDevicesResponse::_internal_devices() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.devices_;
}
inline ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL
listDevicesResponse::_internal_mutable_devices() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.devices_;
}

// -------------------------------------------------------------------

// listDevices

// required .usbguard.IPC.MessageHeader header = 1;
inline bool listDevices::has_header() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline const ::usbguard::IPC::MessageHeader& listDevices::_internal_header() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::MessageHeader* p = _impl_.header_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::MessageHeader>(&::usbguard::IPC::MessageHeader_globals_);
}
inline const ::usbguard::IPC::MessageHeader& listDevices::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listDevices.header)
  return _internal_header();
}
inline void listDevices::unsafe_arena_set_allocated_header(
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.header_);
  }
  _impl_.header_ = reinterpret_cast<::usbguard::IPC::MessageHeader*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:usbguard.IPC.listDevices.header)
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE listDevices::release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* released = _impl_.header_;
  _impl_.header_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE listDevices::unsafe_arena_release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listDevices.header)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL listDevices::_internal_mutable_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.header_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::MessageHeader>(GetArena());
    _impl_.header_ = reinterpret_cast<::usbguard::IPC::MessageHeader*>(p);
  }
  return _impl_.header_;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL listDevices::mutable_header()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listDevices.header)
  return _msg;
}
inline void listDevices::set_allocated_header(::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.header_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.header_ = reinterpret_cast<::usbguard::IPC::MessageHeader*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listDevices.header)
}

// required .usbguard.IPC.listDevicesRequest request = 2;
inline bool listDevices::has_request() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void listDevices::clear_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::usbguard::IPC::listDevicesRequest& listDevices::_internal_request() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::listDevicesRequest* p = _impl_.request_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::listDevicesRequest>(&::usbguard::IPC::listDevicesRequest_globals_);
}
inline const ::usbguard::IPC::listDevicesRequest& listDevices::request() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listDevices.request)
  return _internal_request();
}
inline void listDevices::unsafe_arena_set_allocated_request(
    ::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.request_);
  }
  _impl_.request_ = reinterpret_cast<::usbguard::IPC::listDevicesRequest*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:usbguard.IPC.listDevices.request)
}
inline ::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE listDevices::release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::listDevicesRequest* released = _impl_.request_;
  _impl_.request_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE listDevices::unsafe_arena_release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listDevices.request)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::listDevicesRequest* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::listDevicesRequest* PROTOBUF_NONNULL listDevices::_internal_mutable_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::listDevicesRequest>(GetArena());
    _impl_.request_ = reinterpret_cast<::usbguard::IPC::listDevicesRequest*>(p);
  }
  return _impl_.request_;
}
inline ::usbguard::IPC::listDevicesRequest* PROTOBUF_NONNULL listDevices::mutable_request()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::listDevicesRequest* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listDevices.request)
  return _msg;
}
inline void listDevices::set_allocated_request(::usbguard::IPC::listDevicesRequest* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.request_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.request_ = reinterpret_cast<::usbguard::IPC::listDevicesRequest*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listDevices.request)
}

// optional .usbguard.IPC.listDevicesResponse response = 3;
inline bool listDevices::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void listDevices::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::usbguard::IPC::listDevicesResponse& listDevices::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::listDevicesResponse* p = _impl_.response_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::listDevicesResponse>(&::usbguard::IPC::listDevicesResponse_globals_);
}
inline const ::usbguard::IPC::listDevicesResponse& listDevices::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listDevices.response)
  return _internal_response();
}
inline void listDevices::unsafe_arena_set_allocated_response(
    ::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }
  _impl_.response_ = reinterpret_cast<::usbguard::IPC::listDevicesResponse*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:usbguard.IPC.listDevices.response)
}
inline ::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE listDevices::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::listDevicesResponse* released = _impl_.response_;
  _impl_.response_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE listDevices::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listDevices.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::listDevicesResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::listDevicesResponse* PROTOBUF_NONNULL listDevices::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::listDevicesResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::usbguard::IPC::listDevicesResponse*>(p);
  }
  return _impl_.response_;
}
inline ::usbguard::IPC::listDevicesResponse* PROTOBUF_NONNULL listDevices::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::listDevicesResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listDevices.response)
  return _msg;
}
inline void listDevices::set_allocated_response(::usbguard::IPC::listDevicesResponse* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.response_ = reinterpret_cast<::usbguard::IPC::listDevicesResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listDevices.response)
}

// -------------------------------------------------------------------

// applyDevicePolicyRequest

// required uint32 id = 1;
inline bool applyDevicePolicyRequest::has_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void applyDevicePolicyRequest::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t applyDevicePolicyRequest::id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicyRequest.id)
  return _internal_id();
}
inline void applyDevicePolicyRequest::set_id(::uint32_t value) {
  _internal_set_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.applyDevicePolicyRequest.id)
}
inline ::uint32_t applyDevicePolicyRequest::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void applyDevicePolicyRequest::_internal_set_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// required uint32 target = 2;
inline bool applyDevicePolicyRequest::has_target() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void applyDevicePolicyRequest::clear_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t applyDevicePolicyRequest::target() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicyRequest.target)
  return _internal_target();
}
inline void applyDevicePolicyRequest::set_target(::uint32_t value) {
  _internal_set_target(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.applyDevicePolicyRequest.target)
}
inline ::uint32_t applyDevicePolicyRequest::_internal_target() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_;
}
inline void applyDevicePolicyRequest::_internal_set_target(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_ = value;
}

// required bool permanent = 3;
inline bool applyDevicePolicyRequest::has_permanent() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void applyDevicePolicyRequest::clear_permanent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permanent_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline bool applyDevicePolicyRequest::permanent() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicyRequest.permanent)
  return _internal_permanent();
}
inline void applyDevicePolicyRequest::set_permanent(bool value) {
  _internal_set_permanent(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.applyDevicePolicyRequest.permanent)
}
inline bool applyDevicePolicyRequest::_internal_permanent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.permanent_;
}
inline void applyDevicePolicyRequest::_internal_set_permanent(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permanent_ = value;
}

// -------------------------------------------------------------------

// applyDevicePolicyResponse

// required uint32 rule_id = 2;
inline bool applyDevicePolicyResponse::has_rule_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void applyDevicePolicyResponse::clear_rule_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::uint32_t applyDevicePolicyResponse::rule_id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicyResponse.rule_id)
  return _internal_rule_id();
}
inline void applyDevicePolicyResponse::set_rule_id(::uint32_t value) {
  _internal_set_rule_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.applyDevicePolicyResponse.rule_id)
}
inline ::uint32_t applyDevicePolicyResponse::_internal_rule_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rule_id_;
}
inline void applyDevicePolicyResponse::_internal_set_rule_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_id_ = value;
}

// -------------------------------------------------------------------

// applyDevicePolicy

// required .usbguard.IPC.MessageHeader header = 1;
inline bool applyDevicePolicy::has_header() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline const ::usbguard::IPC::MessageHeader& applyDevicePolicy::_internal_header() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::MessageHeader* p = _impl_.header_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::MessageHeader>(&::usbguard::IPC::MessageHeader_globals_);
}
inline const ::usbguard::IPC::MessageHeader& applyDevicePolicy::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicy.header)
  return _internal_header();
}
inline void applyDevicePolicy::unsafe_arena_set_allocated_header(
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.header_);
  }
  _impl_.header_ = reinterpret_cast<::usbguard::IPC::MessageHeader*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:usbguard.IPC.applyDevicePolicy.header)
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE applyDevicePolicy::release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* released = _impl_.header_;
  _impl_.header_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE applyDevicePolicy::unsafe_arena_release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.applyDevicePolicy.header)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL applyDevicePolicy::_internal_mutable_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.header_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::MessageHeader>(GetArena());
    _impl_.header_ = reinterpret_cast<::usbguard::IPC::MessageHeader*>(p);
  }
  return _impl_.header_;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL applyDevicePolicy::mutable_header()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.applyDevicePolicy.header)
  return _msg;
}
inline void applyDevicePolicy::set_allocated_header(::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.header_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.header_ = reinterpret_cast<::usbguard::IPC::MessageHeader*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.applyDevicePolicy.header)
}

// required .usbguard.IPC.applyDevicePolicyRequest request = 2;
inline bool applyDevicePolicy::has_request() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void applyDevicePolicy::clear_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::usbguard::IPC::applyDevicePolicyRequest& applyDevicePolicy::_internal_request() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::applyDevicePolicyRequest* p = _impl_.request_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::applyDevicePolicyRequest>(&::usbguard::IPC::applyDevicePolicyRequest_globals_);
}
inline const ::usbguard::IPC::applyDevicePolicyRequest& applyDevicePolicy::request() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicy.request)
  return _internal_request();
}
inline void applyDevicePolicy::unsafe_arena_set_allocated_request(
    ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.request_);
  }
  _impl_.request_ = reinterpret_cast<::usbguard::IPC::applyDevicePolicyRequest*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:usbguard.IPC.applyDevicePolicy.request)
}
inline ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE applyDevicePolicy::release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::applyDevicePolicyRequest* released = _impl_.request_;
  _impl_.request_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE applyDevicePolicy::unsafe_arena_release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.applyDevicePolicy.request)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::applyDevicePolicyRequest* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NONNULL applyDevicePolicy::_internal_mutable_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::applyDevicePolicyRequest>(GetArena());
    _impl_.request_ = reinterpret_cast<::usbguard::IPC::applyDevicePolicyRequest*>(p);
  }
  return _impl_.request_;
}
inline ::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NONNULL applyDevicePolicy::mutable_request()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::applyDevicePolicyRequest* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.applyDevicePolicy.request)
  return _msg;
}
inline void applyDevicePolicy::set_allocated_request(::usbguard::IPC::applyDevicePolicyRequest* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.request_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.request_ = reinterpret_cast<::usbguard::IPC::applyDevicePolicyRequest*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.applyDevicePolicy.request)
}

// optional .usbguard.IPC.applyDevicePolicyResponse response = 3;
inline bool applyDevicePolicy::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void applyDevicePolicy::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::usbguard::IPC::applyDevicePolicyResponse& applyDevicePolicy::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::applyDevicePolicyResponse* p = _impl_.response_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::applyDevicePolicyResponse>(&::usbguard::IPC::applyDevicePolicyResponse_globals_);
}
inline const ::usbguard::IPC::applyDevicePolicyResponse& applyDevicePolicy::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.applyDevicePolicy.response)
  return _internal_response();
}
inline void applyDevicePolicy::unsafe_arena_set_allocated_response(
    ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }
  _impl_.response_ = reinterpret_cast<::usbguard::IPC::applyDevicePolicyResponse*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:usbguard.IPC.applyDevicePolicy.response)
}
inline ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE applyDevicePolicy::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::applyDevicePolicyResponse* released = _impl_.response_;
  _impl_.response_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE applyDevicePolicy::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.applyDevicePolicy.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::applyDevicePolicyResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NONNULL applyDevicePolicy::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::applyDevicePolicyResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::usbguard::IPC::applyDevicePolicyResponse*>(p);
  }
  return _impl_.response_;
}
inline ::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NONNULL applyDevicePolicy::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::applyDevicePolicyResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.applyDevicePolicy.response)
  return _msg;
}
inline void applyDevicePolicy::set_allocated_response(::usbguard::IPC::applyDevicePolicyResponse* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.response_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.response_ = reinterpret_cast<::usbguard::IPC::applyDevicePolicyResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.applyDevicePolicy.response)
}

// -------------------------------------------------------------------

// DevicePresenceChangedSignal

// required uint32 id = 1;
inline bool DevicePresenceChangedSignal::has_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void DevicePresenceChangedSignal::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t DevicePresenceChangedSignal::id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePresenceChangedSignal.id)
  return _internal_id();
}
inline void DevicePresenceChangedSignal::set_id(::uint32_t value) {
  _internal_set_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePresenceChangedSignal.id)
}
inline ::uint32_t DevicePresenceChangedSignal::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void DevicePresenceChangedSignal::_internal_set_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// required uint32 event = 2;
inline bool DevicePresenceChangedSignal::has_event() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void DevicePresenceChangedSignal::clear_event() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.event_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t DevicePresenceChangedSignal::event() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePresenceChangedSignal.event)
  return _internal_event();
}
inline void DevicePresenceChangedSignal::set_event(::uint32_t value) {
  _internal_set_event(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePresenceChangedSignal.event)
}
inline ::uint32_t DevicePresenceChangedSignal::_internal_event() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.event_;
}
inline void DevicePresenceChangedSignal::_internal_set_event(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.event_ = value;
}

// required uint32 target = 3;
inline bool DevicePresenceChangedSignal::has_target() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void DevicePresenceChangedSignal::clear_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t DevicePresenceChangedSignal::target() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePresenceChangedSignal.target)
  return _internal_target();
}
inline void DevicePresenceChangedSignal::set_target(::uint32_t value) {
  _internal_set_target(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePresenceChangedSignal.target)
}
inline ::uint32_t DevicePresenceChangedSignal::_internal_target() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_;
}
inline void DevicePresenceChangedSignal::_internal_set_target(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_ = value;
}

// required string device_rule = 4;
inline bool DevicePresenceChangedSignal::has_device_rule() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void DevicePresenceChangedSignal::clear_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_rule_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& DevicePresenceChangedSignal::device_rule() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePresenceChangedSignal.device_rule)
  return _internal_device_rule();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void DevicePresenceChangedSignal::set_device_rule(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.device_rule_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePresenceChangedSignal.device_rule)
}
inline ::std::string* PROTOBUF_NONNULL DevicePresenceChangedSignal::mutable_device_rule()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_device_rule();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.DevicePresenceChangedSignal.device_rule)
  return _s;
}
inline const ::std::string& DevicePresenceChangedSignal::_internal_device_rule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_rule_.Get();
}
inline void DevicePresenceChangedSignal::_internal_set_device_rule(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_rule_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL DevicePresenceChangedSignal::_internal_mutable_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.device_rule_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE DevicePresenceChangedSignal::release_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.DevicePresenceChangedSignal.device_rule)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.device_rule_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.device_rule_.Set("", GetArena());
  }
  return released;
}
inline void DevicePresenceChangedSignal::set_allocated_device_rule(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.device_rule_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.device_rule_.IsDefault()) {
    _impl_.device_rule_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.DevicePresenceChangedSignal.device_rule)
}

// -------------------------------------------------------------------

// DevicePolicyChangedSignal

// required uint32 id = 1;
inline bool DevicePolicyChangedSignal::has_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void DevicePolicyChangedSignal::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t DevicePolicyChangedSignal::id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyChangedSignal.id)
  return _internal_id();
}
inline void DevicePolicyChangedSignal::set_id(::uint32_t value) {
  _internal_set_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyChangedSignal.id)
}
inline ::uint32_t DevicePolicyChangedSignal::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void DevicePolicyChangedSignal::_internal_set_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// required uint32 target_old = 2;
inline bool DevicePolicyChangedSignal::has_target_old() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void DevicePolicyChangedSignal::clear_target_old() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_old_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t DevicePolicyChangedSignal::target_old() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyChangedSignal.target_old)
  return _internal_target_old();
}
inline void DevicePolicyChangedSignal::set_target_old(::uint32_t value) {
  _internal_set_target_old(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyChangedSignal.target_old)
}
inline ::uint32_t DevicePolicyChangedSignal::_internal_target_old() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_old_;
}
inline void DevicePolicyChangedSignal::_internal_set_target_old(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_old_ = value;
}

// required uint32 target_new = 3;
inline bool DevicePolicyChangedSignal::has_target_new() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void DevicePolicyChangedSignal::clear_target_new() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_new_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t DevicePolicyChangedSignal::target_new() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyChangedSignal.target_new)
  return _internal_target_new();
}
inline void DevicePolicyChangedSignal::set_target_new(::uint32_t value) {
  _internal_set_target_new(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyChangedSignal.target_new)
}
inline ::uint32_t DevicePolicyChangedSignal::_internal_target_new() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_new_;
}
inline void DevicePolicyChangedSignal::_internal_set_target_new(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_new_ = value;
}

// required string device_rule = 4;
inline bool DevicePolicyChangedSignal::has_device_rule() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void DevicePolicyChangedSignal::clear_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_rule_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& DevicePolicyChangedSignal::device_rule() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyChangedSignal.device_rule)
  return _internal_device_rule();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void DevicePolicyChangedSignal::set_device_rule(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.device_rule_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyChangedSignal.device_rule)
}
inline ::std::string* PROTOBUF_NONNULL DevicePolicyChangedSignal::mutable_device_rule()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_device_rule();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.DevicePolicyChangedSignal.device_rule)
  return _s;
}
inline const ::std::string& DevicePolicyChangedSignal::_internal_device_rule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_rule_.Get();
}
inline void DevicePolicyChangedSignal::_internal_set_device_rule(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_rule_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL DevicePolicyChangedSignal::_internal_mutable_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.device_rule_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE DevicePolicyChangedSignal::release_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.DevicePolicyChangedSignal.device_rule)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.device_rule_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.device_rule_.Set("", GetArena());
  }
  return released;
}
inline void DevicePolicyChangedSignal::set_allocated_device_rule(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.device_rule_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.device_rule_.IsDefault()) {
    _impl_.device_rule_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.DevicePolicyChangedSignal.device_rule)
}

// required uint32 rule_id = 5;
inline bool DevicePolicyChangedSignal::has_rule_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void DevicePolicyChangedSignal::clear_rule_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint32_t DevicePolicyChangedSignal::rule_id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyChangedSignal.rule_id)
  return _internal_rule_id();
}
inline void DevicePolicyChangedSignal::set_rule_id(::uint32_t value) {
  _internal_set_rule_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyChangedSignal.rule_id)
}
inline ::uint32_t DevicePolicyChangedSignal::_internal_rule_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rule_id_;
}
inline void DevicePolicyChangedSignal::_internal_set_rule_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_id_ = value;
}

// -------------------------------------------------------------------

// DevicePolicyAppliedSignal

// required uint32 id = 1;
inline bool DevicePolicyAppliedSignal::has_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void DevicePolicyAppliedSignal::clear_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t DevicePolicyAppliedSignal::id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyAppliedSignal.id)
  return _internal_id();
}
inline void DevicePolicyAppliedSignal::set_id(::uint32_t value) {
  _internal_set_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyAppliedSignal.id)
}
inline ::uint32_t DevicePolicyAppliedSignal::_internal_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.id_;
}
inline void DevicePolicyAppliedSignal::_internal_set_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.id_ = value;
}

// required uint32 target_new = 2;
inline bool DevicePolicyAppliedSignal::has_target_new() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void DevicePolicyAppliedSignal::clear_target_new() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_new_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t DevicePolicyAppliedSignal::target_new() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyAppliedSignal.target_new)
  return _internal_target_new();
}
inline void DevicePolicyAppliedSignal::set_target_new(::uint32_t value) {
  _internal_set_target_new(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyAppliedSignal.target_new)
}
inline ::uint32_t DevicePolicyAppliedSignal::_internal_target_new() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.target_new_;
}
inline void DevicePolicyAppliedSignal::_internal_set_target_new(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.target_new_ = value;
}

// required string device_rule = 3;
inline bool DevicePolicyAppliedSignal::has_device_rule() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void DevicePolicyAppliedSignal::clear_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_rule_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& DevicePolicyAppliedSignal::device_rule() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyAppliedSignal.device_rule)
  return _internal_device_rule();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void DevicePolicyAppliedSignal::set_device_rule(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.device_rule_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyAppliedSignal.device_rule)
}
inline ::std::string* PROTOBUF_NONNULL DevicePolicyAppliedSignal::mutable_device_rule()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_device_rule();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.DevicePolicyAppliedSignal.device_rule)
  return _s;
}
inline const ::std::string& DevicePolicyAppliedSignal::_internal_device_rule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.device_rule_.Get();
}
inline void DevicePolicyAppliedSignal::_internal_set_device_rule(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.device_rule_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL DevicePolicyAppliedSignal::_internal_mutable_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.device_rule_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE DevicePolicyAppliedSignal::release_device_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.DevicePolicyAppliedSignal.device_rule)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.device_rule_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.device_rule_.Set("", GetArena());
  }
  return released;
}
inline void DevicePolicyAppliedSignal::set_allocated_device_rule(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.device_rule_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.device_rule_.IsDefault()) {
    _impl_.device_rule_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.DevicePolicyAppliedSignal.device_rule)
}

// required uint32 rule_id = 4;
inline bool DevicePolicyAppliedSignal::has_rule_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void DevicePolicyAppliedSignal::clear_rule_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t DevicePolicyAppliedSignal::rule_id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.DevicePolicyAppliedSignal.rule_id)
  return _internal_rule_id();
}
inline void DevicePolicyAppliedSignal::set_rule_id(::uint32_t value) {
  _internal_set_rule_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.DevicePolicyAppliedSignal.rule_id)
}
inline ::uint32_t DevicePolicyAppliedSignal::_internal_rule_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rule_id_;
}
inline void DevicePolicyAppliedSignal::_internal_set_rule_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_id_ = value;
}

// -------------------------------------------------------------------

// PropertyParameterChangedSignal

// required string name = 1;
inline bool PropertyParameterChangedSignal::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void PropertyParameterChangedSignal::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& PropertyParameterChangedSignal::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.PropertyParameterChangedSignal.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void PropertyParameterChangedSignal::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.PropertyParameterChangedSignal.name)
}
inline ::std::string* PROTOBUF_NONNULL PropertyParameterChangedSignal::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.PropertyParameterChangedSignal.name)
  return _s;
}
inline const ::std::string& PropertyParameterChangedSignal::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void PropertyParameterChangedSignal::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL PropertyParameterChangedSignal::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE PropertyParameterChangedSignal::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.PropertyParameterChangedSignal.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void PropertyParameterChangedSignal::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.PropertyParameterChangedSignal.name)
}

// required string value_old = 2;
inline bool PropertyParameterChangedSignal::has_value_old() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void PropertyParameterChangedSignal::clear_value_old() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_old_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& PropertyParameterChangedSignal::value_old() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.PropertyParameterChangedSignal.value_old)
  return _internal_value_old();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void PropertyParameterChangedSignal::set_value_old(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.value_old_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.PropertyParameterChangedSignal.value_old)
}
inline ::std::string* PROTOBUF_NONNULL PropertyParameterChangedSignal::mutable_value_old()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_value_old();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.PropertyParameterChangedSignal.value_old)
  return _s;
}
inline const ::std::string& PropertyParameterChangedSignal::_internal_value_old() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_old_.Get();
}
inline void PropertyParameterChangedSignal::_internal_set_value_old(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_old_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL PropertyParameterChangedSignal::_internal_mutable_value_old() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.value_old_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE PropertyParameterChangedSignal::release_value_old() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.PropertyParameterChangedSignal.value_old)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.value_old_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.value_old_.Set("", GetArena());
  }
  return released;
}
inline void PropertyParameterChangedSignal::set_allocated_value_old(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.value_old_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.value_old_.IsDefault()) {
    _impl_.value_old_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.PropertyParameterChangedSignal.value_old)
}

// required string value_new = 3;
inline bool PropertyParameterChangedSignal::has_value_new() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void PropertyParameterChangedSignal::clear_value_new() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_new_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& PropertyParameterChangedSignal::value_new() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.PropertyParameterChangedSignal.value_new)
  return _internal_value_new();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void PropertyParameterChangedSignal::set_value_new(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.value_new_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.PropertyParameterChangedSignal.value_new)
}
inline ::std::string* PROTOBUF_NONNULL PropertyParameterChangedSignal::mutable_value_new()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_value_new();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.PropertyParameterChangedSignal.value_new)
  return _s;
}
inline const ::std::string& PropertyParameterChangedSignal::_internal_value_new() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_new_.Get();
}
inline void PropertyParameterChangedSignal::_internal_set_value_new(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_new_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL PropertyParameterChangedSignal::_internal_mutable_value_new() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.value_new_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE PropertyParameterChangedSignal::release_value_new() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.PropertyParameterChangedSignal.value_new)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.value_new_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.value_new_.Set("", GetArena());
  }
  return released;
}
inline void PropertyParameterChangedSignal::set_allocated_value_new(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.value_new_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.value_new_.IsDefault()) {
    _impl_.value_new_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.PropertyParameterChangedSignal.value_new)
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace IPC
}  // namespace usbguard


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // Devices_2eproto_2epb_2eh
