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

#ifndef Policy_2eproto_2epb_2eh
#define Policy_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_Policy_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_Policy_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_Policy_2eproto;
}  // extern "C"
namespace usbguard {
namespace IPC {
class appendRule;
struct appendRuleGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern appendRuleGlobalsTypeInternal appendRule_globals_;
extern const ::google::protobuf::internal::ClassDataFull appendRule_class_data_;
#else
extern const appendRuleGlobalsTypeInternal appendRule_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class appendRuleRequest;
struct appendRuleRequestGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern appendRuleRequestGlobalsTypeInternal appendRuleRequest_globals_;
extern const ::google::protobuf::internal::ClassDataFull appendRuleRequest_class_data_;
#else
extern const appendRuleRequestGlobalsTypeInternal appendRuleRequest_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class appendRuleResponse;
struct appendRuleResponseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern appendRuleResponseGlobalsTypeInternal appendRuleResponse_globals_;
extern const ::google::protobuf::internal::ClassDataFull appendRuleResponse_class_data_;
#else
extern const appendRuleResponseGlobalsTypeInternal appendRuleResponse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class checkIPCPermissions;
struct checkIPCPermissionsGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern checkIPCPermissionsGlobalsTypeInternal checkIPCPermissions_globals_;
extern const ::google::protobuf::internal::ClassDataFull checkIPCPermissions_class_data_;
#else
extern const checkIPCPermissionsGlobalsTypeInternal checkIPCPermissions_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class checkIPCPermissionsRequest;
struct checkIPCPermissionsRequestGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern checkIPCPermissionsRequestGlobalsTypeInternal checkIPCPermissionsRequest_globals_;
extern const ::google::protobuf::internal::ClassDataFull checkIPCPermissionsRequest_class_data_;
#else
extern const checkIPCPermissionsRequestGlobalsTypeInternal checkIPCPermissionsRequest_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class checkIPCPermissionsResponse;
struct checkIPCPermissionsResponseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern checkIPCPermissionsResponseGlobalsTypeInternal checkIPCPermissionsResponse_globals_;
extern const ::google::protobuf::internal::ClassDataFull checkIPCPermissionsResponse_class_data_;
#else
extern const checkIPCPermissionsResponseGlobalsTypeInternal checkIPCPermissionsResponse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class listRules;
struct listRulesGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern listRulesGlobalsTypeInternal listRules_globals_;
extern const ::google::protobuf::internal::ClassDataFull listRules_class_data_;
#else
extern const listRulesGlobalsTypeInternal listRules_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class listRulesRequest;
struct listRulesRequestGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern listRulesRequestGlobalsTypeInternal listRulesRequest_globals_;
extern const ::google::protobuf::internal::ClassDataFull listRulesRequest_class_data_;
#else
extern const listRulesRequestGlobalsTypeInternal listRulesRequest_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class listRulesResponse;
struct listRulesResponseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern listRulesResponseGlobalsTypeInternal listRulesResponse_globals_;
extern const ::google::protobuf::internal::ClassDataFull listRulesResponse_class_data_;
#else
extern const listRulesResponseGlobalsTypeInternal listRulesResponse_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class removeRule;
struct removeRuleGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern removeRuleGlobalsTypeInternal removeRule_globals_;
extern const ::google::protobuf::internal::ClassDataFull removeRule_class_data_;
#else
extern const removeRuleGlobalsTypeInternal removeRule_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class removeRuleRequest;
struct removeRuleRequestGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern removeRuleRequestGlobalsTypeInternal removeRuleRequest_globals_;
extern const ::google::protobuf::internal::ClassDataFull removeRuleRequest_class_data_;
#else
extern const removeRuleRequestGlobalsTypeInternal removeRuleRequest_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class removeRuleResponse;
struct removeRuleResponseGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern removeRuleResponseGlobalsTypeInternal removeRuleResponse_globals_;
extern const ::google::protobuf::internal::ClassDataFull removeRuleResponse_class_data_;
#else
extern const removeRuleResponseGlobalsTypeInternal removeRuleResponse_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 removeRuleResponse final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:usbguard.IPC.removeRuleResponse) */ {
  using Super_ = ::google::protobuf::Message;

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

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

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

  inline removeRuleResponse(const removeRuleResponse& from) : removeRuleResponse(nullptr, from) {}
  inline removeRuleResponse(removeRuleResponse&& from) noexcept : removeRuleResponse(nullptr, ::std::move(from)) {}
  inline removeRuleResponse& operator=(const removeRuleResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline removeRuleResponse& operator=(removeRuleResponse&& 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 removeRuleResponse& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<removeRuleResponse>(&removeRuleResponse_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(removeRuleResponse& a, removeRuleResponse& b) { a.Swap(&b); }
  inline void Swap(removeRuleResponse* 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(removeRuleResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] removeRuleResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<removeRuleResponse>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const removeRuleResponse& from);
  using Super_::MergeFrom;
  void MergeFrom(const removeRuleResponse& from) { removeRuleResponse::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(removeRuleResponse* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.removeRuleResponse"; }

  explicit removeRuleResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  removeRuleResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const removeRuleResponse& from);
  removeRuleResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, removeRuleResponse&& from) noexcept
      : removeRuleResponse(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,
  };
  // 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:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.removeRuleResponse)
 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 removeRuleResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline removeRuleRequest(const removeRuleRequest& from) : removeRuleRequest(nullptr, from) {}
  inline removeRuleRequest(removeRuleRequest&& from) noexcept : removeRuleRequest(nullptr, ::std::move(from)) {}
  inline removeRuleRequest& operator=(const removeRuleRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline removeRuleRequest& operator=(removeRuleRequest&& 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 removeRuleRequest& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<removeRuleRequest>(&removeRuleRequest_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(removeRuleRequest& a, removeRuleRequest& b) { a.Swap(&b); }
  inline void Swap(removeRuleRequest* 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(removeRuleRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] removeRuleRequest* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<removeRuleRequest>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const removeRuleRequest& from);
  using Super_::MergeFrom;
  void MergeFrom(const removeRuleRequest& from) { removeRuleRequest::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(removeRuleRequest* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.removeRuleRequest"; }

  explicit removeRuleRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  removeRuleRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const removeRuleRequest& from);
  removeRuleRequest(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, removeRuleRequest&& from) noexcept
      : removeRuleRequest(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,
  };
  // 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:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.removeRuleRequest)
 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 removeRuleRequest& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline listRulesRequest(const listRulesRequest& from) : listRulesRequest(nullptr, from) {}
  inline listRulesRequest(listRulesRequest&& from) noexcept : listRulesRequest(nullptr, ::std::move(from)) {}
  inline listRulesRequest& operator=(const listRulesRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline listRulesRequest& operator=(listRulesRequest&& 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 listRulesRequest& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<listRulesRequest>(&listRulesRequest_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(listRulesRequest& a, listRulesRequest& b) { a.Swap(&b); }
  inline void Swap(listRulesRequest* 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(listRulesRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] listRulesRequest* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<listRulesRequest>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const listRulesRequest& from);
  using Super_::MergeFrom;
  void MergeFrom(const listRulesRequest& from) { listRulesRequest::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(listRulesRequest* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.listRulesRequest"; }

  explicit listRulesRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  listRulesRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const listRulesRequest& from);
  listRulesRequest(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, listRulesRequest&& from) noexcept
      : listRulesRequest(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 {
    kLabelFieldNumber = 1,
  };
  // required string label = 1;
  [[nodiscard]] bool has_label() const;
  void clear_label() ;
  [[nodiscard]] const ::std::string& label() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_label(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_label();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_label();
  void set_allocated_label(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_label() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_label(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_label();

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.listRulesRequest)
 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 listRulesRequest& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr label_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline checkIPCPermissionsResponse(const checkIPCPermissionsResponse& from) : checkIPCPermissionsResponse(nullptr, from) {}
  inline checkIPCPermissionsResponse(checkIPCPermissionsResponse&& from) noexcept : checkIPCPermissionsResponse(nullptr, ::std::move(from)) {}
  inline checkIPCPermissionsResponse& operator=(const checkIPCPermissionsResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline checkIPCPermissionsResponse& operator=(checkIPCPermissionsResponse&& 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 checkIPCPermissionsResponse& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<checkIPCPermissionsResponse>(&checkIPCPermissionsResponse_globals_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(checkIPCPermissionsResponse& a, checkIPCPermissionsResponse& b) { a.Swap(&b); }
  inline void Swap(checkIPCPermissionsResponse* 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(checkIPCPermissionsResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] checkIPCPermissionsResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<checkIPCPermissionsResponse>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const checkIPCPermissionsResponse& from);
  using Super_::MergeFrom;
  void MergeFrom(const checkIPCPermissionsResponse& from) { checkIPCPermissionsResponse::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(checkIPCPermissionsResponse* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.checkIPCPermissionsResponse"; }

  explicit checkIPCPermissionsResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  checkIPCPermissionsResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const checkIPCPermissionsResponse& from);
  checkIPCPermissionsResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, checkIPCPermissionsResponse&& from) noexcept
      : checkIPCPermissionsResponse(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 {
    kPermitFieldNumber = 1,
  };
  // required bool permit = 1;
  [[nodiscard]] bool has_permit() const;
  void clear_permit() ;
  [[nodiscard]] bool permit() const;
  void set_permit(bool value);

  private:
  bool _internal_permit() const;
  void _internal_set_permit(bool value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.checkIPCPermissionsResponse)
 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 checkIPCPermissionsResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    bool permit_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline checkIPCPermissionsRequest(const checkIPCPermissionsRequest& from) : checkIPCPermissionsRequest(nullptr, from) {}
  inline checkIPCPermissionsRequest(checkIPCPermissionsRequest&& from) noexcept : checkIPCPermissionsRequest(nullptr, ::std::move(from)) {}
  inline checkIPCPermissionsRequest& operator=(const checkIPCPermissionsRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline checkIPCPermissionsRequest& operator=(checkIPCPermissionsRequest&& 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 checkIPCPermissionsRequest& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<checkIPCPermissionsRequest>(&checkIPCPermissionsRequest_globals_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(checkIPCPermissionsRequest& a, checkIPCPermissionsRequest& b) { a.Swap(&b); }
  inline void Swap(checkIPCPermissionsRequest* 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(checkIPCPermissionsRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] checkIPCPermissionsRequest* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<checkIPCPermissionsRequest>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const checkIPCPermissionsRequest& from);
  using Super_::MergeFrom;
  void MergeFrom(const checkIPCPermissionsRequest& from) { checkIPCPermissionsRequest::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(checkIPCPermissionsRequest* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.checkIPCPermissionsRequest"; }

  explicit checkIPCPermissionsRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  checkIPCPermissionsRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const checkIPCPermissionsRequest& from);
  checkIPCPermissionsRequest(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, checkIPCPermissionsRequest&& from) noexcept
      : checkIPCPermissionsRequest(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 {
    kSectionFieldNumber = 3,
    kPrivilegeFieldNumber = 4,
    kUidFieldNumber = 1,
    kGidFieldNumber = 2,
  };
  // required string section = 3;
  [[nodiscard]] bool has_section() const;
  void clear_section() ;
  [[nodiscard]] const ::std::string& section() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_section(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_section();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_section();
  void set_allocated_section(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_section() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_section(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_section();

  public:
  // required string privilege = 4;
  [[nodiscard]] bool has_privilege() const;
  void clear_privilege() ;
  [[nodiscard]] const ::std::string& privilege() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_privilege(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_privilege();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_privilege();
  void set_allocated_privilege(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_privilege() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_privilege(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_privilege();

  public:
  // required uint32 uid = 1;
  [[nodiscard]] bool has_uid() const;
  void clear_uid() ;
  [[nodiscard]] ::uint32_t uid() const;
  void set_uid(::uint32_t value);

  private:
  ::uint32_t _internal_uid() const;
  void _internal_set_uid(::uint32_t value);

  public:
  // required uint32 gid = 2;
  [[nodiscard]] bool has_gid() const;
  void clear_gid() ;
  [[nodiscard]] ::uint32_t gid() const;
  void set_gid(::uint32_t value);

  private:
  ::uint32_t _internal_gid() const;
  void _internal_set_gid(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.checkIPCPermissionsRequest)
 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 checkIPCPermissionsRequest& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr section_;
    ::google::protobuf::internal::ArenaStringPtr privilege_;
    ::uint32_t uid_;
    ::uint32_t gid_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline appendRuleResponse(const appendRuleResponse& from) : appendRuleResponse(nullptr, from) {}
  inline appendRuleResponse(appendRuleResponse&& from) noexcept : appendRuleResponse(nullptr, ::std::move(from)) {}
  inline appendRuleResponse& operator=(const appendRuleResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline appendRuleResponse& operator=(appendRuleResponse&& 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 appendRuleResponse& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<appendRuleResponse>(&appendRuleResponse_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(appendRuleResponse& a, appendRuleResponse& b) { a.Swap(&b); }
  inline void Swap(appendRuleResponse* 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(appendRuleResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] appendRuleResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<appendRuleResponse>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const appendRuleResponse& from);
  using Super_::MergeFrom;
  void MergeFrom(const appendRuleResponse& from) { appendRuleResponse::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(appendRuleResponse* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.appendRuleResponse"; }

  explicit appendRuleResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  appendRuleResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const appendRuleResponse& from);
  appendRuleResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, appendRuleResponse&& from) noexcept
      : appendRuleResponse(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,
  };
  // 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:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.appendRuleResponse)
 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 appendRuleResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline appendRuleRequest(const appendRuleRequest& from) : appendRuleRequest(nullptr, from) {}
  inline appendRuleRequest(appendRuleRequest&& from) noexcept : appendRuleRequest(nullptr, ::std::move(from)) {}
  inline appendRuleRequest& operator=(const appendRuleRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline appendRuleRequest& operator=(appendRuleRequest&& 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 appendRuleRequest& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<appendRuleRequest>(&appendRuleRequest_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(appendRuleRequest& a, appendRuleRequest& b) { a.Swap(&b); }
  inline void Swap(appendRuleRequest* 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(appendRuleRequest* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] appendRuleRequest* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<appendRuleRequest>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const appendRuleRequest& from);
  using Super_::MergeFrom;
  void MergeFrom(const appendRuleRequest& from) { appendRuleRequest::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(appendRuleRequest* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.appendRuleRequest"; }

  explicit appendRuleRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  appendRuleRequest(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const appendRuleRequest& from);
  appendRuleRequest(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, appendRuleRequest&& from) noexcept
      : appendRuleRequest(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 {
    kRuleFieldNumber = 1,
    kParentIdFieldNumber = 2,
    kPermanentFieldNumber = 3,
  };
  // required string rule = 1;
  [[nodiscard]] bool has_rule() const;
  void clear_rule() ;
  [[nodiscard]] const ::std::string& rule() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_rule(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_rule();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_rule();
  void set_allocated_rule(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_rule() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_rule(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_rule();

  public:
  // required uint32 parent_id = 2;
  [[nodiscard]] bool has_parent_id() const;
  void clear_parent_id() ;
  [[nodiscard]] ::uint32_t parent_id() const;
  void set_parent_id(::uint32_t value);

  private:
  ::uint32_t _internal_parent_id() const;
  void _internal_set_parent_id(::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.appendRuleRequest)
 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 appendRuleRequest& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr rule_;
    ::uint32_t parent_id_;
    bool permanent_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline removeRule(const removeRule& from) : removeRule(nullptr, from) {}
  inline removeRule(removeRule&& from) noexcept : removeRule(nullptr, ::std::move(from)) {}
  inline removeRule& operator=(const removeRule& from) {
    CopyFrom(from);
    return *this;
  }
  inline removeRule& operator=(removeRule&& 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 removeRule& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<removeRule>(&removeRule_globals_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(removeRule& a, removeRule& b) { a.Swap(&b); }
  inline void Swap(removeRule* 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(removeRule* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] removeRule* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<removeRule>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const removeRule& from);
  using Super_::MergeFrom;
  void MergeFrom(const removeRule& from) { removeRule::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(removeRule* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.removeRule"; }

  explicit removeRule(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  removeRule(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const removeRule& from);
  removeRule(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, removeRule&& from) noexcept
      : removeRule(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.removeRuleRequest request = 2;
  [[nodiscard]] bool has_request() const;
  void clear_request() ;
  [[nodiscard]] const ::usbguard::IPC::removeRuleRequest& request() const;
  [[nodiscard]] ::usbguard::IPC::removeRuleRequest* PROTOBUF_NULLABLE release_request();
  ::usbguard::IPC::removeRuleRequest* PROTOBUF_NONNULL mutable_request();
  void set_allocated_request(::usbguard::IPC::removeRuleRequest* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_request(::usbguard::IPC::removeRuleRequest* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::removeRuleRequest* PROTOBUF_NULLABLE unsafe_arena_release_request();

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

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

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

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.removeRule)
 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 removeRule& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE header_;
    ::usbguard::IPC::removeRuleRequest* PROTOBUF_NULLABLE request_;
    ::usbguard::IPC::removeRuleResponse* PROTOBUF_NULLABLE response_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline listRulesResponse(const listRulesResponse& from) : listRulesResponse(nullptr, from) {}
  inline listRulesResponse(listRulesResponse&& from) noexcept : listRulesResponse(nullptr, ::std::move(from)) {}
  inline listRulesResponse& operator=(const listRulesResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline listRulesResponse& operator=(listRulesResponse&& 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 listRulesResponse& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<listRulesResponse>(&listRulesResponse_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(listRulesResponse& a, listRulesResponse& b) { a.Swap(&b); }
  inline void Swap(listRulesResponse* 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(listRulesResponse* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] listRulesResponse* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<listRulesResponse>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const listRulesResponse& from);
  using Super_::MergeFrom;
  void MergeFrom(const listRulesResponse& from) { listRulesResponse::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(listRulesResponse* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.listRulesResponse"; }

  explicit listRulesResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  listRulesResponse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const listRulesResponse& from);
  listRulesResponse(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, listRulesResponse&& from) noexcept
      : listRulesResponse(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 {
    kRulesFieldNumber = 1,
  };
  // repeated .usbguard.IPC.Rule rules = 1;
  [[nodiscard]] int rules_size() const;
  private:
  int _internal_rules_size() const;

  public:
  void clear_rules() ;
  [[nodiscard]] const ::usbguard::IPC::Rule& rules(int index) const;
  [[nodiscard]] ::usbguard::IPC::Rule* PROTOBUF_NONNULL mutable_rules(int index);
  ::usbguard::IPC::Rule* PROTOBUF_NONNULL add_rules();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>&
  rules() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL
  mutable_rules();

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

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.listRulesResponse)
 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 listRulesResponse& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::usbguard::IPC::Rule > rules_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline checkIPCPermissions(const checkIPCPermissions& from) : checkIPCPermissions(nullptr, from) {}
  inline checkIPCPermissions(checkIPCPermissions&& from) noexcept : checkIPCPermissions(nullptr, ::std::move(from)) {}
  inline checkIPCPermissions& operator=(const checkIPCPermissions& from) {
    CopyFrom(from);
    return *this;
  }
  inline checkIPCPermissions& operator=(checkIPCPermissions&& 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 checkIPCPermissions& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<checkIPCPermissions>(&checkIPCPermissions_globals_);
  }
  static constexpr int kIndexInFileMessages = 11;
  friend void swap(checkIPCPermissions& a, checkIPCPermissions& b) { a.Swap(&b); }
  inline void Swap(checkIPCPermissions* 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(checkIPCPermissions* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] checkIPCPermissions* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<checkIPCPermissions>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const checkIPCPermissions& from);
  using Super_::MergeFrom;
  void MergeFrom(const checkIPCPermissions& from) { checkIPCPermissions::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(checkIPCPermissions* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.checkIPCPermissions"; }

  explicit checkIPCPermissions(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  checkIPCPermissions(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const checkIPCPermissions& from);
  checkIPCPermissions(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, checkIPCPermissions&& from) noexcept
      : checkIPCPermissions(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.checkIPCPermissionsRequest request = 2;
  [[nodiscard]] bool has_request() const;
  void clear_request() ;
  [[nodiscard]] const ::usbguard::IPC::checkIPCPermissionsRequest& request() const;
  [[nodiscard]] ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NULLABLE release_request();
  ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NONNULL mutable_request();
  void set_allocated_request(::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_request(::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NULLABLE unsafe_arena_release_request();

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

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

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

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.checkIPCPermissions)
 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 checkIPCPermissions& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE header_;
    ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NULLABLE request_;
    ::usbguard::IPC::checkIPCPermissionsResponse* PROTOBUF_NULLABLE response_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline appendRule(const appendRule& from) : appendRule(nullptr, from) {}
  inline appendRule(appendRule&& from) noexcept : appendRule(nullptr, ::std::move(from)) {}
  inline appendRule& operator=(const appendRule& from) {
    CopyFrom(from);
    return *this;
  }
  inline appendRule& operator=(appendRule&& 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 appendRule& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<appendRule>(&appendRule_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(appendRule& a, appendRule& b) { a.Swap(&b); }
  inline void Swap(appendRule* 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(appendRule* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] appendRule* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<appendRule>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const appendRule& from);
  using Super_::MergeFrom;
  void MergeFrom(const appendRule& from) { appendRule::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(appendRule* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.appendRule"; }

  explicit appendRule(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  appendRule(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const appendRule& from);
  appendRule(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, appendRule&& from) noexcept
      : appendRule(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.appendRuleRequest request = 2;
  [[nodiscard]] bool has_request() const;
  void clear_request() ;
  [[nodiscard]] const ::usbguard::IPC::appendRuleRequest& request() const;
  [[nodiscard]] ::usbguard::IPC::appendRuleRequest* PROTOBUF_NULLABLE release_request();
  ::usbguard::IPC::appendRuleRequest* PROTOBUF_NONNULL mutable_request();
  void set_allocated_request(::usbguard::IPC::appendRuleRequest* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_request(::usbguard::IPC::appendRuleRequest* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::appendRuleRequest* PROTOBUF_NULLABLE unsafe_arena_release_request();

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

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

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

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.appendRule)
 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 appendRule& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE header_;
    ::usbguard::IPC::appendRuleRequest* PROTOBUF_NULLABLE request_;
    ::usbguard::IPC::appendRuleResponse* PROTOBUF_NULLABLE response_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline listRules(const listRules& from) : listRules(nullptr, from) {}
  inline listRules(listRules&& from) noexcept : listRules(nullptr, ::std::move(from)) {}
  inline listRules& operator=(const listRules& from) {
    CopyFrom(from);
    return *this;
  }
  inline listRules& operator=(listRules&& 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 listRules& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<listRules>(&listRules_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(listRules& a, listRules& b) { a.Swap(&b); }
  inline void Swap(listRules* 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(listRules* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] listRules* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<listRules>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const listRules& from);
  using Super_::MergeFrom;
  void MergeFrom(const listRules& from) { listRules::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(listRules* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "usbguard.IPC.listRules"; }

  explicit listRules(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  listRules(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const listRules& from);
  listRules(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, listRules&& from) noexcept
      : listRules(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.listRulesRequest request = 2;
  [[nodiscard]] bool has_request() const;
  void clear_request() ;
  [[nodiscard]] const ::usbguard::IPC::listRulesRequest& request() const;
  [[nodiscard]] ::usbguard::IPC::listRulesRequest* PROTOBUF_NULLABLE release_request();
  ::usbguard::IPC::listRulesRequest* PROTOBUF_NONNULL mutable_request();
  void set_allocated_request(::usbguard::IPC::listRulesRequest* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_request(::usbguard::IPC::listRulesRequest* PROTOBUF_NULLABLE value);
  ::usbguard::IPC::listRulesRequest* PROTOBUF_NULLABLE unsafe_arena_release_request();

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

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

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

  public:
  // @@protoc_insertion_point(class_scope:usbguard.IPC.listRules)
 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 listRules& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE header_;
    ::usbguard::IPC::listRulesRequest* PROTOBUF_NULLABLE request_;
    ::usbguard::IPC::listRulesResponse* PROTOBUF_NULLABLE response_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_Policy_2eproto;
};

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




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


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

// listRulesRequest

// required string label = 1;
inline bool listRulesRequest::has_label() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void listRulesRequest::clear_label() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.label_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& listRulesRequest::label() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listRulesRequest.label)
  return _internal_label();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void listRulesRequest::set_label(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.label_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.listRulesRequest.label)
}
inline ::std::string* PROTOBUF_NONNULL listRulesRequest::mutable_label()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_label();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listRulesRequest.label)
  return _s;
}
inline const ::std::string& listRulesRequest::_internal_label() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.label_.Get();
}
inline void listRulesRequest::_internal_set_label(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.label_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL listRulesRequest::_internal_mutable_label() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.label_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE listRulesRequest::release_label() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listRulesRequest.label)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.label_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.label_.Set("", GetArena());
  }
  return released;
}
inline void listRulesRequest::set_allocated_label(::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_.label_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.label_.IsDefault()) {
    _impl_.label_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listRulesRequest.label)
}

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

// listRulesResponse

// repeated .usbguard.IPC.Rule rules = 1;
inline int listRulesResponse::_internal_rules_size() const {
  return _internal_rules().size();
}
inline int listRulesResponse::rules_size() const {
  return _internal_rules_size();
}
inline const ::usbguard::IPC::Rule& listRulesResponse::rules(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listRulesResponse.rules)
  return _internal_rules().Get(index);
}
inline ::usbguard::IPC::Rule* PROTOBUF_NONNULL listRulesResponse::mutable_rules(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listRulesResponse.rules)
  return _internal_mutable_rules()->Mutable(index);
}
inline ::usbguard::IPC::Rule* PROTOBUF_NONNULL listRulesResponse::add_rules()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::usbguard::IPC::Rule* _add =
      _internal_mutable_rules()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:usbguard.IPC.listRulesResponse.rules)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>& listRulesResponse::rules() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:usbguard.IPC.listRulesResponse.rules)
  return _internal_rules();
}
inline ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL
listRulesResponse::mutable_rules() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:usbguard.IPC.listRulesResponse.rules)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_rules();
}
inline const ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>&
listRulesResponse::_internal_rules() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rules_;
}
inline ::google::protobuf::RepeatedPtrField<::usbguard::IPC::Rule>* PROTOBUF_NONNULL
listRulesResponse::_internal_mutable_rules() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.rules_;
}

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

// listRules

// required .usbguard.IPC.MessageHeader header = 1;
inline bool listRules::has_header() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline const ::usbguard::IPC::MessageHeader& listRules::_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& listRules::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listRules.header)
  return _internal_header();
}
inline void listRules::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.listRules.header)
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE listRules::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 listRules::unsafe_arena_release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listRules.header)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL listRules::_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 listRules::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.listRules.header)
  return _msg;
}
inline void listRules::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.listRules.header)
}

// required .usbguard.IPC.listRulesRequest request = 2;
inline bool listRules::has_request() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void listRules::clear_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::usbguard::IPC::listRulesRequest& listRules::_internal_request() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::listRulesRequest* p = _impl_.request_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::listRulesRequest>(&::usbguard::IPC::listRulesRequest_globals_);
}
inline const ::usbguard::IPC::listRulesRequest& listRules::request() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listRules.request)
  return _internal_request();
}
inline void listRules::unsafe_arena_set_allocated_request(
    ::usbguard::IPC::listRulesRequest* 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::listRulesRequest*>(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.listRules.request)
}
inline ::usbguard::IPC::listRulesRequest* PROTOBUF_NULLABLE listRules::release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::listRulesRequest* 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::listRulesRequest* PROTOBUF_NULLABLE listRules::unsafe_arena_release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listRules.request)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::listRulesRequest* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::listRulesRequest* PROTOBUF_NONNULL listRules::_internal_mutable_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::listRulesRequest>(GetArena());
    _impl_.request_ = reinterpret_cast<::usbguard::IPC::listRulesRequest*>(p);
  }
  return _impl_.request_;
}
inline ::usbguard::IPC::listRulesRequest* PROTOBUF_NONNULL listRules::mutable_request()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::listRulesRequest* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listRules.request)
  return _msg;
}
inline void listRules::set_allocated_request(::usbguard::IPC::listRulesRequest* 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::listRulesRequest*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listRules.request)
}

// optional .usbguard.IPC.listRulesResponse response = 3;
inline bool listRules::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void listRules::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::usbguard::IPC::listRulesResponse& listRules::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::listRulesResponse* p = _impl_.response_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::listRulesResponse>(&::usbguard::IPC::listRulesResponse_globals_);
}
inline const ::usbguard::IPC::listRulesResponse& listRules::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.listRules.response)
  return _internal_response();
}
inline void listRules::unsafe_arena_set_allocated_response(
    ::usbguard::IPC::listRulesResponse* 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::listRulesResponse*>(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.listRules.response)
}
inline ::usbguard::IPC::listRulesResponse* PROTOBUF_NULLABLE listRules::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::listRulesResponse* 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::listRulesResponse* PROTOBUF_NULLABLE listRules::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.listRules.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::listRulesResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::listRulesResponse* PROTOBUF_NONNULL listRules::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::listRulesResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::usbguard::IPC::listRulesResponse*>(p);
  }
  return _impl_.response_;
}
inline ::usbguard::IPC::listRulesResponse* PROTOBUF_NONNULL listRules::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::listRulesResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.listRules.response)
  return _msg;
}
inline void listRules::set_allocated_response(::usbguard::IPC::listRulesResponse* 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::listRulesResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.listRules.response)
}

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

// appendRuleRequest

// required string rule = 1;
inline bool appendRuleRequest::has_rule() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void appendRuleRequest::clear_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& appendRuleRequest::rule() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.appendRuleRequest.rule)
  return _internal_rule();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void appendRuleRequest::set_rule(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.rule_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.appendRuleRequest.rule)
}
inline ::std::string* PROTOBUF_NONNULL appendRuleRequest::mutable_rule()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_rule();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.appendRuleRequest.rule)
  return _s;
}
inline const ::std::string& appendRuleRequest::_internal_rule() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rule_.Get();
}
inline void appendRuleRequest::_internal_set_rule(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rule_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL appendRuleRequest::_internal_mutable_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.rule_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE appendRuleRequest::release_rule() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.appendRuleRequest.rule)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.rule_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.rule_.Set("", GetArena());
  }
  return released;
}
inline void appendRuleRequest::set_allocated_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_.rule_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.rule_.IsDefault()) {
    _impl_.rule_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.appendRuleRequest.rule)
}

// required uint32 parent_id = 2;
inline bool appendRuleRequest::has_parent_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void appendRuleRequest::clear_parent_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.parent_id_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint32_t appendRuleRequest::parent_id() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.appendRuleRequest.parent_id)
  return _internal_parent_id();
}
inline void appendRuleRequest::set_parent_id(::uint32_t value) {
  _internal_set_parent_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.appendRuleRequest.parent_id)
}
inline ::uint32_t appendRuleRequest::_internal_parent_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.parent_id_;
}
inline void appendRuleRequest::_internal_set_parent_id(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.parent_id_ = value;
}

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

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

// appendRuleResponse

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

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

// appendRule

// required .usbguard.IPC.MessageHeader header = 1;
inline bool appendRule::has_header() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline const ::usbguard::IPC::MessageHeader& appendRule::_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& appendRule::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.appendRule.header)
  return _internal_header();
}
inline void appendRule::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.appendRule.header)
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE appendRule::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 appendRule::unsafe_arena_release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.appendRule.header)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL appendRule::_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 appendRule::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.appendRule.header)
  return _msg;
}
inline void appendRule::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.appendRule.header)
}

// required .usbguard.IPC.appendRuleRequest request = 2;
inline bool appendRule::has_request() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void appendRule::clear_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::usbguard::IPC::appendRuleRequest& appendRule::_internal_request() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::appendRuleRequest* p = _impl_.request_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::appendRuleRequest>(&::usbguard::IPC::appendRuleRequest_globals_);
}
inline const ::usbguard::IPC::appendRuleRequest& appendRule::request() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.appendRule.request)
  return _internal_request();
}
inline void appendRule::unsafe_arena_set_allocated_request(
    ::usbguard::IPC::appendRuleRequest* 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::appendRuleRequest*>(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.appendRule.request)
}
inline ::usbguard::IPC::appendRuleRequest* PROTOBUF_NULLABLE appendRule::release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::appendRuleRequest* 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::appendRuleRequest* PROTOBUF_NULLABLE appendRule::unsafe_arena_release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.appendRule.request)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::appendRuleRequest* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::appendRuleRequest* PROTOBUF_NONNULL appendRule::_internal_mutable_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::appendRuleRequest>(GetArena());
    _impl_.request_ = reinterpret_cast<::usbguard::IPC::appendRuleRequest*>(p);
  }
  return _impl_.request_;
}
inline ::usbguard::IPC::appendRuleRequest* PROTOBUF_NONNULL appendRule::mutable_request()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::appendRuleRequest* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.appendRule.request)
  return _msg;
}
inline void appendRule::set_allocated_request(::usbguard::IPC::appendRuleRequest* 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::appendRuleRequest*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.appendRule.request)
}

// optional .usbguard.IPC.appendRuleResponse response = 3;
inline bool appendRule::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void appendRule::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::usbguard::IPC::appendRuleResponse& appendRule::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::appendRuleResponse* p = _impl_.response_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::appendRuleResponse>(&::usbguard::IPC::appendRuleResponse_globals_);
}
inline const ::usbguard::IPC::appendRuleResponse& appendRule::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.appendRule.response)
  return _internal_response();
}
inline void appendRule::unsafe_arena_set_allocated_response(
    ::usbguard::IPC::appendRuleResponse* 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::appendRuleResponse*>(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.appendRule.response)
}
inline ::usbguard::IPC::appendRuleResponse* PROTOBUF_NULLABLE appendRule::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::appendRuleResponse* 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::appendRuleResponse* PROTOBUF_NULLABLE appendRule::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.appendRule.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::appendRuleResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::appendRuleResponse* PROTOBUF_NONNULL appendRule::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::appendRuleResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::usbguard::IPC::appendRuleResponse*>(p);
  }
  return _impl_.response_;
}
inline ::usbguard::IPC::appendRuleResponse* PROTOBUF_NONNULL appendRule::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::appendRuleResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.appendRule.response)
  return _msg;
}
inline void appendRule::set_allocated_response(::usbguard::IPC::appendRuleResponse* 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::appendRuleResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.appendRule.response)
}

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

// removeRuleRequest

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

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

// removeRuleResponse

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

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

// removeRule

// required .usbguard.IPC.MessageHeader header = 1;
inline bool removeRule::has_header() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline const ::usbguard::IPC::MessageHeader& removeRule::_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& removeRule::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.removeRule.header)
  return _internal_header();
}
inline void removeRule::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.removeRule.header)
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE removeRule::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 removeRule::unsafe_arena_release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.removeRule.header)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL removeRule::_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 removeRule::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.removeRule.header)
  return _msg;
}
inline void removeRule::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.removeRule.header)
}

// required .usbguard.IPC.removeRuleRequest request = 2;
inline bool removeRule::has_request() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void removeRule::clear_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::usbguard::IPC::removeRuleRequest& removeRule::_internal_request() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::removeRuleRequest* p = _impl_.request_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::removeRuleRequest>(&::usbguard::IPC::removeRuleRequest_globals_);
}
inline const ::usbguard::IPC::removeRuleRequest& removeRule::request() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.removeRule.request)
  return _internal_request();
}
inline void removeRule::unsafe_arena_set_allocated_request(
    ::usbguard::IPC::removeRuleRequest* 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::removeRuleRequest*>(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.removeRule.request)
}
inline ::usbguard::IPC::removeRuleRequest* PROTOBUF_NULLABLE removeRule::release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::removeRuleRequest* 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::removeRuleRequest* PROTOBUF_NULLABLE removeRule::unsafe_arena_release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.removeRule.request)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::removeRuleRequest* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::removeRuleRequest* PROTOBUF_NONNULL removeRule::_internal_mutable_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::removeRuleRequest>(GetArena());
    _impl_.request_ = reinterpret_cast<::usbguard::IPC::removeRuleRequest*>(p);
  }
  return _impl_.request_;
}
inline ::usbguard::IPC::removeRuleRequest* PROTOBUF_NONNULL removeRule::mutable_request()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::removeRuleRequest* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.removeRule.request)
  return _msg;
}
inline void removeRule::set_allocated_request(::usbguard::IPC::removeRuleRequest* 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::removeRuleRequest*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.removeRule.request)
}

// optional .usbguard.IPC.removeRuleResponse response = 3;
inline bool removeRule::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void removeRule::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::usbguard::IPC::removeRuleResponse& removeRule::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::removeRuleResponse* p = _impl_.response_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::removeRuleResponse>(&::usbguard::IPC::removeRuleResponse_globals_);
}
inline const ::usbguard::IPC::removeRuleResponse& removeRule::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.removeRule.response)
  return _internal_response();
}
inline void removeRule::unsafe_arena_set_allocated_response(
    ::usbguard::IPC::removeRuleResponse* 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::removeRuleResponse*>(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.removeRule.response)
}
inline ::usbguard::IPC::removeRuleResponse* PROTOBUF_NULLABLE removeRule::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::removeRuleResponse* 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::removeRuleResponse* PROTOBUF_NULLABLE removeRule::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.removeRule.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::removeRuleResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::removeRuleResponse* PROTOBUF_NONNULL removeRule::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::removeRuleResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::usbguard::IPC::removeRuleResponse*>(p);
  }
  return _impl_.response_;
}
inline ::usbguard::IPC::removeRuleResponse* PROTOBUF_NONNULL removeRule::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::removeRuleResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.removeRule.response)
  return _msg;
}
inline void removeRule::set_allocated_response(::usbguard::IPC::removeRuleResponse* 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::removeRuleResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.removeRule.response)
}

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

// checkIPCPermissionsRequest

// required uint32 uid = 1;
inline bool checkIPCPermissionsRequest::has_uid() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void checkIPCPermissionsRequest::clear_uid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.uid_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint32_t checkIPCPermissionsRequest::uid() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissionsRequest.uid)
  return _internal_uid();
}
inline void checkIPCPermissionsRequest::set_uid(::uint32_t value) {
  _internal_set_uid(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.checkIPCPermissionsRequest.uid)
}
inline ::uint32_t checkIPCPermissionsRequest::_internal_uid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.uid_;
}
inline void checkIPCPermissionsRequest::_internal_set_uid(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.uid_ = value;
}

// required uint32 gid = 2;
inline bool checkIPCPermissionsRequest::has_gid() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void checkIPCPermissionsRequest::clear_gid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gid_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint32_t checkIPCPermissionsRequest::gid() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissionsRequest.gid)
  return _internal_gid();
}
inline void checkIPCPermissionsRequest::set_gid(::uint32_t value) {
  _internal_set_gid(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.checkIPCPermissionsRequest.gid)
}
inline ::uint32_t checkIPCPermissionsRequest::_internal_gid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.gid_;
}
inline void checkIPCPermissionsRequest::_internal_set_gid(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.gid_ = value;
}

// required string section = 3;
inline bool checkIPCPermissionsRequest::has_section() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void checkIPCPermissionsRequest::clear_section() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.section_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& checkIPCPermissionsRequest::section() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissionsRequest.section)
  return _internal_section();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void checkIPCPermissionsRequest::set_section(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.section_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.checkIPCPermissionsRequest.section)
}
inline ::std::string* PROTOBUF_NONNULL checkIPCPermissionsRequest::mutable_section()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_section();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.checkIPCPermissionsRequest.section)
  return _s;
}
inline const ::std::string& checkIPCPermissionsRequest::_internal_section() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.section_.Get();
}
inline void checkIPCPermissionsRequest::_internal_set_section(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.section_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL checkIPCPermissionsRequest::_internal_mutable_section() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.section_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE checkIPCPermissionsRequest::release_section() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.checkIPCPermissionsRequest.section)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.section_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.section_.Set("", GetArena());
  }
  return released;
}
inline void checkIPCPermissionsRequest::set_allocated_section(::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_.section_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.section_.IsDefault()) {
    _impl_.section_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.checkIPCPermissionsRequest.section)
}

// required string privilege = 4;
inline bool checkIPCPermissionsRequest::has_privilege() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void checkIPCPermissionsRequest::clear_privilege() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.privilege_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& checkIPCPermissionsRequest::privilege() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissionsRequest.privilege)
  return _internal_privilege();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void checkIPCPermissionsRequest::set_privilege(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.privilege_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:usbguard.IPC.checkIPCPermissionsRequest.privilege)
}
inline ::std::string* PROTOBUF_NONNULL checkIPCPermissionsRequest::mutable_privilege()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_privilege();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.checkIPCPermissionsRequest.privilege)
  return _s;
}
inline const ::std::string& checkIPCPermissionsRequest::_internal_privilege() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.privilege_.Get();
}
inline void checkIPCPermissionsRequest::_internal_set_privilege(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.privilege_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL checkIPCPermissionsRequest::_internal_mutable_privilege() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.privilege_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE checkIPCPermissionsRequest::release_privilege() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.checkIPCPermissionsRequest.privilege)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.privilege_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.privilege_.Set("", GetArena());
  }
  return released;
}
inline void checkIPCPermissionsRequest::set_allocated_privilege(::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_.privilege_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.privilege_.IsDefault()) {
    _impl_.privilege_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.checkIPCPermissionsRequest.privilege)
}

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

// checkIPCPermissionsResponse

// required bool permit = 1;
inline bool checkIPCPermissionsResponse::has_permit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void checkIPCPermissionsResponse::clear_permit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permit_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline bool checkIPCPermissionsResponse::permit() const {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissionsResponse.permit)
  return _internal_permit();
}
inline void checkIPCPermissionsResponse::set_permit(bool value) {
  _internal_set_permit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:usbguard.IPC.checkIPCPermissionsResponse.permit)
}
inline bool checkIPCPermissionsResponse::_internal_permit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.permit_;
}
inline void checkIPCPermissionsResponse::_internal_set_permit(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permit_ = value;
}

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

// checkIPCPermissions

// required .usbguard.IPC.MessageHeader header = 1;
inline bool checkIPCPermissions::has_header() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline const ::usbguard::IPC::MessageHeader& checkIPCPermissions::_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& checkIPCPermissions::header() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissions.header)
  return _internal_header();
}
inline void checkIPCPermissions::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.checkIPCPermissions.header)
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NULLABLE checkIPCPermissions::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 checkIPCPermissions::unsafe_arena_release_header() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.checkIPCPermissions.header)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::usbguard::IPC::MessageHeader* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::MessageHeader* PROTOBUF_NONNULL checkIPCPermissions::_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 checkIPCPermissions::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.checkIPCPermissions.header)
  return _msg;
}
inline void checkIPCPermissions::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.checkIPCPermissions.header)
}

// required .usbguard.IPC.checkIPCPermissionsRequest request = 2;
inline bool checkIPCPermissions::has_request() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.request_ != nullptr);
  return value;
}
inline void checkIPCPermissions::clear_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ != nullptr) _impl_.request_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::usbguard::IPC::checkIPCPermissionsRequest& checkIPCPermissions::_internal_request() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::checkIPCPermissionsRequest* p = _impl_.request_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::checkIPCPermissionsRequest>(&::usbguard::IPC::checkIPCPermissionsRequest_globals_);
}
inline const ::usbguard::IPC::checkIPCPermissionsRequest& checkIPCPermissions::request() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissions.request)
  return _internal_request();
}
inline void checkIPCPermissions::unsafe_arena_set_allocated_request(
    ::usbguard::IPC::checkIPCPermissionsRequest* 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::checkIPCPermissionsRequest*>(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.checkIPCPermissions.request)
}
inline ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NULLABLE checkIPCPermissions::release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::checkIPCPermissionsRequest* 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::checkIPCPermissionsRequest* PROTOBUF_NULLABLE checkIPCPermissions::unsafe_arena_release_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.checkIPCPermissions.request)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::checkIPCPermissionsRequest* temp = _impl_.request_;
  _impl_.request_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NONNULL checkIPCPermissions::_internal_mutable_request() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.request_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::checkIPCPermissionsRequest>(GetArena());
    _impl_.request_ = reinterpret_cast<::usbguard::IPC::checkIPCPermissionsRequest*>(p);
  }
  return _impl_.request_;
}
inline ::usbguard::IPC::checkIPCPermissionsRequest* PROTOBUF_NONNULL checkIPCPermissions::mutable_request()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::usbguard::IPC::checkIPCPermissionsRequest* _msg = _internal_mutable_request();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.checkIPCPermissions.request)
  return _msg;
}
inline void checkIPCPermissions::set_allocated_request(::usbguard::IPC::checkIPCPermissionsRequest* 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::checkIPCPermissionsRequest*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.checkIPCPermissions.request)
}

// optional .usbguard.IPC.checkIPCPermissionsResponse response = 3;
inline bool checkIPCPermissions::has_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.response_ != nullptr);
  return value;
}
inline void checkIPCPermissions::clear_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ != nullptr) _impl_.response_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::usbguard::IPC::checkIPCPermissionsResponse& checkIPCPermissions::_internal_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::usbguard::IPC::checkIPCPermissionsResponse* p = _impl_.response_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::usbguard::IPC::checkIPCPermissionsResponse>(&::usbguard::IPC::checkIPCPermissionsResponse_globals_);
}
inline const ::usbguard::IPC::checkIPCPermissionsResponse& checkIPCPermissions::response() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:usbguard.IPC.checkIPCPermissions.response)
  return _internal_response();
}
inline void checkIPCPermissions::unsafe_arena_set_allocated_response(
    ::usbguard::IPC::checkIPCPermissionsResponse* 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::checkIPCPermissionsResponse*>(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.checkIPCPermissions.response)
}
inline ::usbguard::IPC::checkIPCPermissionsResponse* PROTOBUF_NULLABLE checkIPCPermissions::release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::checkIPCPermissionsResponse* 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::checkIPCPermissionsResponse* PROTOBUF_NULLABLE checkIPCPermissions::unsafe_arena_release_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:usbguard.IPC.checkIPCPermissions.response)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::checkIPCPermissionsResponse* temp = _impl_.response_;
  _impl_.response_ = nullptr;
  return temp;
}
inline ::usbguard::IPC::checkIPCPermissionsResponse* PROTOBUF_NONNULL checkIPCPermissions::_internal_mutable_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.response_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::usbguard::IPC::checkIPCPermissionsResponse>(GetArena());
    _impl_.response_ = reinterpret_cast<::usbguard::IPC::checkIPCPermissionsResponse*>(p);
  }
  return _impl_.response_;
}
inline ::usbguard::IPC::checkIPCPermissionsResponse* PROTOBUF_NONNULL checkIPCPermissions::mutable_response()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::usbguard::IPC::checkIPCPermissionsResponse* _msg = _internal_mutable_response();
  // @@protoc_insertion_point(field_mutable:usbguard.IPC.checkIPCPermissions.response)
  return _msg;
}
inline void checkIPCPermissions::set_allocated_response(::usbguard::IPC::checkIPCPermissionsResponse* 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::checkIPCPermissionsResponse*>(value);
  // @@protoc_insertion_point(field_set_allocated:usbguard.IPC.checkIPCPermissions.response)
}

#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  // Policy_2eproto_2epb_2eh
