// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: keyboard.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_keyboard_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_keyboard_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_keyboard_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_keyboard_2eproto;
namespace keyboard {
namespace cdc {
class Ack;
class AckDefaultTypeInternal;
extern AckDefaultTypeInternal _Ack_default_instance_;
class Bitmap;
class BitmapDefaultTypeInternal;
extern BitmapDefaultTypeInternal _Bitmap_default_instance_;
class CdcFrame;
class CdcFrameDefaultTypeInternal;
extern CdcFrameDefaultTypeInternal _CdcFrame_default_instance_;
class CdcPacketBody;
class CdcPacketBodyDefaultTypeInternal;
extern CdcPacketBodyDefaultTypeInternal _CdcPacketBody_default_instance_;
class Error;
class ErrorDefaultTypeInternal;
extern ErrorDefaultTypeInternal _Error_default_instance_;
class FunctionKeyEvent;
class FunctionKeyEventDefaultTypeInternal;
extern FunctionKeyEventDefaultTypeInternal _FunctionKeyEvent_default_instance_;
class HelloReq;
class HelloReqDefaultTypeInternal;
extern HelloReqDefaultTypeInternal _HelloReq_default_instance_;
class HelloRsp;
class HelloRspDefaultTypeInternal;
extern HelloRspDefaultTypeInternal _HelloRsp_default_instance_;
class LedState;
class LedStateDefaultTypeInternal;
extern LedStateDefaultTypeInternal _LedState_default_instance_;
class ThemeRgb;
class ThemeRgbDefaultTypeInternal;
extern ThemeRgbDefaultTypeInternal _ThemeRgb_default_instance_;
class TimeSync;
class TimeSyncDefaultTypeInternal;
extern TimeSyncDefaultTypeInternal _TimeSync_default_instance_;
}  // namespace cdc
}  // namespace keyboard
PROTOBUF_NAMESPACE_OPEN
template<> ::keyboard::cdc::Ack* Arena::CreateMaybeMessage<::keyboard::cdc::Ack>(Arena*);
template<> ::keyboard::cdc::Bitmap* Arena::CreateMaybeMessage<::keyboard::cdc::Bitmap>(Arena*);
template<> ::keyboard::cdc::CdcFrame* Arena::CreateMaybeMessage<::keyboard::cdc::CdcFrame>(Arena*);
template<> ::keyboard::cdc::CdcPacketBody* Arena::CreateMaybeMessage<::keyboard::cdc::CdcPacketBody>(Arena*);
template<> ::keyboard::cdc::Error* Arena::CreateMaybeMessage<::keyboard::cdc::Error>(Arena*);
template<> ::keyboard::cdc::FunctionKeyEvent* Arena::CreateMaybeMessage<::keyboard::cdc::FunctionKeyEvent>(Arena*);
template<> ::keyboard::cdc::HelloReq* Arena::CreateMaybeMessage<::keyboard::cdc::HelloReq>(Arena*);
template<> ::keyboard::cdc::HelloRsp* Arena::CreateMaybeMessage<::keyboard::cdc::HelloRsp>(Arena*);
template<> ::keyboard::cdc::LedState* Arena::CreateMaybeMessage<::keyboard::cdc::LedState>(Arena*);
template<> ::keyboard::cdc::ThemeRgb* Arena::CreateMaybeMessage<::keyboard::cdc::ThemeRgb>(Arena*);
template<> ::keyboard::cdc::TimeSync* Arena::CreateMaybeMessage<::keyboard::cdc::TimeSync>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace keyboard {
namespace cdc {

enum CdcPacketType : int {
  CDC_PACKET_TYPE_UNKNOWN = 0,
  CDC_PACKET_TYPE_HELLO_REQ = 1,
  CDC_PACKET_TYPE_HELLO_RSP = 2,
  CDC_PACKET_TYPE_BITMAP = 16,
  CDC_PACKET_TYPE_FUNCTION_KEY_EVENT = 32,
  CDC_PACKET_TYPE_LED_STATE = 33,
  CDC_PACKET_TYPE_TIME_SYNC = 48,
  CDC_PACKET_TYPE_THEME_RGB = 49,
  CDC_PACKET_TYPE_ACK = 126,
  CDC_PACKET_TYPE_ERROR = 127,
  CdcPacketType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CdcPacketType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CdcPacketType_IsValid(int value);
constexpr CdcPacketType CdcPacketType_MIN = CDC_PACKET_TYPE_UNKNOWN;
constexpr CdcPacketType CdcPacketType_MAX = CDC_PACKET_TYPE_ERROR;
constexpr int CdcPacketType_ARRAYSIZE = CdcPacketType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CdcPacketType_descriptor();
template<typename T>
inline const std::string& CdcPacketType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CdcPacketType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CdcPacketType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CdcPacketType_descriptor(), enum_t_value);
}
inline bool CdcPacketType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CdcPacketType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CdcPacketType>(
    CdcPacketType_descriptor(), name, value);
}
enum KeyAction : int {
  KEY_ACTION_RELEASE = 0,
  KEY_ACTION_PRESS = 1,
  KeyAction_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  KeyAction_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool KeyAction_IsValid(int value);
constexpr KeyAction KeyAction_MIN = KEY_ACTION_RELEASE;
constexpr KeyAction KeyAction_MAX = KEY_ACTION_PRESS;
constexpr int KeyAction_ARRAYSIZE = KeyAction_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeyAction_descriptor();
template<typename T>
inline const std::string& KeyAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, KeyAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function KeyAction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    KeyAction_descriptor(), enum_t_value);
}
inline bool KeyAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeyAction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeyAction>(
    KeyAction_descriptor(), name, value);
}
enum ErrorCode : int {
  ERROR_CODE_NONE = 0,
  ERROR_CODE_UNKNOWN_TYPE = 1,
  ERROR_CODE_INVALID_LENGTH = 2,
  ERROR_CODE_INVALID_PARAM = 3,
  ERROR_CODE_NOT_READY = 4,
  ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool ErrorCode_IsValid(int value);
constexpr ErrorCode ErrorCode_MIN = ERROR_CODE_NONE;
constexpr ErrorCode ErrorCode_MAX = ERROR_CODE_NOT_READY;
constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
template<typename T>
inline const std::string& ErrorCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ErrorCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ErrorCode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ErrorCode_descriptor(), enum_t_value);
}
inline bool ErrorCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorCode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
    ErrorCode_descriptor(), name, value);
}
// ===================================================================

class CdcFrame PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.CdcFrame) */ {
 public:
  inline CdcFrame() : CdcFrame(nullptr) {}
  virtual ~CdcFrame();

  CdcFrame(const CdcFrame& from);
  CdcFrame(CdcFrame&& from) noexcept
    : CdcFrame() {
    *this = ::std::move(from);
  }

  inline CdcFrame& operator=(const CdcFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline CdcFrame& operator=(CdcFrame&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CdcFrame& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CdcFrame* internal_default_instance() {
    return reinterpret_cast<const CdcFrame*>(
               &_CdcFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CdcFrame& a, CdcFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(CdcFrame* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CdcFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CdcFrame* New() const final {
    return CreateMaybeMessage<CdcFrame>(nullptr);
  }

  CdcFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CdcFrame>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CdcFrame& from);
  void MergeFrom(const CdcFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CdcFrame* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.CdcFrame";
  }
  protected:
  explicit CdcFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPayloadFieldNumber = 5,
    kHead1FieldNumber = 1,
    kHead2FieldNumber = 2,
    kPayloadLengthFieldNumber = 3,
    kTypeFieldNumber = 4,
    kChecksumFieldNumber = 6,
  };
  // bytes payload = 5;
  void clear_payload();
  const std::string& payload() const;
  void set_payload(const std::string& value);
  void set_payload(std::string&& value);
  void set_payload(const char* value);
  void set_payload(const void* value, size_t size);
  std::string* mutable_payload();
  std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // uint32 head1 = 1;
  void clear_head1();
  ::PROTOBUF_NAMESPACE_ID::uint32 head1() const;
  void set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_head1() const;
  void _internal_set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 head2 = 2;
  void clear_head2();
  ::PROTOBUF_NAMESPACE_ID::uint32 head2() const;
  void set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_head2() const;
  void _internal_set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 payload_length = 3;
  void clear_payload_length();
  ::PROTOBUF_NAMESPACE_ID::uint32 payload_length() const;
  void set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_payload_length() const;
  void _internal_set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .keyboard.cdc.CdcPacketType type = 4;
  void clear_type();
  ::keyboard::cdc::CdcPacketType type() const;
  void set_type(::keyboard::cdc::CdcPacketType value);
  private:
  ::keyboard::cdc::CdcPacketType _internal_type() const;
  void _internal_set_type(::keyboard::cdc::CdcPacketType value);
  public:

  // uint32 checksum = 6;
  void clear_checksum();
  ::PROTOBUF_NAMESPACE_ID::uint32 checksum() const;
  void set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_checksum() const;
  void _internal_set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.CdcFrame)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  ::PROTOBUF_NAMESPACE_ID::uint32 head1_;
  ::PROTOBUF_NAMESPACE_ID::uint32 head2_;
  ::PROTOBUF_NAMESPACE_ID::uint32 payload_length_;
  int type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 checksum_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class CdcPacketBody PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.CdcPacketBody) */ {
 public:
  inline CdcPacketBody() : CdcPacketBody(nullptr) {}
  virtual ~CdcPacketBody();

  CdcPacketBody(const CdcPacketBody& from);
  CdcPacketBody(CdcPacketBody&& from) noexcept
    : CdcPacketBody() {
    *this = ::std::move(from);
  }

  inline CdcPacketBody& operator=(const CdcPacketBody& from) {
    CopyFrom(from);
    return *this;
  }
  inline CdcPacketBody& operator=(CdcPacketBody&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CdcPacketBody& default_instance();

  enum BodyCase {
    kHelloReq = 1,
    kHelloRsp = 2,
    kBitmap = 3,
    kFunctionKeyEvent = 4,
    kLedState = 5,
    kTimeSync = 6,
    kThemeRgb = 7,
    kAck = 8,
    kError = 9,
    BODY_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CdcPacketBody* internal_default_instance() {
    return reinterpret_cast<const CdcPacketBody*>(
               &_CdcPacketBody_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CdcPacketBody& a, CdcPacketBody& b) {
    a.Swap(&b);
  }
  inline void Swap(CdcPacketBody* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CdcPacketBody* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline CdcPacketBody* New() const final {
    return CreateMaybeMessage<CdcPacketBody>(nullptr);
  }

  CdcPacketBody* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CdcPacketBody>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CdcPacketBody& from);
  void MergeFrom(const CdcPacketBody& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CdcPacketBody* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.CdcPacketBody";
  }
  protected:
  explicit CdcPacketBody(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kHelloReqFieldNumber = 1,
    kHelloRspFieldNumber = 2,
    kBitmapFieldNumber = 3,
    kFunctionKeyEventFieldNumber = 4,
    kLedStateFieldNumber = 5,
    kTimeSyncFieldNumber = 6,
    kThemeRgbFieldNumber = 7,
    kAckFieldNumber = 8,
    kErrorFieldNumber = 9,
  };
  // .keyboard.cdc.HelloReq hello_req = 1;
  bool has_hello_req() const;
  private:
  bool _internal_has_hello_req() const;
  public:
  void clear_hello_req();
  const ::keyboard::cdc::HelloReq& hello_req() const;
  ::keyboard::cdc::HelloReq* release_hello_req();
  ::keyboard::cdc::HelloReq* mutable_hello_req();
  void set_allocated_hello_req(::keyboard::cdc::HelloReq* hello_req);
  private:
  const ::keyboard::cdc::HelloReq& _internal_hello_req() const;
  ::keyboard::cdc::HelloReq* _internal_mutable_hello_req();
  public:
  void unsafe_arena_set_allocated_hello_req(
      ::keyboard::cdc::HelloReq* hello_req);
  ::keyboard::cdc::HelloReq* unsafe_arena_release_hello_req();

  // .keyboard.cdc.HelloRsp hello_rsp = 2;
  bool has_hello_rsp() const;
  private:
  bool _internal_has_hello_rsp() const;
  public:
  void clear_hello_rsp();
  const ::keyboard::cdc::HelloRsp& hello_rsp() const;
  ::keyboard::cdc::HelloRsp* release_hello_rsp();
  ::keyboard::cdc::HelloRsp* mutable_hello_rsp();
  void set_allocated_hello_rsp(::keyboard::cdc::HelloRsp* hello_rsp);
  private:
  const ::keyboard::cdc::HelloRsp& _internal_hello_rsp() const;
  ::keyboard::cdc::HelloRsp* _internal_mutable_hello_rsp();
  public:
  void unsafe_arena_set_allocated_hello_rsp(
      ::keyboard::cdc::HelloRsp* hello_rsp);
  ::keyboard::cdc::HelloRsp* unsafe_arena_release_hello_rsp();

  // .keyboard.cdc.Bitmap bitmap = 3;
  bool has_bitmap() const;
  private:
  bool _internal_has_bitmap() const;
  public:
  void clear_bitmap();
  const ::keyboard::cdc::Bitmap& bitmap() const;
  ::keyboard::cdc::Bitmap* release_bitmap();
  ::keyboard::cdc::Bitmap* mutable_bitmap();
  void set_allocated_bitmap(::keyboard::cdc::Bitmap* bitmap);
  private:
  const ::keyboard::cdc::Bitmap& _internal_bitmap() const;
  ::keyboard::cdc::Bitmap* _internal_mutable_bitmap();
  public:
  void unsafe_arena_set_allocated_bitmap(
      ::keyboard::cdc::Bitmap* bitmap);
  ::keyboard::cdc::Bitmap* unsafe_arena_release_bitmap();

  // .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
  bool has_function_key_event() const;
  private:
  bool _internal_has_function_key_event() const;
  public:
  void clear_function_key_event();
  const ::keyboard::cdc::FunctionKeyEvent& function_key_event() const;
  ::keyboard::cdc::FunctionKeyEvent* release_function_key_event();
  ::keyboard::cdc::FunctionKeyEvent* mutable_function_key_event();
  void set_allocated_function_key_event(::keyboard::cdc::FunctionKeyEvent* function_key_event);
  private:
  const ::keyboard::cdc::FunctionKeyEvent& _internal_function_key_event() const;
  ::keyboard::cdc::FunctionKeyEvent* _internal_mutable_function_key_event();
  public:
  void unsafe_arena_set_allocated_function_key_event(
      ::keyboard::cdc::FunctionKeyEvent* function_key_event);
  ::keyboard::cdc::FunctionKeyEvent* unsafe_arena_release_function_key_event();

  // .keyboard.cdc.LedState led_state = 5;
  bool has_led_state() const;
  private:
  bool _internal_has_led_state() const;
  public:
  void clear_led_state();
  const ::keyboard::cdc::LedState& led_state() const;
  ::keyboard::cdc::LedState* release_led_state();
  ::keyboard::cdc::LedState* mutable_led_state();
  void set_allocated_led_state(::keyboard::cdc::LedState* led_state);
  private:
  const ::keyboard::cdc::LedState& _internal_led_state() const;
  ::keyboard::cdc::LedState* _internal_mutable_led_state();
  public:
  void unsafe_arena_set_allocated_led_state(
      ::keyboard::cdc::LedState* led_state);
  ::keyboard::cdc::LedState* unsafe_arena_release_led_state();

  // .keyboard.cdc.TimeSync time_sync = 6;
  bool has_time_sync() const;
  private:
  bool _internal_has_time_sync() const;
  public:
  void clear_time_sync();
  const ::keyboard::cdc::TimeSync& time_sync() const;
  ::keyboard::cdc::TimeSync* release_time_sync();
  ::keyboard::cdc::TimeSync* mutable_time_sync();
  void set_allocated_time_sync(::keyboard::cdc::TimeSync* time_sync);
  private:
  const ::keyboard::cdc::TimeSync& _internal_time_sync() const;
  ::keyboard::cdc::TimeSync* _internal_mutable_time_sync();
  public:
  void unsafe_arena_set_allocated_time_sync(
      ::keyboard::cdc::TimeSync* time_sync);
  ::keyboard::cdc::TimeSync* unsafe_arena_release_time_sync();

  // .keyboard.cdc.ThemeRgb theme_rgb = 7;
  bool has_theme_rgb() const;
  private:
  bool _internal_has_theme_rgb() const;
  public:
  void clear_theme_rgb();
  const ::keyboard::cdc::ThemeRgb& theme_rgb() const;
  ::keyboard::cdc::ThemeRgb* release_theme_rgb();
  ::keyboard::cdc::ThemeRgb* mutable_theme_rgb();
  void set_allocated_theme_rgb(::keyboard::cdc::ThemeRgb* theme_rgb);
  private:
  const ::keyboard::cdc::ThemeRgb& _internal_theme_rgb() const;
  ::keyboard::cdc::ThemeRgb* _internal_mutable_theme_rgb();
  public:
  void unsafe_arena_set_allocated_theme_rgb(
      ::keyboard::cdc::ThemeRgb* theme_rgb);
  ::keyboard::cdc::ThemeRgb* unsafe_arena_release_theme_rgb();

  // .keyboard.cdc.Ack ack = 8;
  bool has_ack() const;
  private:
  bool _internal_has_ack() const;
  public:
  void clear_ack();
  const ::keyboard::cdc::Ack& ack() const;
  ::keyboard::cdc::Ack* release_ack();
  ::keyboard::cdc::Ack* mutable_ack();
  void set_allocated_ack(::keyboard::cdc::Ack* ack);
  private:
  const ::keyboard::cdc::Ack& _internal_ack() const;
  ::keyboard::cdc::Ack* _internal_mutable_ack();
  public:
  void unsafe_arena_set_allocated_ack(
      ::keyboard::cdc::Ack* ack);
  ::keyboard::cdc::Ack* unsafe_arena_release_ack();

  // .keyboard.cdc.Error error = 9;
  bool has_error() const;
  private:
  bool _internal_has_error() const;
  public:
  void clear_error();
  const ::keyboard::cdc::Error& error() const;
  ::keyboard::cdc::Error* release_error();
  ::keyboard::cdc::Error* mutable_error();
  void set_allocated_error(::keyboard::cdc::Error* error);
  private:
  const ::keyboard::cdc::Error& _internal_error() const;
  ::keyboard::cdc::Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::keyboard::cdc::Error* error);
  ::keyboard::cdc::Error* unsafe_arena_release_error();

  void clear_body();
  BodyCase body_case() const;
  // @@protoc_insertion_point(class_scope:keyboard.cdc.CdcPacketBody)
 private:
  class _Internal;
  void set_has_hello_req();
  void set_has_hello_rsp();
  void set_has_bitmap();
  void set_has_function_key_event();
  void set_has_led_state();
  void set_has_time_sync();
  void set_has_theme_rgb();
  void set_has_ack();
  void set_has_error();

  inline bool has_body() const;
  inline void clear_has_body();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union BodyUnion {
    BodyUnion() {}
    ::keyboard::cdc::HelloReq* hello_req_;
    ::keyboard::cdc::HelloRsp* hello_rsp_;
    ::keyboard::cdc::Bitmap* bitmap_;
    ::keyboard::cdc::FunctionKeyEvent* function_key_event_;
    ::keyboard::cdc::LedState* led_state_;
    ::keyboard::cdc::TimeSync* time_sync_;
    ::keyboard::cdc::ThemeRgb* theme_rgb_;
    ::keyboard::cdc::Ack* ack_;
    ::keyboard::cdc::Error* error_;
  } body_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class HelloReq PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.HelloReq) */ {
 public:
  inline HelloReq() : HelloReq(nullptr) {}
  virtual ~HelloReq();

  HelloReq(const HelloReq& from);
  HelloReq(HelloReq&& from) noexcept
    : HelloReq() {
    *this = ::std::move(from);
  }

  inline HelloReq& operator=(const HelloReq& from) {
    CopyFrom(from);
    return *this;
  }
  inline HelloReq& operator=(HelloReq&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const HelloReq& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HelloReq* internal_default_instance() {
    return reinterpret_cast<const HelloReq*>(
               &_HelloReq_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(HelloReq& a, HelloReq& b) {
    a.Swap(&b);
  }
  inline void Swap(HelloReq* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HelloReq* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline HelloReq* New() const final {
    return CreateMaybeMessage<HelloReq>(nullptr);
  }

  HelloReq* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HelloReq>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const HelloReq& from);
  void MergeFrom(const HelloReq& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HelloReq* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.HelloReq";
  }
  protected:
  explicit HelloReq(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProtocolVersionFieldNumber = 1,
  };
  // uint32 protocol_version = 1;
  void clear_protocol_version();
  ::PROTOBUF_NAMESPACE_ID::uint32 protocol_version() const;
  void set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protocol_version() const;
  void _internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.HelloReq)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 protocol_version_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class HelloRsp PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.HelloRsp) */ {
 public:
  inline HelloRsp() : HelloRsp(nullptr) {}
  virtual ~HelloRsp();

  HelloRsp(const HelloRsp& from);
  HelloRsp(HelloRsp&& from) noexcept
    : HelloRsp() {
    *this = ::std::move(from);
  }

  inline HelloRsp& operator=(const HelloRsp& from) {
    CopyFrom(from);
    return *this;
  }
  inline HelloRsp& operator=(HelloRsp&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const HelloRsp& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HelloRsp* internal_default_instance() {
    return reinterpret_cast<const HelloRsp*>(
               &_HelloRsp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(HelloRsp& a, HelloRsp& b) {
    a.Swap(&b);
  }
  inline void Swap(HelloRsp* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HelloRsp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline HelloRsp* New() const final {
    return CreateMaybeMessage<HelloRsp>(nullptr);
  }

  HelloRsp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<HelloRsp>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const HelloRsp& from);
  void MergeFrom(const HelloRsp& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HelloRsp* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.HelloRsp";
  }
  protected:
  explicit HelloRsp(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProtocolVersionFieldNumber = 1,
    kVendorIdFieldNumber = 2,
    kProductIdFieldNumber = 3,
    kFirmwareMajorFieldNumber = 4,
    kFirmwareMinorFieldNumber = 5,
    kCapabilityFlagsFieldNumber = 6,
  };
  // uint32 protocol_version = 1;
  void clear_protocol_version();
  ::PROTOBUF_NAMESPACE_ID::uint32 protocol_version() const;
  void set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protocol_version() const;
  void _internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 vendor_id = 2;
  void clear_vendor_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 vendor_id() const;
  void set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_vendor_id() const;
  void _internal_set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 product_id = 3;
  void clear_product_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 product_id() const;
  void set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_product_id() const;
  void _internal_set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 firmware_major = 4;
  void clear_firmware_major();
  ::PROTOBUF_NAMESPACE_ID::uint32 firmware_major() const;
  void set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_firmware_major() const;
  void _internal_set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 firmware_minor = 5;
  void clear_firmware_minor();
  ::PROTOBUF_NAMESPACE_ID::uint32 firmware_minor() const;
  void set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_firmware_minor() const;
  void _internal_set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 capability_flags = 6;
  void clear_capability_flags();
  ::PROTOBUF_NAMESPACE_ID::uint32 capability_flags() const;
  void set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_capability_flags() const;
  void _internal_set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.HelloRsp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 protocol_version_;
  ::PROTOBUF_NAMESPACE_ID::uint32 vendor_id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 product_id_;
  ::PROTOBUF_NAMESPACE_ID::uint32 firmware_major_;
  ::PROTOBUF_NAMESPACE_ID::uint32 firmware_minor_;
  ::PROTOBUF_NAMESPACE_ID::uint32 capability_flags_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class Bitmap PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.Bitmap) */ {
 public:
  inline Bitmap() : Bitmap(nullptr) {}
  virtual ~Bitmap();

  Bitmap(const Bitmap& from);
  Bitmap(Bitmap&& from) noexcept
    : Bitmap() {
    *this = ::std::move(from);
  }

  inline Bitmap& operator=(const Bitmap& from) {
    CopyFrom(from);
    return *this;
  }
  inline Bitmap& operator=(Bitmap&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Bitmap& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Bitmap* internal_default_instance() {
    return reinterpret_cast<const Bitmap*>(
               &_Bitmap_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Bitmap& a, Bitmap& b) {
    a.Swap(&b);
  }
  inline void Swap(Bitmap* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Bitmap* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Bitmap* New() const final {
    return CreateMaybeMessage<Bitmap>(nullptr);
  }

  Bitmap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Bitmap>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Bitmap& from);
  void MergeFrom(const Bitmap& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Bitmap* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.Bitmap";
  }
  protected:
  explicit Bitmap(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUsageBitmapFieldNumber = 1,
  };
  // bytes usage_bitmap = 1;
  void clear_usage_bitmap();
  const std::string& usage_bitmap() const;
  void set_usage_bitmap(const std::string& value);
  void set_usage_bitmap(std::string&& value);
  void set_usage_bitmap(const char* value);
  void set_usage_bitmap(const void* value, size_t size);
  std::string* mutable_usage_bitmap();
  std::string* release_usage_bitmap();
  void set_allocated_usage_bitmap(std::string* usage_bitmap);
  private:
  const std::string& _internal_usage_bitmap() const;
  void _internal_set_usage_bitmap(const std::string& value);
  std::string* _internal_mutable_usage_bitmap();
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.Bitmap)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr usage_bitmap_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class FunctionKeyEvent PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.FunctionKeyEvent) */ {
 public:
  inline FunctionKeyEvent() : FunctionKeyEvent(nullptr) {}
  virtual ~FunctionKeyEvent();

  FunctionKeyEvent(const FunctionKeyEvent& from);
  FunctionKeyEvent(FunctionKeyEvent&& from) noexcept
    : FunctionKeyEvent() {
    *this = ::std::move(from);
  }

  inline FunctionKeyEvent& operator=(const FunctionKeyEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionKeyEvent& operator=(FunctionKeyEvent&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const FunctionKeyEvent& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FunctionKeyEvent* internal_default_instance() {
    return reinterpret_cast<const FunctionKeyEvent*>(
               &_FunctionKeyEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(FunctionKeyEvent& a, FunctionKeyEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionKeyEvent* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionKeyEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline FunctionKeyEvent* New() const final {
    return CreateMaybeMessage<FunctionKeyEvent>(nullptr);
  }

  FunctionKeyEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FunctionKeyEvent>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const FunctionKeyEvent& from);
  void MergeFrom(const FunctionKeyEvent& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionKeyEvent* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.FunctionKeyEvent";
  }
  protected:
  explicit FunctionKeyEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUsageFieldNumber = 1,
    kActionFieldNumber = 2,
  };
  // uint32 usage = 1;
  void clear_usage();
  ::PROTOBUF_NAMESPACE_ID::uint32 usage() const;
  void set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_usage() const;
  void _internal_set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .keyboard.cdc.KeyAction action = 2;
  void clear_action();
  ::keyboard::cdc::KeyAction action() const;
  void set_action(::keyboard::cdc::KeyAction value);
  private:
  ::keyboard::cdc::KeyAction _internal_action() const;
  void _internal_set_action(::keyboard::cdc::KeyAction value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.FunctionKeyEvent)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 usage_;
  int action_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class LedState PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.LedState) */ {
 public:
  inline LedState() : LedState(nullptr) {}
  virtual ~LedState();

  LedState(const LedState& from);
  LedState(LedState&& from) noexcept
    : LedState() {
    *this = ::std::move(from);
  }

  inline LedState& operator=(const LedState& from) {
    CopyFrom(from);
    return *this;
  }
  inline LedState& operator=(LedState&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LedState& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LedState* internal_default_instance() {
    return reinterpret_cast<const LedState*>(
               &_LedState_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(LedState& a, LedState& b) {
    a.Swap(&b);
  }
  inline void Swap(LedState* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LedState* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline LedState* New() const final {
    return CreateMaybeMessage<LedState>(nullptr);
  }

  LedState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LedState>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LedState& from);
  void MergeFrom(const LedState& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LedState* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.LedState";
  }
  protected:
  explicit LedState(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLedMaskFieldNumber = 1,
  };
  // uint32 led_mask = 1;
  void clear_led_mask();
  ::PROTOBUF_NAMESPACE_ID::uint32 led_mask() const;
  void set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_led_mask() const;
  void _internal_set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.LedState)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 led_mask_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class TimeSync PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.TimeSync) */ {
 public:
  inline TimeSync() : TimeSync(nullptr) {}
  virtual ~TimeSync();

  TimeSync(const TimeSync& from);
  TimeSync(TimeSync&& from) noexcept
    : TimeSync() {
    *this = ::std::move(from);
  }

  inline TimeSync& operator=(const TimeSync& from) {
    CopyFrom(from);
    return *this;
  }
  inline TimeSync& operator=(TimeSync&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TimeSync& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TimeSync* internal_default_instance() {
    return reinterpret_cast<const TimeSync*>(
               &_TimeSync_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(TimeSync& a, TimeSync& b) {
    a.Swap(&b);
  }
  inline void Swap(TimeSync* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TimeSync* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline TimeSync* New() const final {
    return CreateMaybeMessage<TimeSync>(nullptr);
  }

  TimeSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TimeSync>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TimeSync& from);
  void MergeFrom(const TimeSync& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TimeSync* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.TimeSync";
  }
  protected:
  explicit TimeSync(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVersionFieldNumber = 1,
    kFlagsFieldNumber = 2,
    kUtcMsFieldNumber = 4,
    kTimezoneMinFieldNumber = 3,
    kAccuracyMsFieldNumber = 5,
  };
  // uint32 version = 1;
  void clear_version();
  ::PROTOBUF_NAMESPACE_ID::uint32 version() const;
  void set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_version() const;
  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 flags = 2;
  void clear_flags();
  ::PROTOBUF_NAMESPACE_ID::uint32 flags() const;
  void set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_flags() const;
  void _internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // fixed64 utc_ms = 4;
  void clear_utc_ms();
  ::PROTOBUF_NAMESPACE_ID::uint64 utc_ms() const;
  void set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_utc_ms() const;
  void _internal_set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // sint32 timezone_min = 3;
  void clear_timezone_min();
  ::PROTOBUF_NAMESPACE_ID::int32 timezone_min() const;
  void set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_timezone_min() const;
  void _internal_set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // fixed32 accuracy_ms = 5;
  void clear_accuracy_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 accuracy_ms() const;
  void set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_accuracy_ms() const;
  void _internal_set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.TimeSync)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 version_;
  ::PROTOBUF_NAMESPACE_ID::uint32 flags_;
  ::PROTOBUF_NAMESPACE_ID::uint64 utc_ms_;
  ::PROTOBUF_NAMESPACE_ID::int32 timezone_min_;
  ::PROTOBUF_NAMESPACE_ID::uint32 accuracy_ms_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class ThemeRgb PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.ThemeRgb) */ {
 public:
  inline ThemeRgb() : ThemeRgb(nullptr) {}
  virtual ~ThemeRgb();

  ThemeRgb(const ThemeRgb& from);
  ThemeRgb(ThemeRgb&& from) noexcept
    : ThemeRgb() {
    *this = ::std::move(from);
  }

  inline ThemeRgb& operator=(const ThemeRgb& from) {
    CopyFrom(from);
    return *this;
  }
  inline ThemeRgb& operator=(ThemeRgb&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ThemeRgb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ThemeRgb* internal_default_instance() {
    return reinterpret_cast<const ThemeRgb*>(
               &_ThemeRgb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(ThemeRgb& a, ThemeRgb& b) {
    a.Swap(&b);
  }
  inline void Swap(ThemeRgb* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ThemeRgb* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline ThemeRgb* New() const final {
    return CreateMaybeMessage<ThemeRgb>(nullptr);
  }

  ThemeRgb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ThemeRgb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ThemeRgb& from);
  void MergeFrom(const ThemeRgb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ThemeRgb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.ThemeRgb";
  }
  protected:
  explicit ThemeRgb(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRedFieldNumber = 1,
    kGreenFieldNumber = 2,
    kBlueFieldNumber = 3,
  };
  // uint32 red = 1;
  void clear_red();
  ::PROTOBUF_NAMESPACE_ID::uint32 red() const;
  void set_red(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_red() const;
  void _internal_set_red(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 green = 2;
  void clear_green();
  ::PROTOBUF_NAMESPACE_ID::uint32 green() const;
  void set_green(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_green() const;
  void _internal_set_green(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 blue = 3;
  void clear_blue();
  ::PROTOBUF_NAMESPACE_ID::uint32 blue() const;
  void set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_blue() const;
  void _internal_set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.ThemeRgb)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 red_;
  ::PROTOBUF_NAMESPACE_ID::uint32 green_;
  ::PROTOBUF_NAMESPACE_ID::uint32 blue_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class Ack PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.Ack) */ {
 public:
  inline Ack() : Ack(nullptr) {}
  virtual ~Ack();

  Ack(const Ack& from);
  Ack(Ack&& from) noexcept
    : Ack() {
    *this = ::std::move(from);
  }

  inline Ack& operator=(const Ack& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ack& operator=(Ack&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Ack& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Ack* internal_default_instance() {
    return reinterpret_cast<const Ack*>(
               &_Ack_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(Ack& a, Ack& b) {
    a.Swap(&b);
  }
  inline void Swap(Ack* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ack* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Ack* New() const final {
    return CreateMaybeMessage<Ack>(nullptr);
  }

  Ack* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Ack>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Ack& from);
  void MergeFrom(const Ack& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Ack* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.Ack";
  }
  protected:
  explicit Ack(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAckedTypeFieldNumber = 1,
  };
  // uint32 acked_type = 1;
  void clear_acked_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 acked_type() const;
  void set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_acked_type() const;
  void _internal_set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.Ack)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 acked_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// -------------------------------------------------------------------

class Error PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:keyboard.cdc.Error) */ {
 public:
  inline Error() : Error(nullptr) {}
  virtual ~Error();

  Error(const Error& from);
  Error(Error&& from) noexcept
    : Error() {
    *this = ::std::move(from);
  }

  inline Error& operator=(const Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline Error& operator=(Error&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Error& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Error* internal_default_instance() {
    return reinterpret_cast<const Error*>(
               &_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(Error& a, Error& b) {
    a.Swap(&b);
  }
  inline void Swap(Error* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Error* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Error* New() const final {
    return CreateMaybeMessage<Error>(nullptr);
  }

  Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Error>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Error& from);
  void MergeFrom(const Error& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Error* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "keyboard.cdc.Error";
  }
  protected:
  explicit Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_keyboard_2eproto);
    return ::descriptor_table_keyboard_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kErrorTypeFieldNumber = 1,
    kErrorCodeFieldNumber = 2,
  };
  // uint32 error_type = 1;
  void clear_error_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 error_type() const;
  void set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_error_type() const;
  void _internal_set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .keyboard.cdc.ErrorCode error_code = 2;
  void clear_error_code();
  ::keyboard::cdc::ErrorCode error_code() const;
  void set_error_code(::keyboard::cdc::ErrorCode value);
  private:
  ::keyboard::cdc::ErrorCode _internal_error_code() const;
  void _internal_set_error_code(::keyboard::cdc::ErrorCode value);
  public:

  // @@protoc_insertion_point(class_scope:keyboard.cdc.Error)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 error_type_;
  int error_code_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_keyboard_2eproto;
};
// ===================================================================


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

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

// uint32 head1 = 1;
inline void CdcFrame::clear_head1() {
  head1_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_head1() const {
  return head1_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::head1() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.head1)
  return _internal_head1();
}
inline void CdcFrame::_internal_set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  head1_ = value;
}
inline void CdcFrame::set_head1(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_head1(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.head1)
}

// uint32 head2 = 2;
inline void CdcFrame::clear_head2() {
  head2_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_head2() const {
  return head2_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::head2() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.head2)
  return _internal_head2();
}
inline void CdcFrame::_internal_set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  head2_ = value;
}
inline void CdcFrame::set_head2(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_head2(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.head2)
}

// uint32 payload_length = 3;
inline void CdcFrame::clear_payload_length() {
  payload_length_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_payload_length() const {
  return payload_length_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::payload_length() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.payload_length)
  return _internal_payload_length();
}
inline void CdcFrame::_internal_set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  payload_length_ = value;
}
inline void CdcFrame::set_payload_length(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_payload_length(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.payload_length)
}

// .keyboard.cdc.CdcPacketType type = 4;
inline void CdcFrame::clear_type() {
  type_ = 0;
}
inline ::keyboard::cdc::CdcPacketType CdcFrame::_internal_type() const {
  return static_cast< ::keyboard::cdc::CdcPacketType >(type_);
}
inline ::keyboard::cdc::CdcPacketType CdcFrame::type() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.type)
  return _internal_type();
}
inline void CdcFrame::_internal_set_type(::keyboard::cdc::CdcPacketType value) {
  
  type_ = value;
}
inline void CdcFrame::set_type(::keyboard::cdc::CdcPacketType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.type)
}

// bytes payload = 5;
inline void CdcFrame::clear_payload() {
  payload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& CdcFrame::payload() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.payload)
  return _internal_payload();
}
inline void CdcFrame::set_payload(const std::string& value) {
  _internal_set_payload(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.payload)
}
inline std::string* CdcFrame::mutable_payload() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcFrame.payload)
  return _internal_mutable_payload();
}
inline const std::string& CdcFrame::_internal_payload() const {
  return payload_.Get();
}
inline void CdcFrame::_internal_set_payload(const std::string& value) {
  
  payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void CdcFrame::set_payload(std::string&& value) {
  
  payload_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:keyboard.cdc.CdcFrame.payload)
}
inline void CdcFrame::set_payload(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:keyboard.cdc.CdcFrame.payload)
}
inline void CdcFrame::set_payload(const void* value,
    size_t size) {
  
  payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:keyboard.cdc.CdcFrame.payload)
}
inline std::string* CdcFrame::_internal_mutable_payload() {
  
  return payload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* CdcFrame::release_payload() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcFrame.payload)
  return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void CdcFrame::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    
  } else {
    
  }
  payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcFrame.payload)
}

// uint32 checksum = 6;
inline void CdcFrame::clear_checksum() {
  checksum_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::_internal_checksum() const {
  return checksum_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 CdcFrame::checksum() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcFrame.checksum)
  return _internal_checksum();
}
inline void CdcFrame::_internal_set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  checksum_ = value;
}
inline void CdcFrame::set_checksum(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_checksum(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.CdcFrame.checksum)
}

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

// CdcPacketBody

// .keyboard.cdc.HelloReq hello_req = 1;
inline bool CdcPacketBody::_internal_has_hello_req() const {
  return body_case() == kHelloReq;
}
inline bool CdcPacketBody::has_hello_req() const {
  return _internal_has_hello_req();
}
inline void CdcPacketBody::set_has_hello_req() {
  _oneof_case_[0] = kHelloReq;
}
inline void CdcPacketBody::clear_hello_req() {
  if (_internal_has_hello_req()) {
    if (GetArena() == nullptr) {
      delete body_.hello_req_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::release_hello_req() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.hello_req)
  if (_internal_has_hello_req()) {
    clear_has_body();
      ::keyboard::cdc::HelloReq* temp = body_.hello_req_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.hello_req_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::HelloReq& CdcPacketBody::_internal_hello_req() const {
  return _internal_has_hello_req()
      ? *body_.hello_req_
      : *reinterpret_cast< ::keyboard::cdc::HelloReq*>(&::keyboard::cdc::_HelloReq_default_instance_);
}
inline const ::keyboard::cdc::HelloReq& CdcPacketBody::hello_req() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.hello_req)
  return _internal_hello_req();
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::unsafe_arena_release_hello_req() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.hello_req)
  if (_internal_has_hello_req()) {
    clear_has_body();
    ::keyboard::cdc::HelloReq* temp = body_.hello_req_;
    body_.hello_req_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_hello_req(::keyboard::cdc::HelloReq* hello_req) {
  clear_body();
  if (hello_req) {
    set_has_hello_req();
    body_.hello_req_ = hello_req;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.hello_req)
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::_internal_mutable_hello_req() {
  if (!_internal_has_hello_req()) {
    clear_body();
    set_has_hello_req();
    body_.hello_req_ = CreateMaybeMessage< ::keyboard::cdc::HelloReq >(GetArena());
  }
  return body_.hello_req_;
}
inline ::keyboard::cdc::HelloReq* CdcPacketBody::mutable_hello_req() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.hello_req)
  return _internal_mutable_hello_req();
}

// .keyboard.cdc.HelloRsp hello_rsp = 2;
inline bool CdcPacketBody::_internal_has_hello_rsp() const {
  return body_case() == kHelloRsp;
}
inline bool CdcPacketBody::has_hello_rsp() const {
  return _internal_has_hello_rsp();
}
inline void CdcPacketBody::set_has_hello_rsp() {
  _oneof_case_[0] = kHelloRsp;
}
inline void CdcPacketBody::clear_hello_rsp() {
  if (_internal_has_hello_rsp()) {
    if (GetArena() == nullptr) {
      delete body_.hello_rsp_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::release_hello_rsp() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.hello_rsp)
  if (_internal_has_hello_rsp()) {
    clear_has_body();
      ::keyboard::cdc::HelloRsp* temp = body_.hello_rsp_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.hello_rsp_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::HelloRsp& CdcPacketBody::_internal_hello_rsp() const {
  return _internal_has_hello_rsp()
      ? *body_.hello_rsp_
      : *reinterpret_cast< ::keyboard::cdc::HelloRsp*>(&::keyboard::cdc::_HelloRsp_default_instance_);
}
inline const ::keyboard::cdc::HelloRsp& CdcPacketBody::hello_rsp() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.hello_rsp)
  return _internal_hello_rsp();
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::unsafe_arena_release_hello_rsp() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.hello_rsp)
  if (_internal_has_hello_rsp()) {
    clear_has_body();
    ::keyboard::cdc::HelloRsp* temp = body_.hello_rsp_;
    body_.hello_rsp_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_hello_rsp(::keyboard::cdc::HelloRsp* hello_rsp) {
  clear_body();
  if (hello_rsp) {
    set_has_hello_rsp();
    body_.hello_rsp_ = hello_rsp;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.hello_rsp)
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::_internal_mutable_hello_rsp() {
  if (!_internal_has_hello_rsp()) {
    clear_body();
    set_has_hello_rsp();
    body_.hello_rsp_ = CreateMaybeMessage< ::keyboard::cdc::HelloRsp >(GetArena());
  }
  return body_.hello_rsp_;
}
inline ::keyboard::cdc::HelloRsp* CdcPacketBody::mutable_hello_rsp() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.hello_rsp)
  return _internal_mutable_hello_rsp();
}

// .keyboard.cdc.Bitmap bitmap = 3;
inline bool CdcPacketBody::_internal_has_bitmap() const {
  return body_case() == kBitmap;
}
inline bool CdcPacketBody::has_bitmap() const {
  return _internal_has_bitmap();
}
inline void CdcPacketBody::set_has_bitmap() {
  _oneof_case_[0] = kBitmap;
}
inline void CdcPacketBody::clear_bitmap() {
  if (_internal_has_bitmap()) {
    if (GetArena() == nullptr) {
      delete body_.bitmap_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::release_bitmap() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.bitmap)
  if (_internal_has_bitmap()) {
    clear_has_body();
      ::keyboard::cdc::Bitmap* temp = body_.bitmap_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.bitmap_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::Bitmap& CdcPacketBody::_internal_bitmap() const {
  return _internal_has_bitmap()
      ? *body_.bitmap_
      : *reinterpret_cast< ::keyboard::cdc::Bitmap*>(&::keyboard::cdc::_Bitmap_default_instance_);
}
inline const ::keyboard::cdc::Bitmap& CdcPacketBody::bitmap() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.bitmap)
  return _internal_bitmap();
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::unsafe_arena_release_bitmap() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.bitmap)
  if (_internal_has_bitmap()) {
    clear_has_body();
    ::keyboard::cdc::Bitmap* temp = body_.bitmap_;
    body_.bitmap_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_bitmap(::keyboard::cdc::Bitmap* bitmap) {
  clear_body();
  if (bitmap) {
    set_has_bitmap();
    body_.bitmap_ = bitmap;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.bitmap)
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::_internal_mutable_bitmap() {
  if (!_internal_has_bitmap()) {
    clear_body();
    set_has_bitmap();
    body_.bitmap_ = CreateMaybeMessage< ::keyboard::cdc::Bitmap >(GetArena());
  }
  return body_.bitmap_;
}
inline ::keyboard::cdc::Bitmap* CdcPacketBody::mutable_bitmap() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.bitmap)
  return _internal_mutable_bitmap();
}

// .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
inline bool CdcPacketBody::_internal_has_function_key_event() const {
  return body_case() == kFunctionKeyEvent;
}
inline bool CdcPacketBody::has_function_key_event() const {
  return _internal_has_function_key_event();
}
inline void CdcPacketBody::set_has_function_key_event() {
  _oneof_case_[0] = kFunctionKeyEvent;
}
inline void CdcPacketBody::clear_function_key_event() {
  if (_internal_has_function_key_event()) {
    if (GetArena() == nullptr) {
      delete body_.function_key_event_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::release_function_key_event() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.function_key_event)
  if (_internal_has_function_key_event()) {
    clear_has_body();
      ::keyboard::cdc::FunctionKeyEvent* temp = body_.function_key_event_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.function_key_event_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::FunctionKeyEvent& CdcPacketBody::_internal_function_key_event() const {
  return _internal_has_function_key_event()
      ? *body_.function_key_event_
      : *reinterpret_cast< ::keyboard::cdc::FunctionKeyEvent*>(&::keyboard::cdc::_FunctionKeyEvent_default_instance_);
}
inline const ::keyboard::cdc::FunctionKeyEvent& CdcPacketBody::function_key_event() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.function_key_event)
  return _internal_function_key_event();
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::unsafe_arena_release_function_key_event() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.function_key_event)
  if (_internal_has_function_key_event()) {
    clear_has_body();
    ::keyboard::cdc::FunctionKeyEvent* temp = body_.function_key_event_;
    body_.function_key_event_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_function_key_event(::keyboard::cdc::FunctionKeyEvent* function_key_event) {
  clear_body();
  if (function_key_event) {
    set_has_function_key_event();
    body_.function_key_event_ = function_key_event;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.function_key_event)
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::_internal_mutable_function_key_event() {
  if (!_internal_has_function_key_event()) {
    clear_body();
    set_has_function_key_event();
    body_.function_key_event_ = CreateMaybeMessage< ::keyboard::cdc::FunctionKeyEvent >(GetArena());
  }
  return body_.function_key_event_;
}
inline ::keyboard::cdc::FunctionKeyEvent* CdcPacketBody::mutable_function_key_event() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.function_key_event)
  return _internal_mutable_function_key_event();
}

// .keyboard.cdc.LedState led_state = 5;
inline bool CdcPacketBody::_internal_has_led_state() const {
  return body_case() == kLedState;
}
inline bool CdcPacketBody::has_led_state() const {
  return _internal_has_led_state();
}
inline void CdcPacketBody::set_has_led_state() {
  _oneof_case_[0] = kLedState;
}
inline void CdcPacketBody::clear_led_state() {
  if (_internal_has_led_state()) {
    if (GetArena() == nullptr) {
      delete body_.led_state_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::LedState* CdcPacketBody::release_led_state() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.led_state)
  if (_internal_has_led_state()) {
    clear_has_body();
      ::keyboard::cdc::LedState* temp = body_.led_state_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.led_state_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::LedState& CdcPacketBody::_internal_led_state() const {
  return _internal_has_led_state()
      ? *body_.led_state_
      : *reinterpret_cast< ::keyboard::cdc::LedState*>(&::keyboard::cdc::_LedState_default_instance_);
}
inline const ::keyboard::cdc::LedState& CdcPacketBody::led_state() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.led_state)
  return _internal_led_state();
}
inline ::keyboard::cdc::LedState* CdcPacketBody::unsafe_arena_release_led_state() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.led_state)
  if (_internal_has_led_state()) {
    clear_has_body();
    ::keyboard::cdc::LedState* temp = body_.led_state_;
    body_.led_state_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_led_state(::keyboard::cdc::LedState* led_state) {
  clear_body();
  if (led_state) {
    set_has_led_state();
    body_.led_state_ = led_state;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.led_state)
}
inline ::keyboard::cdc::LedState* CdcPacketBody::_internal_mutable_led_state() {
  if (!_internal_has_led_state()) {
    clear_body();
    set_has_led_state();
    body_.led_state_ = CreateMaybeMessage< ::keyboard::cdc::LedState >(GetArena());
  }
  return body_.led_state_;
}
inline ::keyboard::cdc::LedState* CdcPacketBody::mutable_led_state() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.led_state)
  return _internal_mutable_led_state();
}

// .keyboard.cdc.TimeSync time_sync = 6;
inline bool CdcPacketBody::_internal_has_time_sync() const {
  return body_case() == kTimeSync;
}
inline bool CdcPacketBody::has_time_sync() const {
  return _internal_has_time_sync();
}
inline void CdcPacketBody::set_has_time_sync() {
  _oneof_case_[0] = kTimeSync;
}
inline void CdcPacketBody::clear_time_sync() {
  if (_internal_has_time_sync()) {
    if (GetArena() == nullptr) {
      delete body_.time_sync_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::release_time_sync() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.time_sync)
  if (_internal_has_time_sync()) {
    clear_has_body();
      ::keyboard::cdc::TimeSync* temp = body_.time_sync_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.time_sync_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::TimeSync& CdcPacketBody::_internal_time_sync() const {
  return _internal_has_time_sync()
      ? *body_.time_sync_
      : *reinterpret_cast< ::keyboard::cdc::TimeSync*>(&::keyboard::cdc::_TimeSync_default_instance_);
}
inline const ::keyboard::cdc::TimeSync& CdcPacketBody::time_sync() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.time_sync)
  return _internal_time_sync();
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::unsafe_arena_release_time_sync() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.time_sync)
  if (_internal_has_time_sync()) {
    clear_has_body();
    ::keyboard::cdc::TimeSync* temp = body_.time_sync_;
    body_.time_sync_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_time_sync(::keyboard::cdc::TimeSync* time_sync) {
  clear_body();
  if (time_sync) {
    set_has_time_sync();
    body_.time_sync_ = time_sync;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.time_sync)
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::_internal_mutable_time_sync() {
  if (!_internal_has_time_sync()) {
    clear_body();
    set_has_time_sync();
    body_.time_sync_ = CreateMaybeMessage< ::keyboard::cdc::TimeSync >(GetArena());
  }
  return body_.time_sync_;
}
inline ::keyboard::cdc::TimeSync* CdcPacketBody::mutable_time_sync() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.time_sync)
  return _internal_mutable_time_sync();
}

// .keyboard.cdc.ThemeRgb theme_rgb = 7;
inline bool CdcPacketBody::_internal_has_theme_rgb() const {
  return body_case() == kThemeRgb;
}
inline bool CdcPacketBody::has_theme_rgb() const {
  return _internal_has_theme_rgb();
}
inline void CdcPacketBody::set_has_theme_rgb() {
  _oneof_case_[0] = kThemeRgb;
}
inline void CdcPacketBody::clear_theme_rgb() {
  if (_internal_has_theme_rgb()) {
    if (GetArena() == nullptr) {
      delete body_.theme_rgb_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::release_theme_rgb() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.theme_rgb)
  if (_internal_has_theme_rgb()) {
    clear_has_body();
      ::keyboard::cdc::ThemeRgb* temp = body_.theme_rgb_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.theme_rgb_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::ThemeRgb& CdcPacketBody::_internal_theme_rgb() const {
  return _internal_has_theme_rgb()
      ? *body_.theme_rgb_
      : *reinterpret_cast< ::keyboard::cdc::ThemeRgb*>(&::keyboard::cdc::_ThemeRgb_default_instance_);
}
inline const ::keyboard::cdc::ThemeRgb& CdcPacketBody::theme_rgb() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.theme_rgb)
  return _internal_theme_rgb();
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::unsafe_arena_release_theme_rgb() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.theme_rgb)
  if (_internal_has_theme_rgb()) {
    clear_has_body();
    ::keyboard::cdc::ThemeRgb* temp = body_.theme_rgb_;
    body_.theme_rgb_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_theme_rgb(::keyboard::cdc::ThemeRgb* theme_rgb) {
  clear_body();
  if (theme_rgb) {
    set_has_theme_rgb();
    body_.theme_rgb_ = theme_rgb;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.theme_rgb)
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::_internal_mutable_theme_rgb() {
  if (!_internal_has_theme_rgb()) {
    clear_body();
    set_has_theme_rgb();
    body_.theme_rgb_ = CreateMaybeMessage< ::keyboard::cdc::ThemeRgb >(GetArena());
  }
  return body_.theme_rgb_;
}
inline ::keyboard::cdc::ThemeRgb* CdcPacketBody::mutable_theme_rgb() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.theme_rgb)
  return _internal_mutable_theme_rgb();
}

// .keyboard.cdc.Ack ack = 8;
inline bool CdcPacketBody::_internal_has_ack() const {
  return body_case() == kAck;
}
inline bool CdcPacketBody::has_ack() const {
  return _internal_has_ack();
}
inline void CdcPacketBody::set_has_ack() {
  _oneof_case_[0] = kAck;
}
inline void CdcPacketBody::clear_ack() {
  if (_internal_has_ack()) {
    if (GetArena() == nullptr) {
      delete body_.ack_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::Ack* CdcPacketBody::release_ack() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.ack)
  if (_internal_has_ack()) {
    clear_has_body();
      ::keyboard::cdc::Ack* temp = body_.ack_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.ack_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::Ack& CdcPacketBody::_internal_ack() const {
  return _internal_has_ack()
      ? *body_.ack_
      : *reinterpret_cast< ::keyboard::cdc::Ack*>(&::keyboard::cdc::_Ack_default_instance_);
}
inline const ::keyboard::cdc::Ack& CdcPacketBody::ack() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.ack)
  return _internal_ack();
}
inline ::keyboard::cdc::Ack* CdcPacketBody::unsafe_arena_release_ack() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.ack)
  if (_internal_has_ack()) {
    clear_has_body();
    ::keyboard::cdc::Ack* temp = body_.ack_;
    body_.ack_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_ack(::keyboard::cdc::Ack* ack) {
  clear_body();
  if (ack) {
    set_has_ack();
    body_.ack_ = ack;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.ack)
}
inline ::keyboard::cdc::Ack* CdcPacketBody::_internal_mutable_ack() {
  if (!_internal_has_ack()) {
    clear_body();
    set_has_ack();
    body_.ack_ = CreateMaybeMessage< ::keyboard::cdc::Ack >(GetArena());
  }
  return body_.ack_;
}
inline ::keyboard::cdc::Ack* CdcPacketBody::mutable_ack() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.ack)
  return _internal_mutable_ack();
}

// .keyboard.cdc.Error error = 9;
inline bool CdcPacketBody::_internal_has_error() const {
  return body_case() == kError;
}
inline bool CdcPacketBody::has_error() const {
  return _internal_has_error();
}
inline void CdcPacketBody::set_has_error() {
  _oneof_case_[0] = kError;
}
inline void CdcPacketBody::clear_error() {
  if (_internal_has_error()) {
    if (GetArena() == nullptr) {
      delete body_.error_;
    }
    clear_has_body();
  }
}
inline ::keyboard::cdc::Error* CdcPacketBody::release_error() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.CdcPacketBody.error)
  if (_internal_has_error()) {
    clear_has_body();
      ::keyboard::cdc::Error* temp = body_.error_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    body_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyboard::cdc::Error& CdcPacketBody::_internal_error() const {
  return _internal_has_error()
      ? *body_.error_
      : *reinterpret_cast< ::keyboard::cdc::Error*>(&::keyboard::cdc::_Error_default_instance_);
}
inline const ::keyboard::cdc::Error& CdcPacketBody::error() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.CdcPacketBody.error)
  return _internal_error();
}
inline ::keyboard::cdc::Error* CdcPacketBody::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyboard.cdc.CdcPacketBody.error)
  if (_internal_has_error()) {
    clear_has_body();
    ::keyboard::cdc::Error* temp = body_.error_;
    body_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void CdcPacketBody::unsafe_arena_set_allocated_error(::keyboard::cdc::Error* error) {
  clear_body();
  if (error) {
    set_has_error();
    body_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyboard.cdc.CdcPacketBody.error)
}
inline ::keyboard::cdc::Error* CdcPacketBody::_internal_mutable_error() {
  if (!_internal_has_error()) {
    clear_body();
    set_has_error();
    body_.error_ = CreateMaybeMessage< ::keyboard::cdc::Error >(GetArena());
  }
  return body_.error_;
}
inline ::keyboard::cdc::Error* CdcPacketBody::mutable_error() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.CdcPacketBody.error)
  return _internal_mutable_error();
}

inline bool CdcPacketBody::has_body() const {
  return body_case() != BODY_NOT_SET;
}
inline void CdcPacketBody::clear_has_body() {
  _oneof_case_[0] = BODY_NOT_SET;
}
inline CdcPacketBody::BodyCase CdcPacketBody::body_case() const {
  return CdcPacketBody::BodyCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// HelloReq

// uint32 protocol_version = 1;
inline void HelloReq::clear_protocol_version() {
  protocol_version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloReq::_internal_protocol_version() const {
  return protocol_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloReq::protocol_version() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloReq.protocol_version)
  return _internal_protocol_version();
}
inline void HelloReq::_internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  protocol_version_ = value;
}
inline void HelloReq::set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_protocol_version(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloReq.protocol_version)
}

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

// HelloRsp

// uint32 protocol_version = 1;
inline void HelloRsp::clear_protocol_version() {
  protocol_version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_protocol_version() const {
  return protocol_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::protocol_version() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.protocol_version)
  return _internal_protocol_version();
}
inline void HelloRsp::_internal_set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  protocol_version_ = value;
}
inline void HelloRsp::set_protocol_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_protocol_version(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.protocol_version)
}

// uint32 vendor_id = 2;
inline void HelloRsp::clear_vendor_id() {
  vendor_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_vendor_id() const {
  return vendor_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::vendor_id() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.vendor_id)
  return _internal_vendor_id();
}
inline void HelloRsp::_internal_set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  vendor_id_ = value;
}
inline void HelloRsp::set_vendor_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_vendor_id(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.vendor_id)
}

// uint32 product_id = 3;
inline void HelloRsp::clear_product_id() {
  product_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_product_id() const {
  return product_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::product_id() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.product_id)
  return _internal_product_id();
}
inline void HelloRsp::_internal_set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  product_id_ = value;
}
inline void HelloRsp::set_product_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_product_id(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.product_id)
}

// uint32 firmware_major = 4;
inline void HelloRsp::clear_firmware_major() {
  firmware_major_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_firmware_major() const {
  return firmware_major_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::firmware_major() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.firmware_major)
  return _internal_firmware_major();
}
inline void HelloRsp::_internal_set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  firmware_major_ = value;
}
inline void HelloRsp::set_firmware_major(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_firmware_major(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.firmware_major)
}

// uint32 firmware_minor = 5;
inline void HelloRsp::clear_firmware_minor() {
  firmware_minor_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_firmware_minor() const {
  return firmware_minor_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::firmware_minor() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.firmware_minor)
  return _internal_firmware_minor();
}
inline void HelloRsp::_internal_set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  firmware_minor_ = value;
}
inline void HelloRsp::set_firmware_minor(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_firmware_minor(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.firmware_minor)
}

// uint32 capability_flags = 6;
inline void HelloRsp::clear_capability_flags() {
  capability_flags_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::_internal_capability_flags() const {
  return capability_flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 HelloRsp::capability_flags() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.HelloRsp.capability_flags)
  return _internal_capability_flags();
}
inline void HelloRsp::_internal_set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  capability_flags_ = value;
}
inline void HelloRsp::set_capability_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_capability_flags(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.HelloRsp.capability_flags)
}

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

// Bitmap

// bytes usage_bitmap = 1;
inline void Bitmap::clear_usage_bitmap() {
  usage_bitmap_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& Bitmap::usage_bitmap() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.Bitmap.usage_bitmap)
  return _internal_usage_bitmap();
}
inline void Bitmap::set_usage_bitmap(const std::string& value) {
  _internal_set_usage_bitmap(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.Bitmap.usage_bitmap)
}
inline std::string* Bitmap::mutable_usage_bitmap() {
  // @@protoc_insertion_point(field_mutable:keyboard.cdc.Bitmap.usage_bitmap)
  return _internal_mutable_usage_bitmap();
}
inline const std::string& Bitmap::_internal_usage_bitmap() const {
  return usage_bitmap_.Get();
}
inline void Bitmap::_internal_set_usage_bitmap(const std::string& value) {
  
  usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Bitmap::set_usage_bitmap(std::string&& value) {
  
  usage_bitmap_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:keyboard.cdc.Bitmap.usage_bitmap)
}
inline void Bitmap::set_usage_bitmap(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:keyboard.cdc.Bitmap.usage_bitmap)
}
inline void Bitmap::set_usage_bitmap(const void* value,
    size_t size) {
  
  usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:keyboard.cdc.Bitmap.usage_bitmap)
}
inline std::string* Bitmap::_internal_mutable_usage_bitmap() {
  
  return usage_bitmap_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Bitmap::release_usage_bitmap() {
  // @@protoc_insertion_point(field_release:keyboard.cdc.Bitmap.usage_bitmap)
  return usage_bitmap_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Bitmap::set_allocated_usage_bitmap(std::string* usage_bitmap) {
  if (usage_bitmap != nullptr) {
    
  } else {
    
  }
  usage_bitmap_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), usage_bitmap,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.Bitmap.usage_bitmap)
}

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

// FunctionKeyEvent

// uint32 usage = 1;
inline void FunctionKeyEvent::clear_usage() {
  usage_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FunctionKeyEvent::_internal_usage() const {
  return usage_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 FunctionKeyEvent::usage() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.FunctionKeyEvent.usage)
  return _internal_usage();
}
inline void FunctionKeyEvent::_internal_set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  usage_ = value;
}
inline void FunctionKeyEvent::set_usage(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_usage(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.FunctionKeyEvent.usage)
}

// .keyboard.cdc.KeyAction action = 2;
inline void FunctionKeyEvent::clear_action() {
  action_ = 0;
}
inline ::keyboard::cdc::KeyAction FunctionKeyEvent::_internal_action() const {
  return static_cast< ::keyboard::cdc::KeyAction >(action_);
}
inline ::keyboard::cdc::KeyAction FunctionKeyEvent::action() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.FunctionKeyEvent.action)
  return _internal_action();
}
inline void FunctionKeyEvent::_internal_set_action(::keyboard::cdc::KeyAction value) {
  
  action_ = value;
}
inline void FunctionKeyEvent::set_action(::keyboard::cdc::KeyAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.FunctionKeyEvent.action)
}

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

// LedState

// uint32 led_mask = 1;
inline void LedState::clear_led_mask() {
  led_mask_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LedState::_internal_led_mask() const {
  return led_mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 LedState::led_mask() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.LedState.led_mask)
  return _internal_led_mask();
}
inline void LedState::_internal_set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  led_mask_ = value;
}
inline void LedState::set_led_mask(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_led_mask(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.LedState.led_mask)
}

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

// TimeSync

// uint32 version = 1;
inline void TimeSync::clear_version() {
  version_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::_internal_version() const {
  return version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::version() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.version)
  return _internal_version();
}
inline void TimeSync::_internal_set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  version_ = value;
}
inline void TimeSync::set_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.version)
}

// uint32 flags = 2;
inline void TimeSync::clear_flags() {
  flags_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::_internal_flags() const {
  return flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::flags() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.flags)
  return _internal_flags();
}
inline void TimeSync::_internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  flags_ = value;
}
inline void TimeSync::set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.flags)
}

// sint32 timezone_min = 3;
inline void TimeSync::clear_timezone_min() {
  timezone_min_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TimeSync::_internal_timezone_min() const {
  return timezone_min_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TimeSync::timezone_min() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.timezone_min)
  return _internal_timezone_min();
}
inline void TimeSync::_internal_set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  timezone_min_ = value;
}
inline void TimeSync::set_timezone_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_timezone_min(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.timezone_min)
}

// fixed64 utc_ms = 4;
inline void TimeSync::clear_utc_ms() {
  utc_ms_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TimeSync::_internal_utc_ms() const {
  return utc_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TimeSync::utc_ms() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.utc_ms)
  return _internal_utc_ms();
}
inline void TimeSync::_internal_set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  utc_ms_ = value;
}
inline void TimeSync::set_utc_ms(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_utc_ms(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.utc_ms)
}

// fixed32 accuracy_ms = 5;
inline void TimeSync::clear_accuracy_ms() {
  accuracy_ms_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::_internal_accuracy_ms() const {
  return accuracy_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TimeSync::accuracy_ms() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.TimeSync.accuracy_ms)
  return _internal_accuracy_ms();
}
inline void TimeSync::_internal_set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  accuracy_ms_ = value;
}
inline void TimeSync::set_accuracy_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_accuracy_ms(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.TimeSync.accuracy_ms)
}

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

// ThemeRgb

// uint32 red = 1;
inline void ThemeRgb::clear_red() {
  red_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::_internal_red() const {
  return red_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::red() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.ThemeRgb.red)
  return _internal_red();
}
inline void ThemeRgb::_internal_set_red(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  red_ = value;
}
inline void ThemeRgb::set_red(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_red(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.ThemeRgb.red)
}

// uint32 green = 2;
inline void ThemeRgb::clear_green() {
  green_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::_internal_green() const {
  return green_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::green() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.ThemeRgb.green)
  return _internal_green();
}
inline void ThemeRgb::_internal_set_green(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  green_ = value;
}
inline void ThemeRgb::set_green(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_green(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.ThemeRgb.green)
}

// uint32 blue = 3;
inline void ThemeRgb::clear_blue() {
  blue_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::_internal_blue() const {
  return blue_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ThemeRgb::blue() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.ThemeRgb.blue)
  return _internal_blue();
}
inline void ThemeRgb::_internal_set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  blue_ = value;
}
inline void ThemeRgb::set_blue(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_blue(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.ThemeRgb.blue)
}

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

// Ack

// uint32 acked_type = 1;
inline void Ack::clear_acked_type() {
  acked_type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Ack::_internal_acked_type() const {
  return acked_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Ack::acked_type() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.Ack.acked_type)
  return _internal_acked_type();
}
inline void Ack::_internal_set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  acked_type_ = value;
}
inline void Ack::set_acked_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_acked_type(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.Ack.acked_type)
}

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

// Error

// uint32 error_type = 1;
inline void Error::clear_error_type() {
  error_type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Error::_internal_error_type() const {
  return error_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Error::error_type() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.Error.error_type)
  return _internal_error_type();
}
inline void Error::_internal_set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  error_type_ = value;
}
inline void Error::set_error_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_error_type(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.Error.error_type)
}

// .keyboard.cdc.ErrorCode error_code = 2;
inline void Error::clear_error_code() {
  error_code_ = 0;
}
inline ::keyboard::cdc::ErrorCode Error::_internal_error_code() const {
  return static_cast< ::keyboard::cdc::ErrorCode >(error_code_);
}
inline ::keyboard::cdc::ErrorCode Error::error_code() const {
  // @@protoc_insertion_point(field_get:keyboard.cdc.Error.error_code)
  return _internal_error_code();
}
inline void Error::_internal_set_error_code(::keyboard::cdc::ErrorCode value) {
  
  error_code_ = value;
}
inline void Error::set_error_code(::keyboard::cdc::ErrorCode value) {
  _internal_set_error_code(value);
  // @@protoc_insertion_point(field_set:keyboard.cdc.Error.error_code)
}

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace cdc
}  // namespace keyboard

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::keyboard::cdc::CdcPacketType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::keyboard::cdc::CdcPacketType>() {
  return ::keyboard::cdc::CdcPacketType_descriptor();
}
template <> struct is_proto_enum< ::keyboard::cdc::KeyAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::keyboard::cdc::KeyAction>() {
  return ::keyboard::cdc::KeyAction_descriptor();
}
template <> struct is_proto_enum< ::keyboard::cdc::ErrorCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::keyboard::cdc::ErrorCode>() {
  return ::keyboard::cdc::ErrorCode_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_keyboard_2eproto