// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: keyapis/identity/v1/keyapis_identity_authorization_v1.proto

#include "keyapis/identity/v1/keyapis_identity_authorization_v1.pb.h"

#include <algorithm>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
namespace keyapis {
namespace identity {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR UserToken::UserToken(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.access_token_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.expired_at_)*/nullptr} {}
struct UserTokenDefaultTypeInternal {
  PROTOBUF_CONSTEXPR UserTokenDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~UserTokenDefaultTypeInternal() {}
  union {
    UserToken _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserTokenDefaultTypeInternal _UserToken_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR Captcha::Captcha(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.url_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CaptchaDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CaptchaDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CaptchaDefaultTypeInternal() {}
  union {
    Captcha _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CaptchaDefaultTypeInternal _Captcha_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CaptchaAnswer_Error_WrongAnswer::CaptchaAnswer_Error_WrongAnswer(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct CaptchaAnswer_Error_WrongAnswerDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CaptchaAnswer_Error_WrongAnswerDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CaptchaAnswer_Error_WrongAnswerDefaultTypeInternal() {}
  union {
    CaptchaAnswer_Error_WrongAnswer _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CaptchaAnswer_Error_WrongAnswerDefaultTypeInternal _CaptchaAnswer_Error_WrongAnswer_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CaptchaAnswer_Error::CaptchaAnswer_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.captcha_)*/nullptr
  , /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct CaptchaAnswer_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CaptchaAnswer_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CaptchaAnswer_ErrorDefaultTypeInternal() {}
  union {
    CaptchaAnswer_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CaptchaAnswer_ErrorDefaultTypeInternal _CaptchaAnswer_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CaptchaAnswer::CaptchaAnswer(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.code_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CaptchaAnswerDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CaptchaAnswerDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CaptchaAnswerDefaultTypeInternal() {}
  union {
    CaptchaAnswer _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CaptchaAnswerDefaultTypeInternal _CaptchaAnswer_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR OtpCode_Error_LifeTimeExpired::OtpCode_Error_LifeTimeExpired(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct OtpCode_Error_LifeTimeExpiredDefaultTypeInternal {
  PROTOBUF_CONSTEXPR OtpCode_Error_LifeTimeExpiredDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~OtpCode_Error_LifeTimeExpiredDefaultTypeInternal() {}
  union {
    OtpCode_Error_LifeTimeExpired _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OtpCode_Error_LifeTimeExpiredDefaultTypeInternal _OtpCode_Error_LifeTimeExpired_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR OtpCode_Error_NoAttempts::OtpCode_Error_NoAttempts(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct OtpCode_Error_NoAttemptsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR OtpCode_Error_NoAttemptsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~OtpCode_Error_NoAttemptsDefaultTypeInternal() {}
  union {
    OtpCode_Error_NoAttempts _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OtpCode_Error_NoAttemptsDefaultTypeInternal _OtpCode_Error_NoAttempts_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR OtpCode_Error_AddressNotFound::OtpCode_Error_AddressNotFound(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct OtpCode_Error_AddressNotFoundDefaultTypeInternal {
  PROTOBUF_CONSTEXPR OtpCode_Error_AddressNotFoundDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~OtpCode_Error_AddressNotFoundDefaultTypeInternal() {}
  union {
    OtpCode_Error_AddressNotFound _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OtpCode_Error_AddressNotFoundDefaultTypeInternal _OtpCode_Error_AddressNotFound_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR OtpCode_Error_InvalidCode::OtpCode_Error_InvalidCode(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct OtpCode_Error_InvalidCodeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR OtpCode_Error_InvalidCodeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~OtpCode_Error_InvalidCodeDefaultTypeInternal() {}
  union {
    OtpCode_Error_InvalidCode _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OtpCode_Error_InvalidCodeDefaultTypeInternal _OtpCode_Error_InvalidCode_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR OtpCode_Error::OtpCode_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct OtpCode_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR OtpCode_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~OtpCode_ErrorDefaultTypeInternal() {}
  union {
    OtpCode_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OtpCode_ErrorDefaultTypeInternal _OtpCode_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR OtpCode::OtpCode(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.code_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.timeout_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct OtpCodeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR OtpCodeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~OtpCodeDefaultTypeInternal() {}
  union {
    OtpCode _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OtpCodeDefaultTypeInternal _OtpCode_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SsoError_UserIsTemporaryBlocked::SsoError_UserIsTemporaryBlocked(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SsoError_UserIsTemporaryBlockedDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SsoError_UserIsTemporaryBlockedDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SsoError_UserIsTemporaryBlockedDefaultTypeInternal() {}
  union {
    SsoError_UserIsTemporaryBlocked _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SsoError_UserIsTemporaryBlockedDefaultTypeInternal _SsoError_UserIsTemporaryBlocked_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SsoError_UserNotFound::SsoError_UserNotFound(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SsoError_UserNotFoundDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SsoError_UserNotFoundDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SsoError_UserNotFoundDefaultTypeInternal() {}
  union {
    SsoError_UserNotFound _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SsoError_UserNotFoundDefaultTypeInternal _SsoError_UserNotFound_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SsoError_WrongCredentials::SsoError_WrongCredentials(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.captcha_)*/nullptr} {}
struct SsoError_WrongCredentialsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SsoError_WrongCredentialsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SsoError_WrongCredentialsDefaultTypeInternal() {}
  union {
    SsoError_WrongCredentials _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SsoError_WrongCredentialsDefaultTypeInternal _SsoError_WrongCredentials_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SsoError_UserIsBlocked::SsoError_UserIsBlocked(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SsoError_UserIsBlockedDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SsoError_UserIsBlockedDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SsoError_UserIsBlockedDefaultTypeInternal() {}
  union {
    SsoError_UserIsBlocked _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SsoError_UserIsBlockedDefaultTypeInternal _SsoError_UserIsBlocked_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SsoError_IntervalExceeded::SsoError_IntervalExceeded(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SsoError_IntervalExceededDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SsoError_IntervalExceededDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SsoError_IntervalExceededDefaultTypeInternal() {}
  union {
    SsoError_IntervalExceeded _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SsoError_IntervalExceededDefaultTypeInternal _SsoError_IntervalExceeded_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SsoError::SsoError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SsoErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SsoErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SsoErrorDefaultTypeInternal() {}
  union {
    SsoError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SsoErrorDefaultTypeInternal _SsoError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR KeyError_UserCreation::KeyError_UserCreation(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct KeyError_UserCreationDefaultTypeInternal {
  PROTOBUF_CONSTEXPR KeyError_UserCreationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~KeyError_UserCreationDefaultTypeInternal() {}
  union {
    KeyError_UserCreation _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyError_UserCreationDefaultTypeInternal _KeyError_UserCreation_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR KeyError::KeyError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct KeyErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR KeyErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~KeyErrorDefaultTypeInternal() {}
  union {
    KeyError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KeyErrorDefaultTypeInternal _KeyError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationSendCodeRequest::PostAuthorizationSendCodeRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.captcha_answer_)*/nullptr
  , /*decltype(_impl_.otp_text_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationSendCodeRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationSendCodeRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationSendCodeRequestDefaultTypeInternal() {}
  union {
    PostAuthorizationSendCodeRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationSendCodeRequestDefaultTypeInternal _PostAuthorizationSendCodeRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationSendCodeResponse_Error::PostAuthorizationSendCodeResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationSendCodeResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationSendCodeResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationSendCodeResponse_ErrorDefaultTypeInternal() {}
  union {
    PostAuthorizationSendCodeResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationSendCodeResponse_ErrorDefaultTypeInternal _PostAuthorizationSendCodeResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationSendCodeResponse::PostAuthorizationSendCodeResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationSendCodeResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationSendCodeResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationSendCodeResponseDefaultTypeInternal() {}
  union {
    PostAuthorizationSendCodeResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationSendCodeResponseDefaultTypeInternal _PostAuthorizationSendCodeResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationLoginRequest::PostAuthorizationLoginRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.code_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.code_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct PostAuthorizationLoginRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationLoginRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationLoginRequestDefaultTypeInternal() {}
  union {
    PostAuthorizationLoginRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationLoginRequestDefaultTypeInternal _PostAuthorizationLoginRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationLoginResponse_Error::PostAuthorizationLoginResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationLoginResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationLoginResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationLoginResponse_ErrorDefaultTypeInternal() {}
  union {
    PostAuthorizationLoginResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationLoginResponse_ErrorDefaultTypeInternal _PostAuthorizationLoginResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationLoginResponse::PostAuthorizationLoginResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationLoginResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationLoginResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationLoginResponseDefaultTypeInternal() {}
  union {
    PostAuthorizationLoginResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationLoginResponseDefaultTypeInternal _PostAuthorizationLoginResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationLoginByPasswordRequest::PostAuthorizationLoginByPasswordRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.password_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.captcha_answer_)*/nullptr
  , /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationLoginByPasswordRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationLoginByPasswordRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationLoginByPasswordRequestDefaultTypeInternal() {}
  union {
    PostAuthorizationLoginByPasswordRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationLoginByPasswordRequestDefaultTypeInternal _PostAuthorizationLoginByPasswordRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationLoginByPasswordResponse_Error::PostAuthorizationLoginByPasswordResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationLoginByPasswordResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationLoginByPasswordResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationLoginByPasswordResponse_ErrorDefaultTypeInternal() {}
  union {
    PostAuthorizationLoginByPasswordResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationLoginByPasswordResponse_ErrorDefaultTypeInternal _PostAuthorizationLoginByPasswordResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostAuthorizationLoginByPasswordResponse::PostAuthorizationLoginByPasswordResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostAuthorizationLoginByPasswordResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostAuthorizationLoginByPasswordResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostAuthorizationLoginByPasswordResponseDefaultTypeInternal() {}
  union {
    PostAuthorizationLoginByPasswordResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostAuthorizationLoginByPasswordResponseDefaultTypeInternal _PostAuthorizationLoginByPasswordResponse_default_instance_;
}  // namespace v1
}  // namespace identity
}  // namespace keyapis
namespace keyapis {
namespace identity {
namespace v1 {
// ===================================================================

class UserToken::_Internal {
 public:
  using HasBits = decltype(std::declval<UserToken>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(UserToken, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& expired_at(const UserToken* msg);
  static void set_has_expired_at(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
UserToken::_Internal::expired_at(const UserToken* msg) {
  return *msg->_impl_.expired_at_;
}
void UserToken::clear_expired_at() {
  if (_impl_.expired_at_ != nullptr) _impl_.expired_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
UserToken::UserToken(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.UserToken)
}
UserToken::UserToken(const UserToken& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  UserToken* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.access_token_) {}

    , decltype(_impl_.expired_at_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.access_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.access_token_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_access_token().empty()) {
    _this->_impl_.access_token_.Set(from._internal_access_token(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.expired_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.expired_at_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.UserToken)
}

inline void UserToken::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.access_token_) {}

    , decltype(_impl_.expired_at_){nullptr}
  };
  _impl_.access_token_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.access_token_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

UserToken::~UserToken() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.UserToken)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void UserToken::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.access_token_.Destroy();
  if (this != internal_default_instance()) delete _impl_.expired_at_;
}

void UserToken::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void UserToken::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.UserToken)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.access_token_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.expired_at_ != nullptr);
    _impl_.expired_at_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* UserToken::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string access_token = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_access_token();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp expired_at = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_expired_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* UserToken::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.UserToken)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string access_token = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_access_token().empty()) {
    const std::string& _s = this->_internal_access_token();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.UserToken.access_token");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.Timestamp expired_at = 2 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::expired_at(this),
        _Internal::expired_at(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.UserToken)
  return target;
}

::size_t UserToken::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.UserToken)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string access_token = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_access_token().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_access_token());
  }

  // .google.protobuf.Timestamp expired_at = 2 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.expired_at_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void UserToken::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const UserToken*>(
      &from));
}

void UserToken::MergeFrom(const UserToken& from) {
  UserToken* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.UserToken)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_access_token().empty()) {
    _this->_internal_set_access_token(from._internal_access_token());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_expired_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
        from._internal_expired_at());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void UserToken::CopyFrom(const UserToken& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.UserToken)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserToken::IsInitialized() const {
  return true;
}

void UserToken::InternalSwap(UserToken* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.access_token_, lhs_arena,
                                       &other->_impl_.access_token_, rhs_arena);
  swap(_impl_.expired_at_, other->_impl_.expired_at_);
}

std::string UserToken::GetTypeName() const {
  return "keyapis.identity.v1.UserToken";
}

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

class Captcha::_Internal {
 public:
};

Captcha::Captcha(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.Captcha)
}
Captcha::Captcha(const Captcha& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Captcha* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) {}

    , decltype(_impl_.url_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  _impl_.url_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.url_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_url().empty()) {
    _this->_impl_.url_.Set(from._internal_url(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.Captcha)
}

inline void Captcha::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) {}

    , decltype(_impl_.url_) {}

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.url_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.url_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

Captcha::~Captcha() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.Captcha)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Captcha::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.id_.Destroy();
  _impl_.url_.Destroy();
}

void Captcha::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void Captcha::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.Captcha)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.id_.ClearToEmpty();
  _impl_.url_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* Captcha::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string url = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_url();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* Captcha::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.Captcha)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    const std::string& _s = this->_internal_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.Captcha.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // string url = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_url().empty()) {
    const std::string& _s = this->_internal_url();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.Captcha.url");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.Captcha)
  return target;
}

::size_t Captcha::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.Captcha)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_id());
  }

  // string url = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_url().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_url());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Captcha::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Captcha*>(
      &from));
}

void Captcha::MergeFrom(const Captcha& from) {
  Captcha* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.Captcha)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  if (!from._internal_url().empty()) {
    _this->_internal_set_url(from._internal_url());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void Captcha::CopyFrom(const Captcha& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.Captcha)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Captcha::IsInitialized() const {
  return true;
}

void Captcha::InternalSwap(Captcha* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.url_, lhs_arena,
                                       &other->_impl_.url_, rhs_arena);
}

std::string Captcha::GetTypeName() const {
  return "keyapis.identity.v1.Captcha";
}

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

class CaptchaAnswer_Error_WrongAnswer::_Internal {
 public:
};

CaptchaAnswer_Error_WrongAnswer::CaptchaAnswer_Error_WrongAnswer(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
}
CaptchaAnswer_Error_WrongAnswer::CaptchaAnswer_Error_WrongAnswer(const CaptchaAnswer_Error_WrongAnswer& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
}

inline void CaptchaAnswer_Error_WrongAnswer::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

CaptchaAnswer_Error_WrongAnswer::~CaptchaAnswer_Error_WrongAnswer() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CaptchaAnswer_Error_WrongAnswer::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void CaptchaAnswer_Error_WrongAnswer::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CaptchaAnswer_Error_WrongAnswer::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* CaptchaAnswer_Error_WrongAnswer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CaptchaAnswer_Error_WrongAnswer::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  return target;
}

::size_t CaptchaAnswer_Error_WrongAnswer::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CaptchaAnswer_Error_WrongAnswer::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CaptchaAnswer_Error_WrongAnswer*>(
      &from));
}

void CaptchaAnswer_Error_WrongAnswer::MergeFrom(const CaptchaAnswer_Error_WrongAnswer& from) {
  CaptchaAnswer_Error_WrongAnswer* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CaptchaAnswer_Error_WrongAnswer::CopyFrom(const CaptchaAnswer_Error_WrongAnswer& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptchaAnswer_Error_WrongAnswer::IsInitialized() const {
  return true;
}

void CaptchaAnswer_Error_WrongAnswer::InternalSwap(CaptchaAnswer_Error_WrongAnswer* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string CaptchaAnswer_Error_WrongAnswer::GetTypeName() const {
  return "keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer";
}

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

class CaptchaAnswer_Error::_Internal {
 public:
  using HasBits = decltype(std::declval<CaptchaAnswer_Error>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(CaptchaAnswer_Error, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::CaptchaAnswer_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer& wrong_answer(const CaptchaAnswer_Error* msg);
  static const ::keyapis::identity::v1::Captcha& captcha(const CaptchaAnswer_Error* msg);
  static void set_has_captcha(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer&
CaptchaAnswer_Error::_Internal::wrong_answer(const CaptchaAnswer_Error* msg) {
  return *msg->_impl_.reason_.wrong_answer_;
}
const ::keyapis::identity::v1::Captcha&
CaptchaAnswer_Error::_Internal::captcha(const CaptchaAnswer_Error* msg) {
  return *msg->_impl_.captcha_;
}
void CaptchaAnswer_Error::set_allocated_wrong_answer(::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer* wrong_answer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (wrong_answer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wrong_answer);
    if (message_arena != submessage_arena) {
      wrong_answer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wrong_answer, submessage_arena);
    }
    set_has_wrong_answer();
    _impl_.reason_.wrong_answer_ = wrong_answer;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.CaptchaAnswer.Error.wrong_answer)
}
CaptchaAnswer_Error::CaptchaAnswer_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.CaptchaAnswer.Error)
}
CaptchaAnswer_Error::CaptchaAnswer_Error(const CaptchaAnswer_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CaptchaAnswer_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.captcha_){nullptr}
    , decltype(_impl_.reason_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.captcha_ = new ::keyapis::identity::v1::Captcha(*from._impl_.captcha_);
  }
  clear_has_reason();
  switch (from.reason_case()) {
    case kWrongAnswer: {
      _this->_internal_mutable_wrong_answer()->::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer::MergeFrom(
          from._internal_wrong_answer());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.CaptchaAnswer.Error)
}

inline void CaptchaAnswer_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.captcha_){nullptr}
    , decltype(_impl_.reason_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

CaptchaAnswer_Error::~CaptchaAnswer_Error() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.CaptchaAnswer.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CaptchaAnswer_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.captcha_;
  if (has_reason()) {
    clear_reason();
  }
}

void CaptchaAnswer_Error::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CaptchaAnswer_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.CaptchaAnswer.Error)
  switch (reason_case()) {
    case kWrongAnswer: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.wrong_answer_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void CaptchaAnswer_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.CaptchaAnswer.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.captcha_ != nullptr);
    _impl_.captcha_->Clear();
  }
  clear_reason();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* CaptchaAnswer_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer wrong_answer = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_wrong_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.Captcha captcha = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CaptchaAnswer_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.CaptchaAnswer.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer wrong_answer = 1;
  if (reason_case() == kWrongAnswer) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::wrong_answer(this),
        _Internal::wrong_answer(this).GetCachedSize(), target, stream);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.identity.v1.Captcha captcha = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::captcha(this),
        _Internal::captcha(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.CaptchaAnswer.Error)
  return target;
}

::size_t CaptchaAnswer_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.CaptchaAnswer.Error)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.identity.v1.Captcha captcha = 2;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.captcha_);
  }

  switch (reason_case()) {
    // .keyapis.identity.v1.CaptchaAnswer.Error.WrongAnswer wrong_answer = 1;
    case kWrongAnswer: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.wrong_answer_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CaptchaAnswer_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CaptchaAnswer_Error*>(
      &from));
}

void CaptchaAnswer_Error::MergeFrom(const CaptchaAnswer_Error& from) {
  CaptchaAnswer_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.CaptchaAnswer.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_captcha()->::keyapis::identity::v1::Captcha::MergeFrom(
        from._internal_captcha());
  }
  switch (from.reason_case()) {
    case kWrongAnswer: {
      _this->_internal_mutable_wrong_answer()->::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer::MergeFrom(
          from._internal_wrong_answer());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CaptchaAnswer_Error::CopyFrom(const CaptchaAnswer_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.CaptchaAnswer.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptchaAnswer_Error::IsInitialized() const {
  return true;
}

void CaptchaAnswer_Error::InternalSwap(CaptchaAnswer_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.captcha_, other->_impl_.captcha_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string CaptchaAnswer_Error::GetTypeName() const {
  return "keyapis.identity.v1.CaptchaAnswer.Error";
}

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

class CaptchaAnswer::_Internal {
 public:
};

CaptchaAnswer::CaptchaAnswer(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.CaptchaAnswer)
}
CaptchaAnswer::CaptchaAnswer(const CaptchaAnswer& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CaptchaAnswer* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) {}

    , decltype(_impl_.code_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  _impl_.code_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_code().empty()) {
    _this->_impl_.code_.Set(from._internal_code(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.CaptchaAnswer)
}

inline void CaptchaAnswer::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) {}

    , decltype(_impl_.code_) {}

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.code_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CaptchaAnswer::~CaptchaAnswer() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.CaptchaAnswer)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CaptchaAnswer::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.id_.Destroy();
  _impl_.code_.Destroy();
}

void CaptchaAnswer::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CaptchaAnswer::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.CaptchaAnswer)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.id_.ClearToEmpty();
  _impl_.code_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* CaptchaAnswer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string code = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_code();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CaptchaAnswer::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.CaptchaAnswer)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    const std::string& _s = this->_internal_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.CaptchaAnswer.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // string code = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code().empty()) {
    const std::string& _s = this->_internal_code();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.CaptchaAnswer.code");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.CaptchaAnswer)
  return target;
}

::size_t CaptchaAnswer::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.CaptchaAnswer)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_id());
  }

  // string code = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_code());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CaptchaAnswer::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const CaptchaAnswer*>(
      &from));
}

void CaptchaAnswer::MergeFrom(const CaptchaAnswer& from) {
  CaptchaAnswer* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.CaptchaAnswer)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  if (!from._internal_code().empty()) {
    _this->_internal_set_code(from._internal_code());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void CaptchaAnswer::CopyFrom(const CaptchaAnswer& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.CaptchaAnswer)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptchaAnswer::IsInitialized() const {
  return true;
}

void CaptchaAnswer::InternalSwap(CaptchaAnswer* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.code_, lhs_arena,
                                       &other->_impl_.code_, rhs_arena);
}

std::string CaptchaAnswer::GetTypeName() const {
  return "keyapis.identity.v1.CaptchaAnswer";
}

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

class OtpCode_Error_LifeTimeExpired::_Internal {
 public:
};

OtpCode_Error_LifeTimeExpired::OtpCode_Error_LifeTimeExpired(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
}
OtpCode_Error_LifeTimeExpired::OtpCode_Error_LifeTimeExpired(const OtpCode_Error_LifeTimeExpired& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
}

inline void OtpCode_Error_LifeTimeExpired::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

OtpCode_Error_LifeTimeExpired::~OtpCode_Error_LifeTimeExpired() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void OtpCode_Error_LifeTimeExpired::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void OtpCode_Error_LifeTimeExpired::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void OtpCode_Error_LifeTimeExpired::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* OtpCode_Error_LifeTimeExpired::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* OtpCode_Error_LifeTimeExpired::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  return target;
}

::size_t OtpCode_Error_LifeTimeExpired::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OtpCode_Error_LifeTimeExpired::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const OtpCode_Error_LifeTimeExpired*>(
      &from));
}

void OtpCode_Error_LifeTimeExpired::MergeFrom(const OtpCode_Error_LifeTimeExpired& from) {
  OtpCode_Error_LifeTimeExpired* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void OtpCode_Error_LifeTimeExpired::CopyFrom(const OtpCode_Error_LifeTimeExpired& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.OtpCode.Error.LifeTimeExpired)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OtpCode_Error_LifeTimeExpired::IsInitialized() const {
  return true;
}

void OtpCode_Error_LifeTimeExpired::InternalSwap(OtpCode_Error_LifeTimeExpired* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string OtpCode_Error_LifeTimeExpired::GetTypeName() const {
  return "keyapis.identity.v1.OtpCode.Error.LifeTimeExpired";
}

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

class OtpCode_Error_NoAttempts::_Internal {
 public:
};

OtpCode_Error_NoAttempts::OtpCode_Error_NoAttempts(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.OtpCode.Error.NoAttempts)
}
OtpCode_Error_NoAttempts::OtpCode_Error_NoAttempts(const OtpCode_Error_NoAttempts& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.OtpCode.Error.NoAttempts)
}

inline void OtpCode_Error_NoAttempts::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

OtpCode_Error_NoAttempts::~OtpCode_Error_NoAttempts() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void OtpCode_Error_NoAttempts::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void OtpCode_Error_NoAttempts::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void OtpCode_Error_NoAttempts::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* OtpCode_Error_NoAttempts::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* OtpCode_Error_NoAttempts::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  return target;
}

::size_t OtpCode_Error_NoAttempts::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OtpCode_Error_NoAttempts::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const OtpCode_Error_NoAttempts*>(
      &from));
}

void OtpCode_Error_NoAttempts::MergeFrom(const OtpCode_Error_NoAttempts& from) {
  OtpCode_Error_NoAttempts* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void OtpCode_Error_NoAttempts::CopyFrom(const OtpCode_Error_NoAttempts& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.OtpCode.Error.NoAttempts)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OtpCode_Error_NoAttempts::IsInitialized() const {
  return true;
}

void OtpCode_Error_NoAttempts::InternalSwap(OtpCode_Error_NoAttempts* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string OtpCode_Error_NoAttempts::GetTypeName() const {
  return "keyapis.identity.v1.OtpCode.Error.NoAttempts";
}

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

class OtpCode_Error_AddressNotFound::_Internal {
 public:
};

OtpCode_Error_AddressNotFound::OtpCode_Error_AddressNotFound(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
}
OtpCode_Error_AddressNotFound::OtpCode_Error_AddressNotFound(const OtpCode_Error_AddressNotFound& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
}

inline void OtpCode_Error_AddressNotFound::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

OtpCode_Error_AddressNotFound::~OtpCode_Error_AddressNotFound() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void OtpCode_Error_AddressNotFound::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void OtpCode_Error_AddressNotFound::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void OtpCode_Error_AddressNotFound::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* OtpCode_Error_AddressNotFound::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* OtpCode_Error_AddressNotFound::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  return target;
}

::size_t OtpCode_Error_AddressNotFound::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OtpCode_Error_AddressNotFound::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const OtpCode_Error_AddressNotFound*>(
      &from));
}

void OtpCode_Error_AddressNotFound::MergeFrom(const OtpCode_Error_AddressNotFound& from) {
  OtpCode_Error_AddressNotFound* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void OtpCode_Error_AddressNotFound::CopyFrom(const OtpCode_Error_AddressNotFound& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.OtpCode.Error.AddressNotFound)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OtpCode_Error_AddressNotFound::IsInitialized() const {
  return true;
}

void OtpCode_Error_AddressNotFound::InternalSwap(OtpCode_Error_AddressNotFound* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string OtpCode_Error_AddressNotFound::GetTypeName() const {
  return "keyapis.identity.v1.OtpCode.Error.AddressNotFound";
}

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

class OtpCode_Error_InvalidCode::_Internal {
 public:
};

OtpCode_Error_InvalidCode::OtpCode_Error_InvalidCode(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.OtpCode.Error.InvalidCode)
}
OtpCode_Error_InvalidCode::OtpCode_Error_InvalidCode(const OtpCode_Error_InvalidCode& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.OtpCode.Error.InvalidCode)
}

inline void OtpCode_Error_InvalidCode::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

OtpCode_Error_InvalidCode::~OtpCode_Error_InvalidCode() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void OtpCode_Error_InvalidCode::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void OtpCode_Error_InvalidCode::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void OtpCode_Error_InvalidCode::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* OtpCode_Error_InvalidCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* OtpCode_Error_InvalidCode::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  return target;
}

::size_t OtpCode_Error_InvalidCode::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OtpCode_Error_InvalidCode::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const OtpCode_Error_InvalidCode*>(
      &from));
}

void OtpCode_Error_InvalidCode::MergeFrom(const OtpCode_Error_InvalidCode& from) {
  OtpCode_Error_InvalidCode* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void OtpCode_Error_InvalidCode::CopyFrom(const OtpCode_Error_InvalidCode& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.OtpCode.Error.InvalidCode)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OtpCode_Error_InvalidCode::IsInitialized() const {
  return true;
}

void OtpCode_Error_InvalidCode::InternalSwap(OtpCode_Error_InvalidCode* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string OtpCode_Error_InvalidCode::GetTypeName() const {
  return "keyapis.identity.v1.OtpCode.Error.InvalidCode";
}

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

class OtpCode_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::OtpCode_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired& life_time_expired(const OtpCode_Error* msg);
  static const ::keyapis::identity::v1::OtpCode_Error_NoAttempts& no_attempts(const OtpCode_Error* msg);
  static const ::keyapis::identity::v1::OtpCode_Error_AddressNotFound& address_not_found(const OtpCode_Error* msg);
  static const ::keyapis::identity::v1::OtpCode_Error_InvalidCode& invalid_code(const OtpCode_Error* msg);
};

const ::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired&
OtpCode_Error::_Internal::life_time_expired(const OtpCode_Error* msg) {
  return *msg->_impl_.reason_.life_time_expired_;
}
const ::keyapis::identity::v1::OtpCode_Error_NoAttempts&
OtpCode_Error::_Internal::no_attempts(const OtpCode_Error* msg) {
  return *msg->_impl_.reason_.no_attempts_;
}
const ::keyapis::identity::v1::OtpCode_Error_AddressNotFound&
OtpCode_Error::_Internal::address_not_found(const OtpCode_Error* msg) {
  return *msg->_impl_.reason_.address_not_found_;
}
const ::keyapis::identity::v1::OtpCode_Error_InvalidCode&
OtpCode_Error::_Internal::invalid_code(const OtpCode_Error* msg) {
  return *msg->_impl_.reason_.invalid_code_;
}
void OtpCode_Error::set_allocated_life_time_expired(::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired* life_time_expired) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (life_time_expired) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(life_time_expired);
    if (message_arena != submessage_arena) {
      life_time_expired = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, life_time_expired, submessage_arena);
    }
    set_has_life_time_expired();
    _impl_.reason_.life_time_expired_ = life_time_expired;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.OtpCode.Error.life_time_expired)
}
void OtpCode_Error::set_allocated_no_attempts(::keyapis::identity::v1::OtpCode_Error_NoAttempts* no_attempts) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (no_attempts) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(no_attempts);
    if (message_arena != submessage_arena) {
      no_attempts = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, no_attempts, submessage_arena);
    }
    set_has_no_attempts();
    _impl_.reason_.no_attempts_ = no_attempts;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.OtpCode.Error.no_attempts)
}
void OtpCode_Error::set_allocated_address_not_found(::keyapis::identity::v1::OtpCode_Error_AddressNotFound* address_not_found) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (address_not_found) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(address_not_found);
    if (message_arena != submessage_arena) {
      address_not_found = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, address_not_found, submessage_arena);
    }
    set_has_address_not_found();
    _impl_.reason_.address_not_found_ = address_not_found;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.OtpCode.Error.address_not_found)
}
void OtpCode_Error::set_allocated_invalid_code(::keyapis::identity::v1::OtpCode_Error_InvalidCode* invalid_code) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (invalid_code) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(invalid_code);
    if (message_arena != submessage_arena) {
      invalid_code = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, invalid_code, submessage_arena);
    }
    set_has_invalid_code();
    _impl_.reason_.invalid_code_ = invalid_code;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.OtpCode.Error.invalid_code)
}
OtpCode_Error::OtpCode_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.OtpCode.Error)
}
OtpCode_Error::OtpCode_Error(const OtpCode_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  OtpCode_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kLifeTimeExpired: {
      _this->_internal_mutable_life_time_expired()->::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired::MergeFrom(
          from._internal_life_time_expired());
      break;
    }
    case kNoAttempts: {
      _this->_internal_mutable_no_attempts()->::keyapis::identity::v1::OtpCode_Error_NoAttempts::MergeFrom(
          from._internal_no_attempts());
      break;
    }
    case kAddressNotFound: {
      _this->_internal_mutable_address_not_found()->::keyapis::identity::v1::OtpCode_Error_AddressNotFound::MergeFrom(
          from._internal_address_not_found());
      break;
    }
    case kInvalidCode: {
      _this->_internal_mutable_invalid_code()->::keyapis::identity::v1::OtpCode_Error_InvalidCode::MergeFrom(
          from._internal_invalid_code());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.OtpCode.Error)
}

inline void OtpCode_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

OtpCode_Error::~OtpCode_Error() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.OtpCode.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void OtpCode_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void OtpCode_Error::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void OtpCode_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.OtpCode.Error)
  switch (reason_case()) {
    case kLifeTimeExpired: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.life_time_expired_;
      }
      break;
    }
    case kNoAttempts: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.no_attempts_;
      }
      break;
    }
    case kAddressNotFound: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.address_not_found_;
      }
      break;
    }
    case kInvalidCode: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.invalid_code_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void OtpCode_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.OtpCode.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* OtpCode_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.OtpCode.Error.LifeTimeExpired life_time_expired = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_life_time_expired(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.OtpCode.Error.NoAttempts no_attempts = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_no_attempts(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.OtpCode.Error.AddressNotFound address_not_found = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_address_not_found(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.OtpCode.Error.InvalidCode invalid_code = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_invalid_code(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* OtpCode_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.OtpCode.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kLifeTimeExpired: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::life_time_expired(this),
          _Internal::life_time_expired(this).GetCachedSize(), target, stream);
      break;
    }
    case kNoAttempts: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::no_attempts(this),
          _Internal::no_attempts(this).GetCachedSize(), target, stream);
      break;
    }
    case kAddressNotFound: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, _Internal::address_not_found(this),
          _Internal::address_not_found(this).GetCachedSize(), target, stream);
      break;
    }
    case kInvalidCode: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, _Internal::invalid_code(this),
          _Internal::invalid_code(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.OtpCode.Error)
  return target;
}

::size_t OtpCode_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.OtpCode.Error)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.identity.v1.OtpCode.Error.LifeTimeExpired life_time_expired = 1;
    case kLifeTimeExpired: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.life_time_expired_);
      break;
    }
    // .keyapis.identity.v1.OtpCode.Error.NoAttempts no_attempts = 2;
    case kNoAttempts: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.no_attempts_);
      break;
    }
    // .keyapis.identity.v1.OtpCode.Error.AddressNotFound address_not_found = 3;
    case kAddressNotFound: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.address_not_found_);
      break;
    }
    // .keyapis.identity.v1.OtpCode.Error.InvalidCode invalid_code = 4;
    case kInvalidCode: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.invalid_code_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OtpCode_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const OtpCode_Error*>(
      &from));
}

void OtpCode_Error::MergeFrom(const OtpCode_Error& from) {
  OtpCode_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.OtpCode.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kLifeTimeExpired: {
      _this->_internal_mutable_life_time_expired()->::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired::MergeFrom(
          from._internal_life_time_expired());
      break;
    }
    case kNoAttempts: {
      _this->_internal_mutable_no_attempts()->::keyapis::identity::v1::OtpCode_Error_NoAttempts::MergeFrom(
          from._internal_no_attempts());
      break;
    }
    case kAddressNotFound: {
      _this->_internal_mutable_address_not_found()->::keyapis::identity::v1::OtpCode_Error_AddressNotFound::MergeFrom(
          from._internal_address_not_found());
      break;
    }
    case kInvalidCode: {
      _this->_internal_mutable_invalid_code()->::keyapis::identity::v1::OtpCode_Error_InvalidCode::MergeFrom(
          from._internal_invalid_code());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void OtpCode_Error::CopyFrom(const OtpCode_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.OtpCode.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OtpCode_Error::IsInitialized() const {
  return true;
}

void OtpCode_Error::InternalSwap(OtpCode_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string OtpCode_Error::GetTypeName() const {
  return "keyapis.identity.v1.OtpCode.Error";
}

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

class OtpCode::_Internal {
 public:
};

OtpCode::OtpCode(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.OtpCode)
}
OtpCode::OtpCode(const OtpCode& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  OtpCode* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.code_id_) {}

    , decltype(_impl_.timeout_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.code_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_code_id().empty()) {
    _this->_impl_.code_id_.Set(from._internal_code_id(), _this->GetArenaForAllocation());
  }
  _this->_impl_.timeout_ = from._impl_.timeout_;
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.OtpCode)
}

inline void OtpCode::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.code_id_) {}

    , decltype(_impl_.timeout_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.code_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

OtpCode::~OtpCode() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.OtpCode)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void OtpCode::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.code_id_.Destroy();
}

void OtpCode::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void OtpCode::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.OtpCode)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.code_id_.ClearToEmpty();
  _impl_.timeout_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* OtpCode::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string code_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_code_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 timeout = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.timeout_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* OtpCode::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.OtpCode)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string code_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code_id().empty()) {
    const std::string& _s = this->_internal_code_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.OtpCode.code_id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // int32 timeout = 2 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_timeout() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        2, this->_internal_timeout(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.OtpCode)
  return target;
}

::size_t OtpCode::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.OtpCode)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string code_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_code_id());
  }

  // int32 timeout = 2 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_timeout() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_timeout());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void OtpCode::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const OtpCode*>(
      &from));
}

void OtpCode::MergeFrom(const OtpCode& from) {
  OtpCode* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.OtpCode)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_code_id().empty()) {
    _this->_internal_set_code_id(from._internal_code_id());
  }
  if (from._internal_timeout() != 0) {
    _this->_internal_set_timeout(from._internal_timeout());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void OtpCode::CopyFrom(const OtpCode& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.OtpCode)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OtpCode::IsInitialized() const {
  return true;
}

void OtpCode::InternalSwap(OtpCode* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.code_id_, lhs_arena,
                                       &other->_impl_.code_id_, rhs_arena);

  swap(_impl_.timeout_, other->_impl_.timeout_);
}

std::string OtpCode::GetTypeName() const {
  return "keyapis.identity.v1.OtpCode";
}

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

class SsoError_UserIsTemporaryBlocked::_Internal {
 public:
};

SsoError_UserIsTemporaryBlocked::SsoError_UserIsTemporaryBlocked(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
}
SsoError_UserIsTemporaryBlocked::SsoError_UserIsTemporaryBlocked(const SsoError_UserIsTemporaryBlocked& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
}

inline void SsoError_UserIsTemporaryBlocked::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

SsoError_UserIsTemporaryBlocked::~SsoError_UserIsTemporaryBlocked() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SsoError_UserIsTemporaryBlocked::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void SsoError_UserIsTemporaryBlocked::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SsoError_UserIsTemporaryBlocked::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* SsoError_UserIsTemporaryBlocked::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SsoError_UserIsTemporaryBlocked::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  return target;
}

::size_t SsoError_UserIsTemporaryBlocked::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SsoError_UserIsTemporaryBlocked::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SsoError_UserIsTemporaryBlocked*>(
      &from));
}

void SsoError_UserIsTemporaryBlocked::MergeFrom(const SsoError_UserIsTemporaryBlocked& from) {
  SsoError_UserIsTemporaryBlocked* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SsoError_UserIsTemporaryBlocked::CopyFrom(const SsoError_UserIsTemporaryBlocked& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.SsoError.UserIsTemporaryBlocked)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SsoError_UserIsTemporaryBlocked::IsInitialized() const {
  return true;
}

void SsoError_UserIsTemporaryBlocked::InternalSwap(SsoError_UserIsTemporaryBlocked* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string SsoError_UserIsTemporaryBlocked::GetTypeName() const {
  return "keyapis.identity.v1.SsoError.UserIsTemporaryBlocked";
}

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

class SsoError_UserNotFound::_Internal {
 public:
};

SsoError_UserNotFound::SsoError_UserNotFound(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.SsoError.UserNotFound)
}
SsoError_UserNotFound::SsoError_UserNotFound(const SsoError_UserNotFound& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.SsoError.UserNotFound)
}

inline void SsoError_UserNotFound::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

SsoError_UserNotFound::~SsoError_UserNotFound() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.SsoError.UserNotFound)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SsoError_UserNotFound::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void SsoError_UserNotFound::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SsoError_UserNotFound::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.SsoError.UserNotFound)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* SsoError_UserNotFound::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SsoError_UserNotFound::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.SsoError.UserNotFound)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.SsoError.UserNotFound)
  return target;
}

::size_t SsoError_UserNotFound::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.SsoError.UserNotFound)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SsoError_UserNotFound::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SsoError_UserNotFound*>(
      &from));
}

void SsoError_UserNotFound::MergeFrom(const SsoError_UserNotFound& from) {
  SsoError_UserNotFound* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.SsoError.UserNotFound)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SsoError_UserNotFound::CopyFrom(const SsoError_UserNotFound& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.SsoError.UserNotFound)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SsoError_UserNotFound::IsInitialized() const {
  return true;
}

void SsoError_UserNotFound::InternalSwap(SsoError_UserNotFound* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string SsoError_UserNotFound::GetTypeName() const {
  return "keyapis.identity.v1.SsoError.UserNotFound";
}

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

class SsoError_WrongCredentials::_Internal {
 public:
  using HasBits = decltype(std::declval<SsoError_WrongCredentials>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(SsoError_WrongCredentials, _impl_._has_bits_);
  static const ::keyapis::identity::v1::Captcha& captcha(const SsoError_WrongCredentials* msg);
  static void set_has_captcha(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::identity::v1::Captcha&
SsoError_WrongCredentials::_Internal::captcha(const SsoError_WrongCredentials* msg) {
  return *msg->_impl_.captcha_;
}
SsoError_WrongCredentials::SsoError_WrongCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.SsoError.WrongCredentials)
}
SsoError_WrongCredentials::SsoError_WrongCredentials(const SsoError_WrongCredentials& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SsoError_WrongCredentials* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.captcha_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.captcha_ = new ::keyapis::identity::v1::Captcha(*from._impl_.captcha_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.SsoError.WrongCredentials)
}

inline void SsoError_WrongCredentials::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.captcha_){nullptr}
  };
}

SsoError_WrongCredentials::~SsoError_WrongCredentials() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.SsoError.WrongCredentials)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SsoError_WrongCredentials::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.captcha_;
}

void SsoError_WrongCredentials::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SsoError_WrongCredentials::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.SsoError.WrongCredentials)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.captcha_ != nullptr);
    _impl_.captcha_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* SsoError_WrongCredentials::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.Captcha captcha = 1 [(.google.api.field_behavior) = OPTIONAL];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SsoError_WrongCredentials::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.SsoError.WrongCredentials)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.identity.v1.Captcha captcha = 1 [(.google.api.field_behavior) = OPTIONAL];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::captcha(this),
        _Internal::captcha(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.SsoError.WrongCredentials)
  return target;
}

::size_t SsoError_WrongCredentials::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.SsoError.WrongCredentials)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.identity.v1.Captcha captcha = 1 [(.google.api.field_behavior) = OPTIONAL];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.captcha_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SsoError_WrongCredentials::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SsoError_WrongCredentials*>(
      &from));
}

void SsoError_WrongCredentials::MergeFrom(const SsoError_WrongCredentials& from) {
  SsoError_WrongCredentials* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.SsoError.WrongCredentials)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_captcha()->::keyapis::identity::v1::Captcha::MergeFrom(
        from._internal_captcha());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SsoError_WrongCredentials::CopyFrom(const SsoError_WrongCredentials& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.SsoError.WrongCredentials)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SsoError_WrongCredentials::IsInitialized() const {
  return true;
}

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

std::string SsoError_WrongCredentials::GetTypeName() const {
  return "keyapis.identity.v1.SsoError.WrongCredentials";
}

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

class SsoError_UserIsBlocked::_Internal {
 public:
};

SsoError_UserIsBlocked::SsoError_UserIsBlocked(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.SsoError.UserIsBlocked)
}
SsoError_UserIsBlocked::SsoError_UserIsBlocked(const SsoError_UserIsBlocked& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.SsoError.UserIsBlocked)
}

inline void SsoError_UserIsBlocked::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

SsoError_UserIsBlocked::~SsoError_UserIsBlocked() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.SsoError.UserIsBlocked)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SsoError_UserIsBlocked::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void SsoError_UserIsBlocked::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SsoError_UserIsBlocked::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.SsoError.UserIsBlocked)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* SsoError_UserIsBlocked::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SsoError_UserIsBlocked::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.SsoError.UserIsBlocked)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.SsoError.UserIsBlocked)
  return target;
}

::size_t SsoError_UserIsBlocked::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.SsoError.UserIsBlocked)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SsoError_UserIsBlocked::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SsoError_UserIsBlocked*>(
      &from));
}

void SsoError_UserIsBlocked::MergeFrom(const SsoError_UserIsBlocked& from) {
  SsoError_UserIsBlocked* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.SsoError.UserIsBlocked)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SsoError_UserIsBlocked::CopyFrom(const SsoError_UserIsBlocked& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.SsoError.UserIsBlocked)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SsoError_UserIsBlocked::IsInitialized() const {
  return true;
}

void SsoError_UserIsBlocked::InternalSwap(SsoError_UserIsBlocked* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string SsoError_UserIsBlocked::GetTypeName() const {
  return "keyapis.identity.v1.SsoError.UserIsBlocked";
}

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

class SsoError_IntervalExceeded::_Internal {
 public:
};

SsoError_IntervalExceeded::SsoError_IntervalExceeded(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.SsoError.IntervalExceeded)
}
SsoError_IntervalExceeded::SsoError_IntervalExceeded(const SsoError_IntervalExceeded& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.SsoError.IntervalExceeded)
}

inline void SsoError_IntervalExceeded::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

SsoError_IntervalExceeded::~SsoError_IntervalExceeded() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.SsoError.IntervalExceeded)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SsoError_IntervalExceeded::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void SsoError_IntervalExceeded::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SsoError_IntervalExceeded::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.SsoError.IntervalExceeded)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* SsoError_IntervalExceeded::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SsoError_IntervalExceeded::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.SsoError.IntervalExceeded)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.SsoError.IntervalExceeded)
  return target;
}

::size_t SsoError_IntervalExceeded::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.SsoError.IntervalExceeded)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SsoError_IntervalExceeded::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SsoError_IntervalExceeded*>(
      &from));
}

void SsoError_IntervalExceeded::MergeFrom(const SsoError_IntervalExceeded& from) {
  SsoError_IntervalExceeded* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.SsoError.IntervalExceeded)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SsoError_IntervalExceeded::CopyFrom(const SsoError_IntervalExceeded& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.SsoError.IntervalExceeded)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SsoError_IntervalExceeded::IsInitialized() const {
  return true;
}

void SsoError_IntervalExceeded::InternalSwap(SsoError_IntervalExceeded* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string SsoError_IntervalExceeded::GetTypeName() const {
  return "keyapis.identity.v1.SsoError.IntervalExceeded";
}

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

class SsoError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::SsoError, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked& user_is_temporary_blocked(const SsoError* msg);
  static const ::keyapis::identity::v1::SsoError_UserNotFound& user_not_found(const SsoError* msg);
  static const ::keyapis::identity::v1::SsoError_WrongCredentials& wrong_credentials(const SsoError* msg);
  static const ::keyapis::identity::v1::SsoError_UserIsBlocked& user_is_blocked(const SsoError* msg);
  static const ::keyapis::identity::v1::SsoError_IntervalExceeded& interval_exceeded(const SsoError* msg);
};

const ::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked&
SsoError::_Internal::user_is_temporary_blocked(const SsoError* msg) {
  return *msg->_impl_.reason_.user_is_temporary_blocked_;
}
const ::keyapis::identity::v1::SsoError_UserNotFound&
SsoError::_Internal::user_not_found(const SsoError* msg) {
  return *msg->_impl_.reason_.user_not_found_;
}
const ::keyapis::identity::v1::SsoError_WrongCredentials&
SsoError::_Internal::wrong_credentials(const SsoError* msg) {
  return *msg->_impl_.reason_.wrong_credentials_;
}
const ::keyapis::identity::v1::SsoError_UserIsBlocked&
SsoError::_Internal::user_is_blocked(const SsoError* msg) {
  return *msg->_impl_.reason_.user_is_blocked_;
}
const ::keyapis::identity::v1::SsoError_IntervalExceeded&
SsoError::_Internal::interval_exceeded(const SsoError* msg) {
  return *msg->_impl_.reason_.interval_exceeded_;
}
void SsoError::set_allocated_user_is_temporary_blocked(::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked* user_is_temporary_blocked) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (user_is_temporary_blocked) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_is_temporary_blocked);
    if (message_arena != submessage_arena) {
      user_is_temporary_blocked = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user_is_temporary_blocked, submessage_arena);
    }
    set_has_user_is_temporary_blocked();
    _impl_.reason_.user_is_temporary_blocked_ = user_is_temporary_blocked;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.SsoError.user_is_temporary_blocked)
}
void SsoError::set_allocated_user_not_found(::keyapis::identity::v1::SsoError_UserNotFound* user_not_found) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (user_not_found) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_not_found);
    if (message_arena != submessage_arena) {
      user_not_found = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user_not_found, submessage_arena);
    }
    set_has_user_not_found();
    _impl_.reason_.user_not_found_ = user_not_found;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.SsoError.user_not_found)
}
void SsoError::set_allocated_wrong_credentials(::keyapis::identity::v1::SsoError_WrongCredentials* wrong_credentials) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (wrong_credentials) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wrong_credentials);
    if (message_arena != submessage_arena) {
      wrong_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wrong_credentials, submessage_arena);
    }
    set_has_wrong_credentials();
    _impl_.reason_.wrong_credentials_ = wrong_credentials;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.SsoError.wrong_credentials)
}
void SsoError::set_allocated_user_is_blocked(::keyapis::identity::v1::SsoError_UserIsBlocked* user_is_blocked) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (user_is_blocked) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_is_blocked);
    if (message_arena != submessage_arena) {
      user_is_blocked = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user_is_blocked, submessage_arena);
    }
    set_has_user_is_blocked();
    _impl_.reason_.user_is_blocked_ = user_is_blocked;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.SsoError.user_is_blocked)
}
void SsoError::set_allocated_interval_exceeded(::keyapis::identity::v1::SsoError_IntervalExceeded* interval_exceeded) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (interval_exceeded) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interval_exceeded);
    if (message_arena != submessage_arena) {
      interval_exceeded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interval_exceeded, submessage_arena);
    }
    set_has_interval_exceeded();
    _impl_.reason_.interval_exceeded_ = interval_exceeded;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.SsoError.interval_exceeded)
}
SsoError::SsoError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.SsoError)
}
SsoError::SsoError(const SsoError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SsoError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kUserIsTemporaryBlocked: {
      _this->_internal_mutable_user_is_temporary_blocked()->::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked::MergeFrom(
          from._internal_user_is_temporary_blocked());
      break;
    }
    case kUserNotFound: {
      _this->_internal_mutable_user_not_found()->::keyapis::identity::v1::SsoError_UserNotFound::MergeFrom(
          from._internal_user_not_found());
      break;
    }
    case kWrongCredentials: {
      _this->_internal_mutable_wrong_credentials()->::keyapis::identity::v1::SsoError_WrongCredentials::MergeFrom(
          from._internal_wrong_credentials());
      break;
    }
    case kUserIsBlocked: {
      _this->_internal_mutable_user_is_blocked()->::keyapis::identity::v1::SsoError_UserIsBlocked::MergeFrom(
          from._internal_user_is_blocked());
      break;
    }
    case kIntervalExceeded: {
      _this->_internal_mutable_interval_exceeded()->::keyapis::identity::v1::SsoError_IntervalExceeded::MergeFrom(
          from._internal_interval_exceeded());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.SsoError)
}

inline void SsoError::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

SsoError::~SsoError() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.SsoError)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void SsoError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void SsoError::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void SsoError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.SsoError)
  switch (reason_case()) {
    case kUserIsTemporaryBlocked: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.user_is_temporary_blocked_;
      }
      break;
    }
    case kUserNotFound: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.user_not_found_;
      }
      break;
    }
    case kWrongCredentials: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.wrong_credentials_;
      }
      break;
    }
    case kUserIsBlocked: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.user_is_blocked_;
      }
      break;
    }
    case kIntervalExceeded: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.interval_exceeded_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void SsoError::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.SsoError)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* SsoError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.SsoError.UserIsTemporaryBlocked user_is_temporary_blocked = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_is_temporary_blocked(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError.UserNotFound user_not_found = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_not_found(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError.WrongCredentials wrong_credentials = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_wrong_credentials(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError.UserIsBlocked user_is_blocked = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_is_blocked(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError.IntervalExceeded interval_exceeded = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_interval_exceeded(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* SsoError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.SsoError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kUserIsTemporaryBlocked: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::user_is_temporary_blocked(this),
          _Internal::user_is_temporary_blocked(this).GetCachedSize(), target, stream);
      break;
    }
    case kUserNotFound: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::user_not_found(this),
          _Internal::user_not_found(this).GetCachedSize(), target, stream);
      break;
    }
    case kWrongCredentials: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, _Internal::wrong_credentials(this),
          _Internal::wrong_credentials(this).GetCachedSize(), target, stream);
      break;
    }
    case kUserIsBlocked: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, _Internal::user_is_blocked(this),
          _Internal::user_is_blocked(this).GetCachedSize(), target, stream);
      break;
    }
    case kIntervalExceeded: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(5, _Internal::interval_exceeded(this),
          _Internal::interval_exceeded(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.SsoError)
  return target;
}

::size_t SsoError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.SsoError)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.identity.v1.SsoError.UserIsTemporaryBlocked user_is_temporary_blocked = 1;
    case kUserIsTemporaryBlocked: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.user_is_temporary_blocked_);
      break;
    }
    // .keyapis.identity.v1.SsoError.UserNotFound user_not_found = 2;
    case kUserNotFound: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.user_not_found_);
      break;
    }
    // .keyapis.identity.v1.SsoError.WrongCredentials wrong_credentials = 3;
    case kWrongCredentials: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.wrong_credentials_);
      break;
    }
    // .keyapis.identity.v1.SsoError.UserIsBlocked user_is_blocked = 4;
    case kUserIsBlocked: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.user_is_blocked_);
      break;
    }
    // .keyapis.identity.v1.SsoError.IntervalExceeded interval_exceeded = 5;
    case kIntervalExceeded: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.interval_exceeded_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void SsoError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SsoError*>(
      &from));
}

void SsoError::MergeFrom(const SsoError& from) {
  SsoError* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.SsoError)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kUserIsTemporaryBlocked: {
      _this->_internal_mutable_user_is_temporary_blocked()->::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked::MergeFrom(
          from._internal_user_is_temporary_blocked());
      break;
    }
    case kUserNotFound: {
      _this->_internal_mutable_user_not_found()->::keyapis::identity::v1::SsoError_UserNotFound::MergeFrom(
          from._internal_user_not_found());
      break;
    }
    case kWrongCredentials: {
      _this->_internal_mutable_wrong_credentials()->::keyapis::identity::v1::SsoError_WrongCredentials::MergeFrom(
          from._internal_wrong_credentials());
      break;
    }
    case kUserIsBlocked: {
      _this->_internal_mutable_user_is_blocked()->::keyapis::identity::v1::SsoError_UserIsBlocked::MergeFrom(
          from._internal_user_is_blocked());
      break;
    }
    case kIntervalExceeded: {
      _this->_internal_mutable_interval_exceeded()->::keyapis::identity::v1::SsoError_IntervalExceeded::MergeFrom(
          from._internal_interval_exceeded());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SsoError::CopyFrom(const SsoError& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.SsoError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SsoError::IsInitialized() const {
  return true;
}

void SsoError::InternalSwap(SsoError* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string SsoError::GetTypeName() const {
  return "keyapis.identity.v1.SsoError";
}

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

class KeyError_UserCreation::_Internal {
 public:
};

KeyError_UserCreation::KeyError_UserCreation(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.KeyError.UserCreation)
}
KeyError_UserCreation::KeyError_UserCreation(const KeyError_UserCreation& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.KeyError.UserCreation)
}

inline void KeyError_UserCreation::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

KeyError_UserCreation::~KeyError_UserCreation() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.KeyError.UserCreation)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void KeyError_UserCreation::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void KeyError_UserCreation::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void KeyError_UserCreation::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.KeyError.UserCreation)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* KeyError_UserCreation::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* KeyError_UserCreation::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.KeyError.UserCreation)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.KeyError.UserCreation)
  return target;
}

::size_t KeyError_UserCreation::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.KeyError.UserCreation)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void KeyError_UserCreation::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const KeyError_UserCreation*>(
      &from));
}

void KeyError_UserCreation::MergeFrom(const KeyError_UserCreation& from) {
  KeyError_UserCreation* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.KeyError.UserCreation)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void KeyError_UserCreation::CopyFrom(const KeyError_UserCreation& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.KeyError.UserCreation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KeyError_UserCreation::IsInitialized() const {
  return true;
}

void KeyError_UserCreation::InternalSwap(KeyError_UserCreation* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string KeyError_UserCreation::GetTypeName() const {
  return "keyapis.identity.v1.KeyError.UserCreation";
}

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

class KeyError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::KeyError, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::KeyError_UserCreation& user_creation(const KeyError* msg);
};

const ::keyapis::identity::v1::KeyError_UserCreation&
KeyError::_Internal::user_creation(const KeyError* msg) {
  return *msg->_impl_.reason_.user_creation_;
}
void KeyError::set_allocated_user_creation(::keyapis::identity::v1::KeyError_UserCreation* user_creation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (user_creation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(user_creation);
    if (message_arena != submessage_arena) {
      user_creation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user_creation, submessage_arena);
    }
    set_has_user_creation();
    _impl_.reason_.user_creation_ = user_creation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.KeyError.user_creation)
}
KeyError::KeyError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.KeyError)
}
KeyError::KeyError(const KeyError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  KeyError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kUserCreation: {
      _this->_internal_mutable_user_creation()->::keyapis::identity::v1::KeyError_UserCreation::MergeFrom(
          from._internal_user_creation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.KeyError)
}

inline void KeyError::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

KeyError::~KeyError() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.KeyError)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void KeyError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void KeyError::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void KeyError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.KeyError)
  switch (reason_case()) {
    case kUserCreation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.user_creation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void KeyError::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.KeyError)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* KeyError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.KeyError.UserCreation user_creation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_creation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* KeyError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.KeyError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.identity.v1.KeyError.UserCreation user_creation = 1;
  if (reason_case() == kUserCreation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::user_creation(this),
        _Internal::user_creation(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.KeyError)
  return target;
}

::size_t KeyError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.KeyError)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.identity.v1.KeyError.UserCreation user_creation = 1;
    case kUserCreation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.user_creation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void KeyError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const KeyError*>(
      &from));
}

void KeyError::MergeFrom(const KeyError& from) {
  KeyError* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.KeyError)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kUserCreation: {
      _this->_internal_mutable_user_creation()->::keyapis::identity::v1::KeyError_UserCreation::MergeFrom(
          from._internal_user_creation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void KeyError::CopyFrom(const KeyError& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.KeyError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KeyError::IsInitialized() const {
  return true;
}

void KeyError::InternalSwap(KeyError* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string KeyError::GetTypeName() const {
  return "keyapis.identity.v1.KeyError";
}

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

class PostAuthorizationSendCodeRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostAuthorizationSendCodeRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostAuthorizationSendCodeRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationSendCodeRequest, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer& captcha_answer(const PostAuthorizationSendCodeRequest* msg);
  static void set_has_captcha_answer(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::identity::v1::CaptchaAnswer&
PostAuthorizationSendCodeRequest::_Internal::captcha_answer(const PostAuthorizationSendCodeRequest* msg) {
  return *msg->_impl_.captcha_answer_;
}
PostAuthorizationSendCodeRequest::PostAuthorizationSendCodeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
}
PostAuthorizationSendCodeRequest::PostAuthorizationSendCodeRequest(const PostAuthorizationSendCodeRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationSendCodeRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.captcha_answer_){nullptr}
    , decltype(_impl_.otp_text_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.captcha_answer_ = new ::keyapis::identity::v1::CaptchaAnswer(*from._impl_.captcha_answer_);
  }
  clear_has_otp_text();
  switch (from.otp_text_case()) {
    case kPhoneNumber: {
      _this->_internal_set_phone_number(from._internal_phone_number());
      break;
    }
    case OTP_TEXT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
}

inline void PostAuthorizationSendCodeRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.captcha_answer_){nullptr}
    , decltype(_impl_.otp_text_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_otp_text();
}

PostAuthorizationSendCodeRequest::~PostAuthorizationSendCodeRequest() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationSendCodeRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.captcha_answer_;
  if (has_otp_text()) {
    clear_otp_text();
  }
}

void PostAuthorizationSendCodeRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationSendCodeRequest::clear_otp_text() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  switch (otp_text_case()) {
    case kPhoneNumber: {
      _impl_.otp_text_.phone_number_.Destroy();
      break;
    }
    case OTP_TEXT_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = OTP_TEXT_NOT_SET;
}


void PostAuthorizationSendCodeRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.captcha_answer_ != nullptr);
    _impl_.captcha_answer_->Clear();
  }
  clear_otp_text();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationSendCodeRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string phone_number = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_phone_number();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 2 [(.google.api.field_behavior) = OPTIONAL];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationSendCodeRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string phone_number = 1;
  if (otp_text_case() == kPhoneNumber) {
    const std::string& _s = this->_internal_phone_number();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationSendCodeRequest.phone_number");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 2 [(.google.api.field_behavior) = OPTIONAL];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::captcha_answer(this),
        _Internal::captcha_answer(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  return target;
}

::size_t PostAuthorizationSendCodeRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 2 [(.google.api.field_behavior) = OPTIONAL];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.captcha_answer_);
  }

  switch (otp_text_case()) {
    // string phone_number = 1;
    case kPhoneNumber: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_phone_number());
      break;
    }
    case OTP_TEXT_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationSendCodeRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationSendCodeRequest*>(
      &from));
}

void PostAuthorizationSendCodeRequest::MergeFrom(const PostAuthorizationSendCodeRequest& from) {
  PostAuthorizationSendCodeRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer::MergeFrom(
        from._internal_captcha_answer());
  }
  switch (from.otp_text_case()) {
    case kPhoneNumber: {
      _this->_internal_set_phone_number(from._internal_phone_number());
      break;
    }
    case OTP_TEXT_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationSendCodeRequest::CopyFrom(const PostAuthorizationSendCodeRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationSendCodeRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationSendCodeRequest::IsInitialized() const {
  return true;
}

void PostAuthorizationSendCodeRequest::InternalSwap(PostAuthorizationSendCodeRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.captcha_answer_, other->_impl_.captcha_answer_);
  swap(_impl_.otp_text_, other->_impl_.otp_text_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationSendCodeRequest::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationSendCodeRequest";
}

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

class PostAuthorizationSendCodeResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer_Error& captcha_answer(const PostAuthorizationSendCodeResponse_Error* msg);
  static const ::keyapis::identity::v1::SsoError& sso(const PostAuthorizationSendCodeResponse_Error* msg);
};

const ::keyapis::identity::v1::CaptchaAnswer_Error&
PostAuthorizationSendCodeResponse_Error::_Internal::captcha_answer(const PostAuthorizationSendCodeResponse_Error* msg) {
  return *msg->_impl_.reason_.captcha_answer_;
}
const ::keyapis::identity::v1::SsoError&
PostAuthorizationSendCodeResponse_Error::_Internal::sso(const PostAuthorizationSendCodeResponse_Error* msg) {
  return *msg->_impl_.reason_.sso_;
}
void PostAuthorizationSendCodeResponse_Error::set_allocated_captcha_answer(::keyapis::identity::v1::CaptchaAnswer_Error* captcha_answer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (captcha_answer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(captcha_answer);
    if (message_arena != submessage_arena) {
      captcha_answer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, captcha_answer, submessage_arena);
    }
    set_has_captcha_answer();
    _impl_.reason_.captcha_answer_ = captcha_answer;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error.captcha_answer)
}
void PostAuthorizationSendCodeResponse_Error::set_allocated_sso(::keyapis::identity::v1::SsoError* sso) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (sso) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sso);
    if (message_arena != submessage_arena) {
      sso = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sso, submessage_arena);
    }
    set_has_sso();
    _impl_.reason_.sso_ = sso;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error.sso)
}
PostAuthorizationSendCodeResponse_Error::PostAuthorizationSendCodeResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
}
PostAuthorizationSendCodeResponse_Error::PostAuthorizationSendCodeResponse_Error(const PostAuthorizationSendCodeResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationSendCodeResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kCaptchaAnswer: {
      _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer_Error::MergeFrom(
          from._internal_captcha_answer());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
}

inline void PostAuthorizationSendCodeResponse_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

PostAuthorizationSendCodeResponse_Error::~PostAuthorizationSendCodeResponse_Error() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationSendCodeResponse_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void PostAuthorizationSendCodeResponse_Error::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationSendCodeResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  switch (reason_case()) {
    case kCaptchaAnswer: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.captcha_answer_;
      }
      break;
    }
    case kSso: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.sso_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostAuthorizationSendCodeResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationSendCodeResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.CaptchaAnswer.Error captcha_answer = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError sso = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sso(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationSendCodeResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kCaptchaAnswer: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::captcha_answer(this),
          _Internal::captcha_answer(this).GetCachedSize(), target, stream);
      break;
    }
    case kSso: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::sso(this),
          _Internal::sso(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  return target;
}

::size_t PostAuthorizationSendCodeResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.identity.v1.CaptchaAnswer.Error captcha_answer = 1;
    case kCaptchaAnswer: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.captcha_answer_);
      break;
    }
    // .keyapis.identity.v1.SsoError sso = 2;
    case kSso: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.sso_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationSendCodeResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationSendCodeResponse_Error*>(
      &from));
}

void PostAuthorizationSendCodeResponse_Error::MergeFrom(const PostAuthorizationSendCodeResponse_Error& from) {
  PostAuthorizationSendCodeResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kCaptchaAnswer: {
      _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer_Error::MergeFrom(
          from._internal_captcha_answer());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationSendCodeResponse_Error::CopyFrom(const PostAuthorizationSendCodeResponse_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationSendCodeResponse_Error::IsInitialized() const {
  return true;
}

void PostAuthorizationSendCodeResponse_Error::InternalSwap(PostAuthorizationSendCodeResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationSendCodeResponse_Error::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error";
}

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

class PostAuthorizationSendCodeResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationSendCodeResponse, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::OtpCode& data(const PostAuthorizationSendCodeResponse* msg);
  static const ::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error& error(const PostAuthorizationSendCodeResponse* msg);
};

const ::keyapis::identity::v1::OtpCode&
PostAuthorizationSendCodeResponse::_Internal::data(const PostAuthorizationSendCodeResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error&
PostAuthorizationSendCodeResponse::_Internal::error(const PostAuthorizationSendCodeResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void PostAuthorizationSendCodeResponse::set_allocated_data(::keyapis::identity::v1::OtpCode* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationSendCodeResponse.data)
}
void PostAuthorizationSendCodeResponse::set_allocated_error(::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationSendCodeResponse.error)
}
PostAuthorizationSendCodeResponse::PostAuthorizationSendCodeResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
}
PostAuthorizationSendCodeResponse::PostAuthorizationSendCodeResponse(const PostAuthorizationSendCodeResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationSendCodeResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::identity::v1::OtpCode::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
}

inline void PostAuthorizationSendCodeResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

PostAuthorizationSendCodeResponse::~PostAuthorizationSendCodeResponse() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationSendCodeResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void PostAuthorizationSendCodeResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationSendCodeResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void PostAuthorizationSendCodeResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationSendCodeResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.OtpCode data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationSendCodeResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::data(this),
          _Internal::data(this).GetCachedSize(), target, stream);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  return target;
}

::size_t PostAuthorizationSendCodeResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.identity.v1.OtpCode data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.identity.v1.PostAuthorizationSendCodeResponse.Error error = 2;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationSendCodeResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationSendCodeResponse*>(
      &from));
}

void PostAuthorizationSendCodeResponse::MergeFrom(const PostAuthorizationSendCodeResponse& from) {
  PostAuthorizationSendCodeResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::identity::v1::OtpCode::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationSendCodeResponse::CopyFrom(const PostAuthorizationSendCodeResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationSendCodeResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationSendCodeResponse::IsInitialized() const {
  return true;
}

void PostAuthorizationSendCodeResponse::InternalSwap(PostAuthorizationSendCodeResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationSendCodeResponse::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationSendCodeResponse";
}

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

class PostAuthorizationLoginRequest::_Internal {
 public:
};

PostAuthorizationLoginRequest::PostAuthorizationLoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationLoginRequest)
}
PostAuthorizationLoginRequest::PostAuthorizationLoginRequest(const PostAuthorizationLoginRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationLoginRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.code_id_) {}

    , decltype(_impl_.code_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.code_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_code_id().empty()) {
    _this->_impl_.code_id_.Set(from._internal_code_id(), _this->GetArenaForAllocation());
  }
  _impl_.code_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_code().empty()) {
    _this->_impl_.code_.Set(from._internal_code(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationLoginRequest)
}

inline void PostAuthorizationLoginRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.code_id_) {}

    , decltype(_impl_.code_) {}

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.code_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.code_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

PostAuthorizationLoginRequest::~PostAuthorizationLoginRequest() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationLoginRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationLoginRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.code_id_.Destroy();
  _impl_.code_.Destroy();
}

void PostAuthorizationLoginRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationLoginRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationLoginRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.code_id_.ClearToEmpty();
  _impl_.code_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationLoginRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string code_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_code_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string code = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_code();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationLoginRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationLoginRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string code_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code_id().empty()) {
    const std::string& _s = this->_internal_code_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationLoginRequest.code_id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // string code = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code().empty()) {
    const std::string& _s = this->_internal_code();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationLoginRequest.code");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationLoginRequest)
  return target;
}

::size_t PostAuthorizationLoginRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationLoginRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string code_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_code_id());
  }

  // string code = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_code().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_code());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationLoginRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationLoginRequest*>(
      &from));
}

void PostAuthorizationLoginRequest::MergeFrom(const PostAuthorizationLoginRequest& from) {
  PostAuthorizationLoginRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationLoginRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_code_id().empty()) {
    _this->_internal_set_code_id(from._internal_code_id());
  }
  if (!from._internal_code().empty()) {
    _this->_internal_set_code(from._internal_code());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationLoginRequest::CopyFrom(const PostAuthorizationLoginRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationLoginRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationLoginRequest::IsInitialized() const {
  return true;
}

void PostAuthorizationLoginRequest::InternalSwap(PostAuthorizationLoginRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.code_id_, lhs_arena,
                                       &other->_impl_.code_id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.code_, lhs_arena,
                                       &other->_impl_.code_, rhs_arena);
}

std::string PostAuthorizationLoginRequest::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationLoginRequest";
}

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

class PostAuthorizationLoginResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationLoginResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::OtpCode_Error& otp_code(const PostAuthorizationLoginResponse_Error* msg);
  static const ::keyapis::identity::v1::SsoError& sso(const PostAuthorizationLoginResponse_Error* msg);
  static const ::keyapis::identity::v1::KeyError& key(const PostAuthorizationLoginResponse_Error* msg);
};

const ::keyapis::identity::v1::OtpCode_Error&
PostAuthorizationLoginResponse_Error::_Internal::otp_code(const PostAuthorizationLoginResponse_Error* msg) {
  return *msg->_impl_.reason_.otp_code_;
}
const ::keyapis::identity::v1::SsoError&
PostAuthorizationLoginResponse_Error::_Internal::sso(const PostAuthorizationLoginResponse_Error* msg) {
  return *msg->_impl_.reason_.sso_;
}
const ::keyapis::identity::v1::KeyError&
PostAuthorizationLoginResponse_Error::_Internal::key(const PostAuthorizationLoginResponse_Error* msg) {
  return *msg->_impl_.reason_.key_;
}
void PostAuthorizationLoginResponse_Error::set_allocated_otp_code(::keyapis::identity::v1::OtpCode_Error* otp_code) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (otp_code) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(otp_code);
    if (message_arena != submessage_arena) {
      otp_code = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, otp_code, submessage_arena);
    }
    set_has_otp_code();
    _impl_.reason_.otp_code_ = otp_code;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginResponse.Error.otp_code)
}
void PostAuthorizationLoginResponse_Error::set_allocated_sso(::keyapis::identity::v1::SsoError* sso) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (sso) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sso);
    if (message_arena != submessage_arena) {
      sso = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sso, submessage_arena);
    }
    set_has_sso();
    _impl_.reason_.sso_ = sso;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginResponse.Error.sso)
}
void PostAuthorizationLoginResponse_Error::set_allocated_key(::keyapis::identity::v1::KeyError* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    set_has_key();
    _impl_.reason_.key_ = key;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginResponse.Error.key)
}
PostAuthorizationLoginResponse_Error::PostAuthorizationLoginResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
}
PostAuthorizationLoginResponse_Error::PostAuthorizationLoginResponse_Error(const PostAuthorizationLoginResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationLoginResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kOtpCode: {
      _this->_internal_mutable_otp_code()->::keyapis::identity::v1::OtpCode_Error::MergeFrom(
          from._internal_otp_code());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
}

inline void PostAuthorizationLoginResponse_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

PostAuthorizationLoginResponse_Error::~PostAuthorizationLoginResponse_Error() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationLoginResponse_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void PostAuthorizationLoginResponse_Error::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationLoginResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  switch (reason_case()) {
    case kOtpCode: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.otp_code_;
      }
      break;
    }
    case kSso: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.sso_;
      }
      break;
    }
    case kKey: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.key_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostAuthorizationLoginResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationLoginResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.OtpCode.Error otp_code = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_otp_code(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError sso = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sso(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.KeyError key = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationLoginResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kOtpCode: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::otp_code(this),
          _Internal::otp_code(this).GetCachedSize(), target, stream);
      break;
    }
    case kSso: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::sso(this),
          _Internal::sso(this).GetCachedSize(), target, stream);
      break;
    }
    case kKey: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, _Internal::key(this),
          _Internal::key(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  return target;
}

::size_t PostAuthorizationLoginResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.identity.v1.OtpCode.Error otp_code = 1;
    case kOtpCode: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.otp_code_);
      break;
    }
    // .keyapis.identity.v1.SsoError sso = 2;
    case kSso: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.sso_);
      break;
    }
    // .keyapis.identity.v1.KeyError key = 3;
    case kKey: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.key_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationLoginResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationLoginResponse_Error*>(
      &from));
}

void PostAuthorizationLoginResponse_Error::MergeFrom(const PostAuthorizationLoginResponse_Error& from) {
  PostAuthorizationLoginResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kOtpCode: {
      _this->_internal_mutable_otp_code()->::keyapis::identity::v1::OtpCode_Error::MergeFrom(
          from._internal_otp_code());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationLoginResponse_Error::CopyFrom(const PostAuthorizationLoginResponse_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationLoginResponse.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationLoginResponse_Error::IsInitialized() const {
  return true;
}

void PostAuthorizationLoginResponse_Error::InternalSwap(PostAuthorizationLoginResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationLoginResponse_Error::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationLoginResponse.Error";
}

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

class PostAuthorizationLoginResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationLoginResponse, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::UserToken& data(const PostAuthorizationLoginResponse* msg);
  static const ::keyapis::identity::v1::PostAuthorizationLoginResponse_Error& error(const PostAuthorizationLoginResponse* msg);
};

const ::keyapis::identity::v1::UserToken&
PostAuthorizationLoginResponse::_Internal::data(const PostAuthorizationLoginResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::identity::v1::PostAuthorizationLoginResponse_Error&
PostAuthorizationLoginResponse::_Internal::error(const PostAuthorizationLoginResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void PostAuthorizationLoginResponse::set_allocated_data(::keyapis::identity::v1::UserToken* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginResponse.data)
}
void PostAuthorizationLoginResponse::set_allocated_error(::keyapis::identity::v1::PostAuthorizationLoginResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginResponse.error)
}
PostAuthorizationLoginResponse::PostAuthorizationLoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationLoginResponse)
}
PostAuthorizationLoginResponse::PostAuthorizationLoginResponse(const PostAuthorizationLoginResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationLoginResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::identity::v1::UserToken::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostAuthorizationLoginResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationLoginResponse)
}

inline void PostAuthorizationLoginResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

PostAuthorizationLoginResponse::~PostAuthorizationLoginResponse() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationLoginResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationLoginResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void PostAuthorizationLoginResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationLoginResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationLoginResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void PostAuthorizationLoginResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationLoginResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationLoginResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.UserToken data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.PostAuthorizationLoginResponse.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationLoginResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationLoginResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::data(this),
          _Internal::data(this).GetCachedSize(), target, stream);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationLoginResponse)
  return target;
}

::size_t PostAuthorizationLoginResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationLoginResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.identity.v1.UserToken data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.identity.v1.PostAuthorizationLoginResponse.Error error = 2;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationLoginResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationLoginResponse*>(
      &from));
}

void PostAuthorizationLoginResponse::MergeFrom(const PostAuthorizationLoginResponse& from) {
  PostAuthorizationLoginResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationLoginResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::identity::v1::UserToken::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostAuthorizationLoginResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationLoginResponse::CopyFrom(const PostAuthorizationLoginResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationLoginResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationLoginResponse::IsInitialized() const {
  return true;
}

void PostAuthorizationLoginResponse::InternalSwap(PostAuthorizationLoginResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationLoginResponse::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationLoginResponse";
}

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

class PostAuthorizationLoginByPasswordRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostAuthorizationLoginByPasswordRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostAuthorizationLoginByPasswordRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationLoginByPasswordRequest, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer& captcha_answer(const PostAuthorizationLoginByPasswordRequest* msg);
  static void set_has_captcha_answer(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::identity::v1::CaptchaAnswer&
PostAuthorizationLoginByPasswordRequest::_Internal::captcha_answer(const PostAuthorizationLoginByPasswordRequest* msg) {
  return *msg->_impl_.captcha_answer_;
}
PostAuthorizationLoginByPasswordRequest::PostAuthorizationLoginByPasswordRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
}
PostAuthorizationLoginByPasswordRequest::PostAuthorizationLoginByPasswordRequest(const PostAuthorizationLoginByPasswordRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationLoginByPasswordRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.password_) {}

    , decltype(_impl_.captcha_answer_){nullptr}
    , decltype(_impl_.type_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.password_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.password_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_password().empty()) {
    _this->_impl_.password_.Set(from._internal_password(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.captcha_answer_ = new ::keyapis::identity::v1::CaptchaAnswer(*from._impl_.captcha_answer_);
  }
  clear_has_type();
  switch (from.type_case()) {
    case kPhoneNumber: {
      _this->_internal_set_phone_number(from._internal_phone_number());
      break;
    }
    case kEmail: {
      _this->_internal_set_email(from._internal_email());
      break;
    }
    case kLogin: {
      _this->_internal_set_login(from._internal_login());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
}

inline void PostAuthorizationLoginByPasswordRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.password_) {}

    , decltype(_impl_.captcha_answer_){nullptr}
    , decltype(_impl_.type_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  _impl_.password_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.password_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  clear_has_type();
}

PostAuthorizationLoginByPasswordRequest::~PostAuthorizationLoginByPasswordRequest() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationLoginByPasswordRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.password_.Destroy();
  if (this != internal_default_instance()) delete _impl_.captcha_answer_;
  if (has_type()) {
    clear_type();
  }
}

void PostAuthorizationLoginByPasswordRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationLoginByPasswordRequest::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  switch (type_case()) {
    case kPhoneNumber: {
      _impl_.type_.phone_number_.Destroy();
      break;
    }
    case kEmail: {
      _impl_.type_.email_.Destroy();
      break;
    }
    case kLogin: {
      _impl_.type_.login_.Destroy();
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void PostAuthorizationLoginByPasswordRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.password_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.captcha_answer_ != nullptr);
    _impl_.captcha_answer_->Clear();
  }
  clear_type();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationLoginByPasswordRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string phone_number = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_phone_number();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string email = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_email();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string login = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_login();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string password = 4 [(.google.api.field_behavior) = REQUIRED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_password();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 5 [(.google.api.field_behavior) = OPTIONAL];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationLoginByPasswordRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kPhoneNumber: {
      const std::string& _s = this->_internal_phone_number();
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest.phone_number");
      target = stream->WriteStringMaybeAliased(1, _s, target);
      break;
    }
    case kEmail: {
      const std::string& _s = this->_internal_email();
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest.email");
      target = stream->WriteStringMaybeAliased(2, _s, target);
      break;
    }
    case kLogin: {
      const std::string& _s = this->_internal_login();
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest.login");
      target = stream->WriteStringMaybeAliased(3, _s, target);
      break;
    }
    default: ;
  }
  // string password = 4 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_password().empty()) {
    const std::string& _s = this->_internal_password();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest.password");
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 5 [(.google.api.field_behavior) = OPTIONAL];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::captcha_answer(this),
        _Internal::captcha_answer(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  return target;
}

::size_t PostAuthorizationLoginByPasswordRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string password = 4 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_password().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_password());
  }

  // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 5 [(.google.api.field_behavior) = OPTIONAL];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.captcha_answer_);
  }

  switch (type_case()) {
    // string phone_number = 1;
    case kPhoneNumber: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_phone_number());
      break;
    }
    // string email = 2;
    case kEmail: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_email());
      break;
    }
    // string login = 3;
    case kLogin: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_login());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationLoginByPasswordRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationLoginByPasswordRequest*>(
      &from));
}

void PostAuthorizationLoginByPasswordRequest::MergeFrom(const PostAuthorizationLoginByPasswordRequest& from) {
  PostAuthorizationLoginByPasswordRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_password().empty()) {
    _this->_internal_set_password(from._internal_password());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer::MergeFrom(
        from._internal_captcha_answer());
  }
  switch (from.type_case()) {
    case kPhoneNumber: {
      _this->_internal_set_phone_number(from._internal_phone_number());
      break;
    }
    case kEmail: {
      _this->_internal_set_email(from._internal_email());
      break;
    }
    case kLogin: {
      _this->_internal_set_login(from._internal_login());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationLoginByPasswordRequest::CopyFrom(const PostAuthorizationLoginByPasswordRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationLoginByPasswordRequest::IsInitialized() const {
  return true;
}

void PostAuthorizationLoginByPasswordRequest::InternalSwap(PostAuthorizationLoginByPasswordRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.password_, lhs_arena,
                                       &other->_impl_.password_, rhs_arena);
  swap(_impl_.captcha_answer_, other->_impl_.captcha_answer_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationLoginByPasswordRequest::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationLoginByPasswordRequest";
}

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

class PostAuthorizationLoginByPasswordResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer_Error& captcha_answer(const PostAuthorizationLoginByPasswordResponse_Error* msg);
  static const ::keyapis::identity::v1::SsoError& sso(const PostAuthorizationLoginByPasswordResponse_Error* msg);
  static const ::keyapis::identity::v1::KeyError& key(const PostAuthorizationLoginByPasswordResponse_Error* msg);
};

const ::keyapis::identity::v1::CaptchaAnswer_Error&
PostAuthorizationLoginByPasswordResponse_Error::_Internal::captcha_answer(const PostAuthorizationLoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.captcha_answer_;
}
const ::keyapis::identity::v1::SsoError&
PostAuthorizationLoginByPasswordResponse_Error::_Internal::sso(const PostAuthorizationLoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.sso_;
}
const ::keyapis::identity::v1::KeyError&
PostAuthorizationLoginByPasswordResponse_Error::_Internal::key(const PostAuthorizationLoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.key_;
}
void PostAuthorizationLoginByPasswordResponse_Error::set_allocated_captcha_answer(::keyapis::identity::v1::CaptchaAnswer_Error* captcha_answer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (captcha_answer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(captcha_answer);
    if (message_arena != submessage_arena) {
      captcha_answer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, captcha_answer, submessage_arena);
    }
    set_has_captcha_answer();
    _impl_.reason_.captcha_answer_ = captcha_answer;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error.captcha_answer)
}
void PostAuthorizationLoginByPasswordResponse_Error::set_allocated_sso(::keyapis::identity::v1::SsoError* sso) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (sso) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sso);
    if (message_arena != submessage_arena) {
      sso = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sso, submessage_arena);
    }
    set_has_sso();
    _impl_.reason_.sso_ = sso;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error.sso)
}
void PostAuthorizationLoginByPasswordResponse_Error::set_allocated_key(::keyapis::identity::v1::KeyError* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    set_has_key();
    _impl_.reason_.key_ = key;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error.key)
}
PostAuthorizationLoginByPasswordResponse_Error::PostAuthorizationLoginByPasswordResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
}
PostAuthorizationLoginByPasswordResponse_Error::PostAuthorizationLoginByPasswordResponse_Error(const PostAuthorizationLoginByPasswordResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationLoginByPasswordResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kCaptchaAnswer: {
      _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer_Error::MergeFrom(
          from._internal_captcha_answer());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
}

inline void PostAuthorizationLoginByPasswordResponse_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

PostAuthorizationLoginByPasswordResponse_Error::~PostAuthorizationLoginByPasswordResponse_Error() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationLoginByPasswordResponse_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

void PostAuthorizationLoginByPasswordResponse_Error::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationLoginByPasswordResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  switch (reason_case()) {
    case kCaptchaAnswer: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.captcha_answer_;
      }
      break;
    }
    case kSso: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.sso_;
      }
      break;
    }
    case kKey: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.key_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostAuthorizationLoginByPasswordResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_reason();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationLoginByPasswordResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.CaptchaAnswer.Error captcha_answer = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError sso = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sso(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.KeyError key = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationLoginByPasswordResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kCaptchaAnswer: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::captcha_answer(this),
          _Internal::captcha_answer(this).GetCachedSize(), target, stream);
      break;
    }
    case kSso: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::sso(this),
          _Internal::sso(this).GetCachedSize(), target, stream);
      break;
    }
    case kKey: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, _Internal::key(this),
          _Internal::key(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  return target;
}

::size_t PostAuthorizationLoginByPasswordResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (reason_case()) {
    // .keyapis.identity.v1.CaptchaAnswer.Error captcha_answer = 1;
    case kCaptchaAnswer: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.captcha_answer_);
      break;
    }
    // .keyapis.identity.v1.SsoError sso = 2;
    case kSso: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.sso_);
      break;
    }
    // .keyapis.identity.v1.KeyError key = 3;
    case kKey: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.key_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationLoginByPasswordResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationLoginByPasswordResponse_Error*>(
      &from));
}

void PostAuthorizationLoginByPasswordResponse_Error::MergeFrom(const PostAuthorizationLoginByPasswordResponse_Error& from) {
  PostAuthorizationLoginByPasswordResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kCaptchaAnswer: {
      _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer_Error::MergeFrom(
          from._internal_captcha_answer());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationLoginByPasswordResponse_Error::CopyFrom(const PostAuthorizationLoginByPasswordResponse_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationLoginByPasswordResponse_Error::IsInitialized() const {
  return true;
}

void PostAuthorizationLoginByPasswordResponse_Error::InternalSwap(PostAuthorizationLoginByPasswordResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationLoginByPasswordResponse_Error::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error";
}

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

class PostAuthorizationLoginByPasswordResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::UserToken& data(const PostAuthorizationLoginByPasswordResponse* msg);
  static const ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error& error(const PostAuthorizationLoginByPasswordResponse* msg);
};

const ::keyapis::identity::v1::UserToken&
PostAuthorizationLoginByPasswordResponse::_Internal::data(const PostAuthorizationLoginByPasswordResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error&
PostAuthorizationLoginByPasswordResponse::_Internal::error(const PostAuthorizationLoginByPasswordResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void PostAuthorizationLoginByPasswordResponse::set_allocated_data(::keyapis::identity::v1::UserToken* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.data)
}
void PostAuthorizationLoginByPasswordResponse::set_allocated_error(::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.error)
}
PostAuthorizationLoginByPasswordResponse::PostAuthorizationLoginByPasswordResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
}
PostAuthorizationLoginByPasswordResponse::PostAuthorizationLoginByPasswordResponse(const PostAuthorizationLoginByPasswordResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostAuthorizationLoginByPasswordResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::identity::v1::UserToken::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
}

inline void PostAuthorizationLoginByPasswordResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

PostAuthorizationLoginByPasswordResponse::~PostAuthorizationLoginByPasswordResponse() {
  // @@protoc_insertion_point(destructor:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostAuthorizationLoginByPasswordResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void PostAuthorizationLoginByPasswordResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostAuthorizationLoginByPasswordResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void PostAuthorizationLoginByPasswordResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* PostAuthorizationLoginByPasswordResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.UserToken data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostAuthorizationLoginByPasswordResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::data(this),
          _Internal::data(this).GetCachedSize(), target, stream);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  return target;
}

::size_t PostAuthorizationLoginByPasswordResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.identity.v1.UserToken data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse.Error error = 2;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostAuthorizationLoginByPasswordResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostAuthorizationLoginByPasswordResponse*>(
      &from));
}

void PostAuthorizationLoginByPasswordResponse::MergeFrom(const PostAuthorizationLoginByPasswordResponse& from) {
  PostAuthorizationLoginByPasswordResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::identity::v1::UserToken::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostAuthorizationLoginByPasswordResponse::CopyFrom(const PostAuthorizationLoginByPasswordResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostAuthorizationLoginByPasswordResponse::IsInitialized() const {
  return true;
}

void PostAuthorizationLoginByPasswordResponse::InternalSwap(PostAuthorizationLoginByPasswordResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostAuthorizationLoginByPasswordResponse::GetTypeName() const {
  return "keyapis.identity.v1.PostAuthorizationLoginByPasswordResponse";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace identity
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::UserToken*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::UserToken >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::UserToken >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::Captcha*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::Captcha >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::Captcha >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::CaptchaAnswer_Error_WrongAnswer >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::CaptchaAnswer_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::CaptchaAnswer_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::CaptchaAnswer_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::CaptchaAnswer*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::CaptchaAnswer >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::CaptchaAnswer >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::OtpCode_Error_LifeTimeExpired >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::OtpCode_Error_NoAttempts*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::OtpCode_Error_NoAttempts >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::OtpCode_Error_NoAttempts >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::OtpCode_Error_AddressNotFound*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::OtpCode_Error_AddressNotFound >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::OtpCode_Error_AddressNotFound >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::OtpCode_Error_InvalidCode*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::OtpCode_Error_InvalidCode >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::OtpCode_Error_InvalidCode >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::OtpCode_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::OtpCode_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::OtpCode_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::OtpCode*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::OtpCode >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::OtpCode >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::SsoError_UserIsTemporaryBlocked >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::SsoError_UserNotFound*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::SsoError_UserNotFound >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::SsoError_UserNotFound >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::SsoError_WrongCredentials*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::SsoError_WrongCredentials >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::SsoError_WrongCredentials >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::SsoError_UserIsBlocked*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::SsoError_UserIsBlocked >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::SsoError_UserIsBlocked >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::SsoError_IntervalExceeded*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::SsoError_IntervalExceeded >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::SsoError_IntervalExceeded >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::SsoError*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::SsoError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::SsoError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::KeyError_UserCreation*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::KeyError_UserCreation >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::KeyError_UserCreation >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::KeyError*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::KeyError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::KeyError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationSendCodeRequest*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationSendCodeRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationSendCodeRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationSendCodeResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationSendCodeResponse*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationSendCodeResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationSendCodeResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationLoginRequest*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationLoginRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationLoginRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationLoginResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationLoginResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationLoginResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationLoginResponse*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationLoginResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationLoginResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationLoginByPasswordRequest*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationLoginByPasswordRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationLoginByPasswordRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostAuthorizationLoginByPasswordResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"