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

#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fukey_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fukey_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#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 3019004 < 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/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fukey_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fukey_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[6]
    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 uint32_t offsets[];
};
namespace securegcm {
class Ukey2Alert;
struct Ukey2AlertDefaultTypeInternal;
extern Ukey2AlertDefaultTypeInternal _Ukey2Alert_default_instance_;
class Ukey2ClientFinished;
struct Ukey2ClientFinishedDefaultTypeInternal;
extern Ukey2ClientFinishedDefaultTypeInternal _Ukey2ClientFinished_default_instance_;
class Ukey2ClientInit;
struct Ukey2ClientInitDefaultTypeInternal;
extern Ukey2ClientInitDefaultTypeInternal _Ukey2ClientInit_default_instance_;
class Ukey2ClientInit_CipherCommitment;
struct Ukey2ClientInit_CipherCommitmentDefaultTypeInternal;
extern Ukey2ClientInit_CipherCommitmentDefaultTypeInternal _Ukey2ClientInit_CipherCommitment_default_instance_;
class Ukey2Message;
struct Ukey2MessageDefaultTypeInternal;
extern Ukey2MessageDefaultTypeInternal _Ukey2Message_default_instance_;
class Ukey2ServerInit;
struct Ukey2ServerInitDefaultTypeInternal;
extern Ukey2ServerInitDefaultTypeInternal _Ukey2ServerInit_default_instance_;
}  // namespace securegcm
PROTOBUF_NAMESPACE_OPEN
template<> ::securegcm::Ukey2Alert* Arena::CreateMaybeMessage<::securegcm::Ukey2Alert>(Arena*);
template<> ::securegcm::Ukey2ClientFinished* Arena::CreateMaybeMessage<::securegcm::Ukey2ClientFinished>(Arena*);
template<> ::securegcm::Ukey2ClientInit* Arena::CreateMaybeMessage<::securegcm::Ukey2ClientInit>(Arena*);
template<> ::securegcm::Ukey2ClientInit_CipherCommitment* Arena::CreateMaybeMessage<::securegcm::Ukey2ClientInit_CipherCommitment>(Arena*);
template<> ::securegcm::Ukey2Message* Arena::CreateMaybeMessage<::securegcm::Ukey2Message>(Arena*);
template<> ::securegcm::Ukey2ServerInit* Arena::CreateMaybeMessage<::securegcm::Ukey2ServerInit>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace securegcm {

enum Ukey2Message_Type : int {
  Ukey2Message_Type_UNKNOWN_DO_NOT_USE = 0,
  Ukey2Message_Type_ALERT = 1,
  Ukey2Message_Type_CLIENT_INIT = 2,
  Ukey2Message_Type_SERVER_INIT = 3,
  Ukey2Message_Type_CLIENT_FINISH = 4
};
bool Ukey2Message_Type_IsValid(int value);
constexpr Ukey2Message_Type Ukey2Message_Type_Type_MIN = Ukey2Message_Type_UNKNOWN_DO_NOT_USE;
constexpr Ukey2Message_Type Ukey2Message_Type_Type_MAX = Ukey2Message_Type_CLIENT_FINISH;
constexpr int Ukey2Message_Type_Type_ARRAYSIZE = Ukey2Message_Type_Type_MAX + 1;

const std::string& Ukey2Message_Type_Name(Ukey2Message_Type value);
template<typename T>
inline const std::string& Ukey2Message_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Ukey2Message_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Ukey2Message_Type_Name.");
  return Ukey2Message_Type_Name(static_cast<Ukey2Message_Type>(enum_t_value));
}
bool Ukey2Message_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ukey2Message_Type* value);
enum Ukey2Alert_AlertType : int {
  Ukey2Alert_AlertType_BAD_MESSAGE = 1,
  Ukey2Alert_AlertType_BAD_MESSAGE_TYPE = 2,
  Ukey2Alert_AlertType_INCORRECT_MESSAGE = 3,
  Ukey2Alert_AlertType_BAD_MESSAGE_DATA = 4,
  Ukey2Alert_AlertType_BAD_VERSION = 100,
  Ukey2Alert_AlertType_BAD_RANDOM = 101,
  Ukey2Alert_AlertType_BAD_HANDSHAKE_CIPHER = 102,
  Ukey2Alert_AlertType_BAD_NEXT_PROTOCOL = 103,
  Ukey2Alert_AlertType_BAD_PUBLIC_KEY = 104,
  Ukey2Alert_AlertType_INTERNAL_ERROR = 200
};
bool Ukey2Alert_AlertType_IsValid(int value);
constexpr Ukey2Alert_AlertType Ukey2Alert_AlertType_AlertType_MIN = Ukey2Alert_AlertType_BAD_MESSAGE;
constexpr Ukey2Alert_AlertType Ukey2Alert_AlertType_AlertType_MAX = Ukey2Alert_AlertType_INTERNAL_ERROR;
constexpr int Ukey2Alert_AlertType_AlertType_ARRAYSIZE = Ukey2Alert_AlertType_AlertType_MAX + 1;

const std::string& Ukey2Alert_AlertType_Name(Ukey2Alert_AlertType value);
template<typename T>
inline const std::string& Ukey2Alert_AlertType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Ukey2Alert_AlertType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Ukey2Alert_AlertType_Name.");
  return Ukey2Alert_AlertType_Name(static_cast<Ukey2Alert_AlertType>(enum_t_value));
}
bool Ukey2Alert_AlertType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ukey2Alert_AlertType* value);
enum Ukey2HandshakeCipher : int {
  RESERVED = 0,
  P256_SHA512 = 100,
  CURVE25519_SHA512 = 200
};
bool Ukey2HandshakeCipher_IsValid(int value);
constexpr Ukey2HandshakeCipher Ukey2HandshakeCipher_MIN = RESERVED;
constexpr Ukey2HandshakeCipher Ukey2HandshakeCipher_MAX = CURVE25519_SHA512;
constexpr int Ukey2HandshakeCipher_ARRAYSIZE = Ukey2HandshakeCipher_MAX + 1;

const std::string& Ukey2HandshakeCipher_Name(Ukey2HandshakeCipher value);
template<typename T>
inline const std::string& Ukey2HandshakeCipher_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Ukey2HandshakeCipher>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Ukey2HandshakeCipher_Name.");
  return Ukey2HandshakeCipher_Name(static_cast<Ukey2HandshakeCipher>(enum_t_value));
}
bool Ukey2HandshakeCipher_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ukey2HandshakeCipher* value);
// ===================================================================

class Ukey2Message final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2Message) */ {
 public:
  inline Ukey2Message() : Ukey2Message(nullptr) {}
  ~Ukey2Message() override;
  explicit constexpr Ukey2Message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Ukey2Message& operator=(const Ukey2Message& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ukey2Message& operator=(Ukey2Message&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Ukey2Message& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ukey2Message* internal_default_instance() {
    return reinterpret_cast<const Ukey2Message*>(
               &_Ukey2Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Ukey2Message& a, Ukey2Message& b) {
    a.Swap(&b);
  }
  inline void Swap(Ukey2Message* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ukey2Message* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ukey2Message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ukey2Message>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Ukey2Message& from);
  void MergeFrom(const Ukey2Message& 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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Ukey2Message* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Ukey2Message";
  }
  protected:
  explicit Ukey2Message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

  typedef Ukey2Message_Type Type;
  static constexpr Type UNKNOWN_DO_NOT_USE =
    Ukey2Message_Type_UNKNOWN_DO_NOT_USE;
  static constexpr Type ALERT =
    Ukey2Message_Type_ALERT;
  static constexpr Type CLIENT_INIT =
    Ukey2Message_Type_CLIENT_INIT;
  static constexpr Type SERVER_INIT =
    Ukey2Message_Type_SERVER_INIT;
  static constexpr Type CLIENT_FINISH =
    Ukey2Message_Type_CLIENT_FINISH;
  static inline bool Type_IsValid(int value) {
    return Ukey2Message_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Ukey2Message_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Ukey2Message_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Ukey2Message_Type_Type_ARRAYSIZE;
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return Ukey2Message_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Ukey2Message_Type_Parse(name, value);
  }

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

  enum : int {
    kMessageDataFieldNumber = 2,
    kMessageTypeFieldNumber = 1,
  };
  // optional bytes message_data = 2;
  bool has_message_data() const;
  private:
  bool _internal_has_message_data() const;
  public:
  void clear_message_data();
  const std::string& message_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message_data();
  PROTOBUF_NODISCARD std::string* release_message_data();
  void set_allocated_message_data(std::string* message_data);
  private:
  const std::string& _internal_message_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message_data(const std::string& value);
  std::string* _internal_mutable_message_data();
  public:

  // optional .securegcm.Ukey2Message.Type message_type = 1;
  bool has_message_type() const;
  private:
  bool _internal_has_message_type() const;
  public:
  void clear_message_type();
  ::securegcm::Ukey2Message_Type message_type() const;
  void set_message_type(::securegcm::Ukey2Message_Type value);
  private:
  ::securegcm::Ukey2Message_Type _internal_message_type() const;
  void _internal_set_message_type(::securegcm::Ukey2Message_Type value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Ukey2Message)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_data_;
  int message_type_;
  friend struct ::TableStruct_proto_2fukey_2eproto;
};
// -------------------------------------------------------------------

class Ukey2Alert final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2Alert) */ {
 public:
  inline Ukey2Alert() : Ukey2Alert(nullptr) {}
  ~Ukey2Alert() override;
  explicit constexpr Ukey2Alert(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Ukey2Alert& operator=(const Ukey2Alert& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ukey2Alert& operator=(Ukey2Alert&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Ukey2Alert& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ukey2Alert* internal_default_instance() {
    return reinterpret_cast<const Ukey2Alert*>(
               &_Ukey2Alert_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Ukey2Alert& a, Ukey2Alert& b) {
    a.Swap(&b);
  }
  inline void Swap(Ukey2Alert* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ukey2Alert* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ukey2Alert* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ukey2Alert>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Ukey2Alert& from);
  void MergeFrom(const Ukey2Alert& 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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Ukey2Alert* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Ukey2Alert";
  }
  protected:
  explicit Ukey2Alert(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

  typedef Ukey2Alert_AlertType AlertType;
  static constexpr AlertType BAD_MESSAGE =
    Ukey2Alert_AlertType_BAD_MESSAGE;
  static constexpr AlertType BAD_MESSAGE_TYPE =
    Ukey2Alert_AlertType_BAD_MESSAGE_TYPE;
  static constexpr AlertType INCORRECT_MESSAGE =
    Ukey2Alert_AlertType_INCORRECT_MESSAGE;
  static constexpr AlertType BAD_MESSAGE_DATA =
    Ukey2Alert_AlertType_BAD_MESSAGE_DATA;
  static constexpr AlertType BAD_VERSION =
    Ukey2Alert_AlertType_BAD_VERSION;
  static constexpr AlertType BAD_RANDOM =
    Ukey2Alert_AlertType_BAD_RANDOM;
  static constexpr AlertType BAD_HANDSHAKE_CIPHER =
    Ukey2Alert_AlertType_BAD_HANDSHAKE_CIPHER;
  static constexpr AlertType BAD_NEXT_PROTOCOL =
    Ukey2Alert_AlertType_BAD_NEXT_PROTOCOL;
  static constexpr AlertType BAD_PUBLIC_KEY =
    Ukey2Alert_AlertType_BAD_PUBLIC_KEY;
  static constexpr AlertType INTERNAL_ERROR =
    Ukey2Alert_AlertType_INTERNAL_ERROR;
  static inline bool AlertType_IsValid(int value) {
    return Ukey2Alert_AlertType_IsValid(value);
  }
  static constexpr AlertType AlertType_MIN =
    Ukey2Alert_AlertType_AlertType_MIN;
  static constexpr AlertType AlertType_MAX =
    Ukey2Alert_AlertType_AlertType_MAX;
  static constexpr int AlertType_ARRAYSIZE =
    Ukey2Alert_AlertType_AlertType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& AlertType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AlertType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AlertType_Name.");
    return Ukey2Alert_AlertType_Name(enum_t_value);
  }
  static inline bool AlertType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AlertType* value) {
    return Ukey2Alert_AlertType_Parse(name, value);
  }

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

  enum : int {
    kErrorMessageFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // optional string error_message = 2;
  bool has_error_message() const;
  private:
  bool _internal_has_error_message() const;
  public:
  void clear_error_message();
  const std::string& error_message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_error_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_error_message();
  PROTOBUF_NODISCARD std::string* release_error_message();
  void set_allocated_error_message(std::string* error_message);
  private:
  const std::string& _internal_error_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_message(const std::string& value);
  std::string* _internal_mutable_error_message();
  public:

  // optional .securegcm.Ukey2Alert.AlertType type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::securegcm::Ukey2Alert_AlertType type() const;
  void set_type(::securegcm::Ukey2Alert_AlertType value);
  private:
  ::securegcm::Ukey2Alert_AlertType _internal_type() const;
  void _internal_set_type(::securegcm::Ukey2Alert_AlertType value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Ukey2Alert)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
  int type_;
  friend struct ::TableStruct_proto_2fukey_2eproto;
};
// -------------------------------------------------------------------

class Ukey2ClientInit_CipherCommitment final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ClientInit.CipherCommitment) */ {
 public:
  inline Ukey2ClientInit_CipherCommitment() : Ukey2ClientInit_CipherCommitment(nullptr) {}
  ~Ukey2ClientInit_CipherCommitment() override;
  explicit constexpr Ukey2ClientInit_CipherCommitment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Ukey2ClientInit_CipherCommitment& operator=(const Ukey2ClientInit_CipherCommitment& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ukey2ClientInit_CipherCommitment& operator=(Ukey2ClientInit_CipherCommitment&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Ukey2ClientInit_CipherCommitment& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ukey2ClientInit_CipherCommitment* internal_default_instance() {
    return reinterpret_cast<const Ukey2ClientInit_CipherCommitment*>(
               &_Ukey2ClientInit_CipherCommitment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Ukey2ClientInit_CipherCommitment& a, Ukey2ClientInit_CipherCommitment& b) {
    a.Swap(&b);
  }
  inline void Swap(Ukey2ClientInit_CipherCommitment* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ukey2ClientInit_CipherCommitment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ukey2ClientInit_CipherCommitment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ukey2ClientInit_CipherCommitment>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Ukey2ClientInit_CipherCommitment& from);
  void MergeFrom(const Ukey2ClientInit_CipherCommitment& 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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Ukey2ClientInit_CipherCommitment* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Ukey2ClientInit.CipherCommitment";
  }
  protected:
  explicit Ukey2ClientInit_CipherCommitment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kCommitmentFieldNumber = 2,
    kHandshakeCipherFieldNumber = 1,
  };
  // optional bytes commitment = 2;
  bool has_commitment() const;
  private:
  bool _internal_has_commitment() const;
  public:
  void clear_commitment();
  const std::string& commitment() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_commitment(ArgT0&& arg0, ArgT... args);
  std::string* mutable_commitment();
  PROTOBUF_NODISCARD std::string* release_commitment();
  void set_allocated_commitment(std::string* commitment);
  private:
  const std::string& _internal_commitment() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_commitment(const std::string& value);
  std::string* _internal_mutable_commitment();
  public:

  // optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 1;
  bool has_handshake_cipher() const;
  private:
  bool _internal_has_handshake_cipher() const;
  public:
  void clear_handshake_cipher();
  ::securegcm::Ukey2HandshakeCipher handshake_cipher() const;
  void set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
  private:
  ::securegcm::Ukey2HandshakeCipher _internal_handshake_cipher() const;
  void _internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Ukey2ClientInit.CipherCommitment)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr commitment_;
  int handshake_cipher_;
  friend struct ::TableStruct_proto_2fukey_2eproto;
};
// -------------------------------------------------------------------

class Ukey2ClientInit final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ClientInit) */ {
 public:
  inline Ukey2ClientInit() : Ukey2ClientInit(nullptr) {}
  ~Ukey2ClientInit() override;
  explicit constexpr Ukey2ClientInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Ukey2ClientInit& operator=(const Ukey2ClientInit& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ukey2ClientInit& operator=(Ukey2ClientInit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Ukey2ClientInit& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ukey2ClientInit* internal_default_instance() {
    return reinterpret_cast<const Ukey2ClientInit*>(
               &_Ukey2ClientInit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Ukey2ClientInit& a, Ukey2ClientInit& b) {
    a.Swap(&b);
  }
  inline void Swap(Ukey2ClientInit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ukey2ClientInit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ukey2ClientInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ukey2ClientInit>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Ukey2ClientInit& from);
  void MergeFrom(const Ukey2ClientInit& 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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Ukey2ClientInit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Ukey2ClientInit";
  }
  protected:
  explicit Ukey2ClientInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

  typedef Ukey2ClientInit_CipherCommitment CipherCommitment;

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

  enum : int {
    kCipherCommitmentsFieldNumber = 3,
    kRandomFieldNumber = 2,
    kNextProtocolFieldNumber = 4,
    kVersionFieldNumber = 1,
  };
  // repeated .securegcm.Ukey2ClientInit.CipherCommitment cipher_commitments = 3;
  int cipher_commitments_size() const;
  private:
  int _internal_cipher_commitments_size() const;
  public:
  void clear_cipher_commitments();
  ::securegcm::Ukey2ClientInit_CipherCommitment* mutable_cipher_commitments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >*
      mutable_cipher_commitments();
  private:
  const ::securegcm::Ukey2ClientInit_CipherCommitment& _internal_cipher_commitments(int index) const;
  ::securegcm::Ukey2ClientInit_CipherCommitment* _internal_add_cipher_commitments();
  public:
  const ::securegcm::Ukey2ClientInit_CipherCommitment& cipher_commitments(int index) const;
  ::securegcm::Ukey2ClientInit_CipherCommitment* add_cipher_commitments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >&
      cipher_commitments() const;

  // optional bytes random = 2;
  bool has_random() const;
  private:
  bool _internal_has_random() const;
  public:
  void clear_random();
  const std::string& random() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_random(ArgT0&& arg0, ArgT... args);
  std::string* mutable_random();
  PROTOBUF_NODISCARD std::string* release_random();
  void set_allocated_random(std::string* random);
  private:
  const std::string& _internal_random() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_random(const std::string& value);
  std::string* _internal_mutable_random();
  public:

  // optional string next_protocol = 4;
  bool has_next_protocol() const;
  private:
  bool _internal_has_next_protocol() const;
  public:
  void clear_next_protocol();
  const std::string& next_protocol() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_next_protocol(ArgT0&& arg0, ArgT... args);
  std::string* mutable_next_protocol();
  PROTOBUF_NODISCARD std::string* release_next_protocol();
  void set_allocated_next_protocol(std::string* next_protocol);
  private:
  const std::string& _internal_next_protocol() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_next_protocol(const std::string& value);
  std::string* _internal_mutable_next_protocol();
  public:

  // optional int32 version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Ukey2ClientInit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment > cipher_commitments_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr random_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr next_protocol_;
  int32_t version_;
  friend struct ::TableStruct_proto_2fukey_2eproto;
};
// -------------------------------------------------------------------

class Ukey2ServerInit final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ServerInit) */ {
 public:
  inline Ukey2ServerInit() : Ukey2ServerInit(nullptr) {}
  ~Ukey2ServerInit() override;
  explicit constexpr Ukey2ServerInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Ukey2ServerInit& operator=(const Ukey2ServerInit& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ukey2ServerInit& operator=(Ukey2ServerInit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Ukey2ServerInit& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ukey2ServerInit* internal_default_instance() {
    return reinterpret_cast<const Ukey2ServerInit*>(
               &_Ukey2ServerInit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Ukey2ServerInit& a, Ukey2ServerInit& b) {
    a.Swap(&b);
  }
  inline void Swap(Ukey2ServerInit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ukey2ServerInit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ukey2ServerInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ukey2ServerInit>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Ukey2ServerInit& from);
  void MergeFrom(const Ukey2ServerInit& 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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Ukey2ServerInit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Ukey2ServerInit";
  }
  protected:
  explicit Ukey2ServerInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kRandomFieldNumber = 2,
    kPublicKeyFieldNumber = 4,
    kVersionFieldNumber = 1,
    kHandshakeCipherFieldNumber = 3,
  };
  // optional bytes random = 2;
  bool has_random() const;
  private:
  bool _internal_has_random() const;
  public:
  void clear_random();
  const std::string& random() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_random(ArgT0&& arg0, ArgT... args);
  std::string* mutable_random();
  PROTOBUF_NODISCARD std::string* release_random();
  void set_allocated_random(std::string* random);
  private:
  const std::string& _internal_random() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_random(const std::string& value);
  std::string* _internal_mutable_random();
  public:

  // optional bytes public_key = 4;
  bool has_public_key() const;
  private:
  bool _internal_has_public_key() const;
  public:
  void clear_public_key();
  const std::string& public_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_public_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_public_key();
  PROTOBUF_NODISCARD std::string* release_public_key();
  void set_allocated_public_key(std::string* public_key);
  private:
  const std::string& _internal_public_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
  std::string* _internal_mutable_public_key();
  public:

  // optional int32 version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 3;
  bool has_handshake_cipher() const;
  private:
  bool _internal_has_handshake_cipher() const;
  public:
  void clear_handshake_cipher();
  ::securegcm::Ukey2HandshakeCipher handshake_cipher() const;
  void set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
  private:
  ::securegcm::Ukey2HandshakeCipher _internal_handshake_cipher() const;
  void _internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Ukey2ServerInit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr random_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
  int32_t version_;
  int handshake_cipher_;
  friend struct ::TableStruct_proto_2fukey_2eproto;
};
// -------------------------------------------------------------------

class Ukey2ClientFinished final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Ukey2ClientFinished) */ {
 public:
  inline Ukey2ClientFinished() : Ukey2ClientFinished(nullptr) {}
  ~Ukey2ClientFinished() override;
  explicit constexpr Ukey2ClientFinished(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Ukey2ClientFinished& operator=(const Ukey2ClientFinished& from) {
    CopyFrom(from);
    return *this;
  }
  inline Ukey2ClientFinished& operator=(Ukey2ClientFinished&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Ukey2ClientFinished& default_instance() {
    return *internal_default_instance();
  }
  static inline const Ukey2ClientFinished* internal_default_instance() {
    return reinterpret_cast<const Ukey2ClientFinished*>(
               &_Ukey2ClientFinished_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Ukey2ClientFinished& a, Ukey2ClientFinished& b) {
    a.Swap(&b);
  }
  inline void Swap(Ukey2ClientFinished* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Ukey2ClientFinished* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Ukey2ClientFinished* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Ukey2ClientFinished>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Ukey2ClientFinished& from);
  void MergeFrom(const Ukey2ClientFinished& 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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Ukey2ClientFinished* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Ukey2ClientFinished";
  }
  protected:
  explicit Ukey2ClientFinished(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kPublicKeyFieldNumber = 1,
  };
  // optional bytes public_key = 1;
  bool has_public_key() const;
  private:
  bool _internal_has_public_key() const;
  public:
  void clear_public_key();
  const std::string& public_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_public_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_public_key();
  PROTOBUF_NODISCARD std::string* release_public_key();
  void set_allocated_public_key(std::string* public_key);
  private:
  const std::string& _internal_public_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
  std::string* _internal_mutable_public_key();
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Ukey2ClientFinished)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
  friend struct ::TableStruct_proto_2fukey_2eproto;
};
// ===================================================================


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

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

// optional .securegcm.Ukey2Message.Type message_type = 1;
inline bool Ukey2Message::_internal_has_message_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ukey2Message::has_message_type() const {
  return _internal_has_message_type();
}
inline void Ukey2Message::clear_message_type() {
  message_type_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::securegcm::Ukey2Message_Type Ukey2Message::_internal_message_type() const {
  return static_cast< ::securegcm::Ukey2Message_Type >(message_type_);
}
inline ::securegcm::Ukey2Message_Type Ukey2Message::message_type() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2Message.message_type)
  return _internal_message_type();
}
inline void Ukey2Message::_internal_set_message_type(::securegcm::Ukey2Message_Type value) {
  assert(::securegcm::Ukey2Message_Type_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  message_type_ = value;
}
inline void Ukey2Message::set_message_type(::securegcm::Ukey2Message_Type value) {
  _internal_set_message_type(value);
  // @@protoc_insertion_point(field_set:securegcm.Ukey2Message.message_type)
}

// optional bytes message_data = 2;
inline bool Ukey2Message::_internal_has_message_data() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ukey2Message::has_message_data() const {
  return _internal_has_message_data();
}
inline void Ukey2Message::clear_message_data() {
  message_data_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ukey2Message::message_data() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2Message.message_data)
  return _internal_message_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2Message::set_message_data(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 message_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2Message.message_data)
}
inline std::string* Ukey2Message::mutable_message_data() {
  std::string* _s = _internal_mutable_message_data();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2Message.message_data)
  return _s;
}
inline const std::string& Ukey2Message::_internal_message_data() const {
  return message_data_.Get();
}
inline void Ukey2Message::_internal_set_message_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  message_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2Message::_internal_mutable_message_data() {
  _has_bits_[0] |= 0x00000001u;
  return message_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2Message::release_message_data() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2Message.message_data)
  if (!_internal_has_message_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = message_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (message_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    message_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2Message::set_allocated_message_data(std::string* message_data) {
  if (message_data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  message_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message_data,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (message_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    message_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2Message.message_data)
}

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

// Ukey2Alert

// optional .securegcm.Ukey2Alert.AlertType type = 1;
inline bool Ukey2Alert::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ukey2Alert::has_type() const {
  return _internal_has_type();
}
inline void Ukey2Alert::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::securegcm::Ukey2Alert_AlertType Ukey2Alert::_internal_type() const {
  return static_cast< ::securegcm::Ukey2Alert_AlertType >(type_);
}
inline ::securegcm::Ukey2Alert_AlertType Ukey2Alert::type() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2Alert.type)
  return _internal_type();
}
inline void Ukey2Alert::_internal_set_type(::securegcm::Ukey2Alert_AlertType value) {
  assert(::securegcm::Ukey2Alert_AlertType_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  type_ = value;
}
inline void Ukey2Alert::set_type(::securegcm::Ukey2Alert_AlertType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:securegcm.Ukey2Alert.type)
}

// optional string error_message = 2;
inline bool Ukey2Alert::_internal_has_error_message() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ukey2Alert::has_error_message() const {
  return _internal_has_error_message();
}
inline void Ukey2Alert::clear_error_message() {
  error_message_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ukey2Alert::error_message() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2Alert.error_message)
  return _internal_error_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2Alert::set_error_message(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 error_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2Alert.error_message)
}
inline std::string* Ukey2Alert::mutable_error_message() {
  std::string* _s = _internal_mutable_error_message();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2Alert.error_message)
  return _s;
}
inline const std::string& Ukey2Alert::_internal_error_message() const {
  return error_message_.Get();
}
inline void Ukey2Alert::_internal_set_error_message(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  error_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2Alert::_internal_mutable_error_message() {
  _has_bits_[0] |= 0x00000001u;
  return error_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2Alert::release_error_message() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2Alert.error_message)
  if (!_internal_has_error_message()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = error_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (error_message_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    error_message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2Alert::set_allocated_error_message(std::string* error_message) {
  if (error_message != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  error_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), error_message,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (error_message_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    error_message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2Alert.error_message)
}

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

// Ukey2ClientInit_CipherCommitment

// optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 1;
inline bool Ukey2ClientInit_CipherCommitment::_internal_has_handshake_cipher() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ukey2ClientInit_CipherCommitment::has_handshake_cipher() const {
  return _internal_has_handshake_cipher();
}
inline void Ukey2ClientInit_CipherCommitment::clear_handshake_cipher() {
  handshake_cipher_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::securegcm::Ukey2HandshakeCipher Ukey2ClientInit_CipherCommitment::_internal_handshake_cipher() const {
  return static_cast< ::securegcm::Ukey2HandshakeCipher >(handshake_cipher_);
}
inline ::securegcm::Ukey2HandshakeCipher Ukey2ClientInit_CipherCommitment::handshake_cipher() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.CipherCommitment.handshake_cipher)
  return _internal_handshake_cipher();
}
inline void Ukey2ClientInit_CipherCommitment::_internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
  assert(::securegcm::Ukey2HandshakeCipher_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  handshake_cipher_ = value;
}
inline void Ukey2ClientInit_CipherCommitment::set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
  _internal_set_handshake_cipher(value);
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.CipherCommitment.handshake_cipher)
}

// optional bytes commitment = 2;
inline bool Ukey2ClientInit_CipherCommitment::_internal_has_commitment() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ukey2ClientInit_CipherCommitment::has_commitment() const {
  return _internal_has_commitment();
}
inline void Ukey2ClientInit_CipherCommitment::clear_commitment() {
  commitment_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ukey2ClientInit_CipherCommitment::commitment() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
  return _internal_commitment();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2ClientInit_CipherCommitment::set_commitment(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 commitment_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
}
inline std::string* Ukey2ClientInit_CipherCommitment::mutable_commitment() {
  std::string* _s = _internal_mutable_commitment();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
  return _s;
}
inline const std::string& Ukey2ClientInit_CipherCommitment::_internal_commitment() const {
  return commitment_.Get();
}
inline void Ukey2ClientInit_CipherCommitment::_internal_set_commitment(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  commitment_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2ClientInit_CipherCommitment::_internal_mutable_commitment() {
  _has_bits_[0] |= 0x00000001u;
  return commitment_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2ClientInit_CipherCommitment::release_commitment() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
  if (!_internal_has_commitment()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = commitment_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (commitment_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    commitment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2ClientInit_CipherCommitment::set_allocated_commitment(std::string* commitment) {
  if (commitment != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  commitment_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), commitment,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (commitment_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    commitment_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientInit.CipherCommitment.commitment)
}

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

// Ukey2ClientInit

// optional int32 version = 1;
inline bool Ukey2ClientInit::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Ukey2ClientInit::has_version() const {
  return _internal_has_version();
}
inline void Ukey2ClientInit::clear_version() {
  version_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline int32_t Ukey2ClientInit::_internal_version() const {
  return version_;
}
inline int32_t Ukey2ClientInit::version() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.version)
  return _internal_version();
}
inline void Ukey2ClientInit::_internal_set_version(int32_t value) {
  _has_bits_[0] |= 0x00000004u;
  version_ = value;
}
inline void Ukey2ClientInit::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.version)
}

// optional bytes random = 2;
inline bool Ukey2ClientInit::_internal_has_random() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ukey2ClientInit::has_random() const {
  return _internal_has_random();
}
inline void Ukey2ClientInit::clear_random() {
  random_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ukey2ClientInit::random() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.random)
  return _internal_random();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2ClientInit::set_random(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 random_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.random)
}
inline std::string* Ukey2ClientInit::mutable_random() {
  std::string* _s = _internal_mutable_random();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.random)
  return _s;
}
inline const std::string& Ukey2ClientInit::_internal_random() const {
  return random_.Get();
}
inline void Ukey2ClientInit::_internal_set_random(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  random_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2ClientInit::_internal_mutable_random() {
  _has_bits_[0] |= 0x00000001u;
  return random_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2ClientInit::release_random() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2ClientInit.random)
  if (!_internal_has_random()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = random_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2ClientInit::set_allocated_random(std::string* random) {
  if (random != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  random_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), random,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientInit.random)
}

// repeated .securegcm.Ukey2ClientInit.CipherCommitment cipher_commitments = 3;
inline int Ukey2ClientInit::_internal_cipher_commitments_size() const {
  return cipher_commitments_.size();
}
inline int Ukey2ClientInit::cipher_commitments_size() const {
  return _internal_cipher_commitments_size();
}
inline void Ukey2ClientInit::clear_cipher_commitments() {
  cipher_commitments_.Clear();
}
inline ::securegcm::Ukey2ClientInit_CipherCommitment* Ukey2ClientInit::mutable_cipher_commitments(int index) {
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.cipher_commitments)
  return cipher_commitments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >*
Ukey2ClientInit::mutable_cipher_commitments() {
  // @@protoc_insertion_point(field_mutable_list:securegcm.Ukey2ClientInit.cipher_commitments)
  return &cipher_commitments_;
}
inline const ::securegcm::Ukey2ClientInit_CipherCommitment& Ukey2ClientInit::_internal_cipher_commitments(int index) const {
  return cipher_commitments_.Get(index);
}
inline const ::securegcm::Ukey2ClientInit_CipherCommitment& Ukey2ClientInit::cipher_commitments(int index) const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.cipher_commitments)
  return _internal_cipher_commitments(index);
}
inline ::securegcm::Ukey2ClientInit_CipherCommitment* Ukey2ClientInit::_internal_add_cipher_commitments() {
  return cipher_commitments_.Add();
}
inline ::securegcm::Ukey2ClientInit_CipherCommitment* Ukey2ClientInit::add_cipher_commitments() {
  ::securegcm::Ukey2ClientInit_CipherCommitment* _add = _internal_add_cipher_commitments();
  // @@protoc_insertion_point(field_add:securegcm.Ukey2ClientInit.cipher_commitments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::securegcm::Ukey2ClientInit_CipherCommitment >&
Ukey2ClientInit::cipher_commitments() const {
  // @@protoc_insertion_point(field_list:securegcm.Ukey2ClientInit.cipher_commitments)
  return cipher_commitments_;
}

// optional string next_protocol = 4;
inline bool Ukey2ClientInit::_internal_has_next_protocol() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ukey2ClientInit::has_next_protocol() const {
  return _internal_has_next_protocol();
}
inline void Ukey2ClientInit::clear_next_protocol() {
  next_protocol_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Ukey2ClientInit::next_protocol() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientInit.next_protocol)
  return _internal_next_protocol();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2ClientInit::set_next_protocol(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 next_protocol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ClientInit.next_protocol)
}
inline std::string* Ukey2ClientInit::mutable_next_protocol() {
  std::string* _s = _internal_mutable_next_protocol();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientInit.next_protocol)
  return _s;
}
inline const std::string& Ukey2ClientInit::_internal_next_protocol() const {
  return next_protocol_.Get();
}
inline void Ukey2ClientInit::_internal_set_next_protocol(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  next_protocol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2ClientInit::_internal_mutable_next_protocol() {
  _has_bits_[0] |= 0x00000002u;
  return next_protocol_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2ClientInit::release_next_protocol() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2ClientInit.next_protocol)
  if (!_internal_has_next_protocol()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = next_protocol_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (next_protocol_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    next_protocol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2ClientInit::set_allocated_next_protocol(std::string* next_protocol) {
  if (next_protocol != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  next_protocol_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), next_protocol,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (next_protocol_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    next_protocol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientInit.next_protocol)
}

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

// Ukey2ServerInit

// optional int32 version = 1;
inline bool Ukey2ServerInit::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Ukey2ServerInit::has_version() const {
  return _internal_has_version();
}
inline void Ukey2ServerInit::clear_version() {
  version_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline int32_t Ukey2ServerInit::_internal_version() const {
  return version_;
}
inline int32_t Ukey2ServerInit::version() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.version)
  return _internal_version();
}
inline void Ukey2ServerInit::_internal_set_version(int32_t value) {
  _has_bits_[0] |= 0x00000004u;
  version_ = value;
}
inline void Ukey2ServerInit::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.version)
}

// optional bytes random = 2;
inline bool Ukey2ServerInit::_internal_has_random() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ukey2ServerInit::has_random() const {
  return _internal_has_random();
}
inline void Ukey2ServerInit::clear_random() {
  random_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ukey2ServerInit::random() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.random)
  return _internal_random();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2ServerInit::set_random(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 random_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.random)
}
inline std::string* Ukey2ServerInit::mutable_random() {
  std::string* _s = _internal_mutable_random();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ServerInit.random)
  return _s;
}
inline const std::string& Ukey2ServerInit::_internal_random() const {
  return random_.Get();
}
inline void Ukey2ServerInit::_internal_set_random(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  random_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2ServerInit::_internal_mutable_random() {
  _has_bits_[0] |= 0x00000001u;
  return random_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2ServerInit::release_random() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2ServerInit.random)
  if (!_internal_has_random()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = random_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2ServerInit::set_allocated_random(std::string* random) {
  if (random != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  random_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), random,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (random_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    random_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ServerInit.random)
}

// optional .securegcm.Ukey2HandshakeCipher handshake_cipher = 3;
inline bool Ukey2ServerInit::_internal_has_handshake_cipher() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Ukey2ServerInit::has_handshake_cipher() const {
  return _internal_has_handshake_cipher();
}
inline void Ukey2ServerInit::clear_handshake_cipher() {
  handshake_cipher_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::securegcm::Ukey2HandshakeCipher Ukey2ServerInit::_internal_handshake_cipher() const {
  return static_cast< ::securegcm::Ukey2HandshakeCipher >(handshake_cipher_);
}
inline ::securegcm::Ukey2HandshakeCipher Ukey2ServerInit::handshake_cipher() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.handshake_cipher)
  return _internal_handshake_cipher();
}
inline void Ukey2ServerInit::_internal_set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
  assert(::securegcm::Ukey2HandshakeCipher_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  handshake_cipher_ = value;
}
inline void Ukey2ServerInit::set_handshake_cipher(::securegcm::Ukey2HandshakeCipher value) {
  _internal_set_handshake_cipher(value);
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.handshake_cipher)
}

// optional bytes public_key = 4;
inline bool Ukey2ServerInit::_internal_has_public_key() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Ukey2ServerInit::has_public_key() const {
  return _internal_has_public_key();
}
inline void Ukey2ServerInit::clear_public_key() {
  public_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Ukey2ServerInit::public_key() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ServerInit.public_key)
  return _internal_public_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2ServerInit::set_public_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ServerInit.public_key)
}
inline std::string* Ukey2ServerInit::mutable_public_key() {
  std::string* _s = _internal_mutable_public_key();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ServerInit.public_key)
  return _s;
}
inline const std::string& Ukey2ServerInit::_internal_public_key() const {
  return public_key_.Get();
}
inline void Ukey2ServerInit::_internal_set_public_key(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2ServerInit::_internal_mutable_public_key() {
  _has_bits_[0] |= 0x00000002u;
  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2ServerInit::release_public_key() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2ServerInit.public_key)
  if (!_internal_has_public_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2ServerInit::set_allocated_public_key(std::string* public_key) {
  if (public_key != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ServerInit.public_key)
}

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

// Ukey2ClientFinished

// optional bytes public_key = 1;
inline bool Ukey2ClientFinished::_internal_has_public_key() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Ukey2ClientFinished::has_public_key() const {
  return _internal_has_public_key();
}
inline void Ukey2ClientFinished::clear_public_key() {
  public_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Ukey2ClientFinished::public_key() const {
  // @@protoc_insertion_point(field_get:securegcm.Ukey2ClientFinished.public_key)
  return _internal_public_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Ukey2ClientFinished::set_public_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.Ukey2ClientFinished.public_key)
}
inline std::string* Ukey2ClientFinished::mutable_public_key() {
  std::string* _s = _internal_mutable_public_key();
  // @@protoc_insertion_point(field_mutable:securegcm.Ukey2ClientFinished.public_key)
  return _s;
}
inline const std::string& Ukey2ClientFinished::_internal_public_key() const {
  return public_key_.Get();
}
inline void Ukey2ClientFinished::_internal_set_public_key(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Ukey2ClientFinished::_internal_mutable_public_key() {
  _has_bits_[0] |= 0x00000001u;
  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Ukey2ClientFinished::release_public_key() {
  // @@protoc_insertion_point(field_release:securegcm.Ukey2ClientFinished.public_key)
  if (!_internal_has_public_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Ukey2ClientFinished::set_allocated_public_key(std::string* public_key) {
  if (public_key != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.Ukey2ClientFinished.public_key)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace securegcm

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::securegcm::Ukey2Message_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::securegcm::Ukey2Alert_AlertType> : ::std::true_type {};
template <> struct is_proto_enum< ::securegcm::Ukey2HandshakeCipher> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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