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

#include "keyapis/access_management/v1/keyapis_access_management_group_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 access_management {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR PutGroupApiKeyCreateRequest::PutGroupApiKeyCreateRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.group_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupApiKeyCreateRequestDefaultTypeInternal _PutGroupApiKeyCreateRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupApiKeyCreateResponse::PutGroupApiKeyCreateResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutGroupApiKeyCreateResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupApiKeyCreateResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupApiKeyCreateResponseDefaultTypeInternal() {}
  union {
    PutGroupApiKeyCreateResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupApiKeyCreateResponseDefaultTypeInternal _PutGroupApiKeyCreateResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupApiKeyDeleteRequest::PutGroupApiKeyDeleteRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.group_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupApiKeyDeleteRequestDefaultTypeInternal _PutGroupApiKeyDeleteRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupApiKeyDeleteResponse::PutGroupApiKeyDeleteResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PutGroupApiKeyDeleteResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupApiKeyDeleteResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupApiKeyDeleteResponseDefaultTypeInternal() {}
  union {
    PutGroupApiKeyDeleteResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupApiKeyDeleteResponseDefaultTypeInternal _PutGroupApiKeyDeleteResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR Claim::Claim(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.key_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClaimDefaultTypeInternal _Claim_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR UserGroup::UserGroup(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.user_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserGroupDefaultTypeInternal _UserGroup_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR Group::Group(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.claims_)*/{}
  , /*decltype(_impl_.requirements_)*/{}
  , /*decltype(_impl_.tags_)*/{}
  , /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

  , /*decltype(_impl_.deleted_at_)*/nullptr} {}
struct GroupDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupDefaultTypeInternal() {}
  union {
    Group _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupRequestDefaultTypeInternal _GetGroupRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupResponse_Error::GetGroupResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupResponse_ErrorDefaultTypeInternal _GetGroupResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupResponse::GetGroupResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupResponseDefaultTypeInternal() {}
  union {
    GetGroupResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupResponseDefaultTypeInternal _GetGroupResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupListRequest::GetGroupListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr
  , /*decltype(_impl_.pagination_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupListRequestDefaultTypeInternal() {}
  union {
    GetGroupListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupListRequestDefaultTypeInternal _GetGroupListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupListResponse_Error::GetGroupListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupListResponse_ErrorDefaultTypeInternal _GetGroupListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupListResponse::GetGroupListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupListResponseDefaultTypeInternal() {}
  union {
    GetGroupListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupListResponseDefaultTypeInternal _GetGroupListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupCountRequest::GetGroupCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetGroupCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupCountRequestDefaultTypeInternal() {}
  union {
    GetGroupCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupCountRequestDefaultTypeInternal _GetGroupCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupCountResponse_Error::GetGroupCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupCountResponse_ErrorDefaultTypeInternal _GetGroupCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupCountResponse::GetGroupCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupCountResponseDefaultTypeInternal() {}
  union {
    GetGroupCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupCountResponseDefaultTypeInternal _GetGroupCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupFilter_RequirementsEntry_DoNotUse::GroupFilter_RequirementsEntry_DoNotUse(
    ::_pbi::ConstantInitialized) {}
struct GroupFilter_RequirementsEntry_DoNotUseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupFilter_RequirementsEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupFilter_RequirementsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    GroupFilter_RequirementsEntry_DoNotUse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupFilter_RequirementsEntry_DoNotUseDefaultTypeInternal _GroupFilter_RequirementsEntry_DoNotUse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupFilter_ClaimsEntry_DoNotUse::GroupFilter_ClaimsEntry_DoNotUse(
    ::_pbi::ConstantInitialized) {}
struct GroupFilter_ClaimsEntry_DoNotUseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupFilter_ClaimsEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupFilter_ClaimsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    GroupFilter_ClaimsEntry_DoNotUse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupFilter_ClaimsEntry_DoNotUseDefaultTypeInternal _GroupFilter_ClaimsEntry_DoNotUse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupFilter::GroupFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.requirements_)*/{}
  , /*decltype(_impl_.claims_)*/{}
  , /*decltype(_impl_.tags_)*/{}
  , /*decltype(_impl_.text_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.hide_deleted_)*/nullptr} {}
struct GroupFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupFilterDefaultTypeInternal() {}
  union {
    GroupFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupFilterDefaultTypeInternal _GroupFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupPaging::GroupPaging(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.order_by_type_)*/ 0

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

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupPagingDefaultTypeInternal _GroupPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupRequest::PostGroupRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostGroupRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupRequestDefaultTypeInternal() {}
  union {
    PostGroupRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupRequestDefaultTypeInternal _PostGroupRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupByTemplateRequest::PostGroupByTemplateRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.group_requirements_)*/{}
  , /*decltype(_impl_.group_template_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupByTemplateRequestDefaultTypeInternal _PostGroupByTemplateRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupResponse_Error::PostGroupResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostGroupResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupResponse_ErrorDefaultTypeInternal() {}
  union {
    PostGroupResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupResponse_ErrorDefaultTypeInternal _PostGroupResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupResponse::PostGroupResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostGroupResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupResponseDefaultTypeInternal() {}
  union {
    PostGroupResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupResponseDefaultTypeInternal _PostGroupResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupByTemplateResponse_Error::PostGroupByTemplateResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostGroupByTemplateResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupByTemplateResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupByTemplateResponse_ErrorDefaultTypeInternal() {}
  union {
    PostGroupByTemplateResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupByTemplateResponse_ErrorDefaultTypeInternal _PostGroupByTemplateResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupByTemplateResponse::PostGroupByTemplateResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostGroupByTemplateResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupByTemplateResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupByTemplateResponseDefaultTypeInternal() {}
  union {
    PostGroupByTemplateResponse _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteGroupRequestDefaultTypeInternal _DeleteGroupRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteGroupResponse::DeleteGroupResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteGroupResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteGroupResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteGroupResponseDefaultTypeInternal() {}
  union {
    DeleteGroupResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteGroupResponseDefaultTypeInternal _DeleteGroupResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupUserAttachRequest::PutGroupUserAttachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.user_group_)*/nullptr} {}
struct PutGroupUserAttachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupUserAttachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupUserAttachRequestDefaultTypeInternal() {}
  union {
    PutGroupUserAttachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupUserAttachRequestDefaultTypeInternal _PutGroupUserAttachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupUserAttachResponse::PutGroupUserAttachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PutGroupUserAttachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupUserAttachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupUserAttachResponseDefaultTypeInternal() {}
  union {
    PutGroupUserAttachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupUserAttachResponseDefaultTypeInternal _PutGroupUserAttachResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupUserDetachRequest::PutGroupUserDetachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.user_group_)*/nullptr} {}
struct PutGroupUserDetachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupUserDetachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupUserDetachRequestDefaultTypeInternal() {}
  union {
    PutGroupUserDetachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupUserDetachRequestDefaultTypeInternal _PutGroupUserDetachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupUserListRequest::GetGroupUserListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr
  , /*decltype(_impl_.pagination_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupUserListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupUserListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupUserListRequestDefaultTypeInternal() {}
  union {
    GetGroupUserListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupUserListRequestDefaultTypeInternal _GetGroupUserListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupUserPaging::GroupUserPaging(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.order_by_type_)*/ 0

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

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupUserPagingDefaultTypeInternal _GroupUserPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupUserFilter::GroupUserFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.group_ids_)*/{}
  , /*decltype(_impl_.user_ids_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GroupUserFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupUserFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupUserFilterDefaultTypeInternal() {}
  union {
    GroupUserFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupUserFilterDefaultTypeInternal _GroupUserFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupUserListResponse::GetGroupUserListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupUserListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupUserListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupUserListResponseDefaultTypeInternal() {}
  union {
    GetGroupUserListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupUserListResponseDefaultTypeInternal _GetGroupUserListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupUserCountRequest::GetGroupUserCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetGroupUserCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupUserCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupUserCountRequestDefaultTypeInternal() {}
  union {
    GetGroupUserCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupUserCountRequestDefaultTypeInternal _GetGroupUserCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupUserCountResponse::GetGroupUserCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupUserCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupUserCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupUserCountResponseDefaultTypeInternal() {}
  union {
    GetGroupUserCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupUserCountResponseDefaultTypeInternal _GetGroupUserCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupUserDetachResponse::PutGroupUserDetachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PutGroupUserDetachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupUserDetachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupUserDetachResponseDefaultTypeInternal() {}
  union {
    PutGroupUserDetachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupUserDetachResponseDefaultTypeInternal _PutGroupUserDetachResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimCountRequest::GetGroupClaimCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetGroupClaimCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimCountRequestDefaultTypeInternal() {}
  union {
    GetGroupClaimCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimCountRequestDefaultTypeInternal _GetGroupClaimCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimCountResponse::GetGroupClaimCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupClaimCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimCountResponseDefaultTypeInternal() {}
  union {
    GetGroupClaimCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimCountResponseDefaultTypeInternal _GetGroupClaimCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimExistRequest::GetGroupClaimExistRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetGroupClaimExistRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimExistRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimExistRequestDefaultTypeInternal() {}
  union {
    GetGroupClaimExistRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimExistRequestDefaultTypeInternal _GetGroupClaimExistRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetGroupClaimExistResponse_Error_ClaimFilterEmptyErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimExistResponse_Error_ClaimFilterEmptyErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimExistResponse_Error_ClaimFilterEmptyErrorDefaultTypeInternal() {}
  union {
    GetGroupClaimExistResponse_Error_ClaimFilterEmptyError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimExistResponse_Error_ClaimFilterEmptyErrorDefaultTypeInternal _GetGroupClaimExistResponse_Error_ClaimFilterEmptyError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimExistResponse_Error::GetGroupClaimExistResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupClaimExistResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimExistResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimExistResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupClaimExistResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimExistResponse_ErrorDefaultTypeInternal _GetGroupClaimExistResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimExistResponse::GetGroupClaimExistResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupClaimExistResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimExistResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimExistResponseDefaultTypeInternal() {}
  union {
    GetGroupClaimExistResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimExistResponseDefaultTypeInternal _GetGroupClaimExistResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimListRequest::GetGroupClaimListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr
  , /*decltype(_impl_.pagination_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupClaimListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimListRequestDefaultTypeInternal() {}
  union {
    GetGroupClaimListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimListRequestDefaultTypeInternal _GetGroupClaimListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupClaimListResponse::GetGroupClaimListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupClaimListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupClaimListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupClaimListResponseDefaultTypeInternal() {}
  union {
    GetGroupClaimListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupClaimListResponseDefaultTypeInternal _GetGroupClaimListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupClaimFilter_ClaimsEntry_DoNotUse::GroupClaimFilter_ClaimsEntry_DoNotUse(
    ::_pbi::ConstantInitialized) {}
struct GroupClaimFilter_ClaimsEntry_DoNotUseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupClaimFilter_ClaimsEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupClaimFilter_ClaimsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    GroupClaimFilter_ClaimsEntry_DoNotUse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupClaimFilter_ClaimsEntry_DoNotUseDefaultTypeInternal _GroupClaimFilter_ClaimsEntry_DoNotUse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupClaimFilter_UserData_ClaimsEntry_DoNotUse::GroupClaimFilter_UserData_ClaimsEntry_DoNotUse(
    ::_pbi::ConstantInitialized) {}
struct GroupClaimFilter_UserData_ClaimsEntry_DoNotUseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupClaimFilter_UserData_ClaimsEntry_DoNotUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupClaimFilter_UserData_ClaimsEntry_DoNotUseDefaultTypeInternal() {}
  union {
    GroupClaimFilter_UserData_ClaimsEntry_DoNotUse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupClaimFilter_UserData_ClaimsEntry_DoNotUseDefaultTypeInternal _GroupClaimFilter_UserData_ClaimsEntry_DoNotUse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupClaimFilter_UserData::GroupClaimFilter_UserData(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.claims_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GroupClaimFilter_UserDataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupClaimFilter_UserDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupClaimFilter_UserDataDefaultTypeInternal() {}
  union {
    GroupClaimFilter_UserData _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupClaimFilter_UserDataDefaultTypeInternal _GroupClaimFilter_UserData_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupClaimFilter::GroupClaimFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.claims_)*/{}
  , /*decltype(_impl_.api_key_hash_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.user_id_)*/nullptr
  , /*decltype(_impl_.user_data_)*/nullptr} {}
struct GroupClaimFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupClaimFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupClaimFilterDefaultTypeInternal() {}
  union {
    GroupClaimFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupClaimFilterDefaultTypeInternal _GroupClaimFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupClaimPaging::GroupClaimPaging(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.order_by_type_)*/ 0

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

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupClaimPagingDefaultTypeInternal _GroupClaimPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR ValidationError::ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.path_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValidationErrorDefaultTypeInternal _ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupTemplateNotFoundError::GroupTemplateNotFoundError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.group_template_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupTemplateNotFoundErrorDefaultTypeInternal _GroupTemplateNotFoundError_default_instance_;
}  // namespace v1
}  // namespace access_management
}  // namespace keyapis
namespace keyapis {
namespace access_management {
namespace v1 {
bool GroupPaging_OrderByType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GroupPaging_OrderByType_strings[3] = {};

static const char GroupPaging_OrderByType_names[] = {
    "ID"
    "ORDER_BY_TYPE_UNKNOWN"
    "TITLE"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupPaging_OrderByType_entries[] =
    {
        {{&GroupPaging_OrderByType_names[0], 2}, 1},
        {{&GroupPaging_OrderByType_names[2], 21}, 0},
        {{&GroupPaging_OrderByType_names[23], 5}, 2},
};

static const int GroupPaging_OrderByType_entries_by_number[] = {
    1,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> ID
    2,  // 2 -> TITLE
};

const std::string& GroupPaging_OrderByType_Name(GroupPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupPaging_OrderByType_entries, GroupPaging_OrderByType_entries_by_number,
          3, GroupPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupPaging_OrderByType_entries, GroupPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupPaging_OrderByType_strings[idx].get();
}

bool GroupPaging_OrderByType_Parse(absl::string_view name, GroupPaging_OrderByType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      GroupPaging_OrderByType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<GroupPaging_OrderByType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr GroupPaging_OrderByType GroupPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr GroupPaging_OrderByType GroupPaging::ID;
constexpr GroupPaging_OrderByType GroupPaging::TITLE;
constexpr GroupPaging_OrderByType GroupPaging::OrderByType_MIN;
constexpr GroupPaging_OrderByType GroupPaging::OrderByType_MAX;
constexpr int GroupPaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupPaging_DirectionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GroupPaging_DirectionType_strings[3] = {};

static const char GroupPaging_DirectionType_names[] = {
    "ASC"
    "DESC"
    "DIRECTION_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupPaging_DirectionType_entries[] =
    {
        {{&GroupPaging_DirectionType_names[0], 3}, 2},
        {{&GroupPaging_DirectionType_names[3], 4}, 1},
        {{&GroupPaging_DirectionType_names[7], 22}, 0},
};

static const int GroupPaging_DirectionType_entries_by_number[] = {
    2,  // 0 -> DIRECTION_TYPE_UNKNOWN
    1,  // 1 -> DESC
    0,  // 2 -> ASC
};

const std::string& GroupPaging_DirectionType_Name(GroupPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupPaging_DirectionType_entries, GroupPaging_DirectionType_entries_by_number,
          3, GroupPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupPaging_DirectionType_entries, GroupPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupPaging_DirectionType_strings[idx].get();
}

bool GroupPaging_DirectionType_Parse(absl::string_view name, GroupPaging_DirectionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      GroupPaging_DirectionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<GroupPaging_DirectionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr GroupPaging_DirectionType GroupPaging::DIRECTION_TYPE_UNKNOWN;
constexpr GroupPaging_DirectionType GroupPaging::DESC;
constexpr GroupPaging_DirectionType GroupPaging::ASC;
constexpr GroupPaging_DirectionType GroupPaging::DirectionType_MIN;
constexpr GroupPaging_DirectionType GroupPaging::DirectionType_MAX;
constexpr int GroupPaging::DirectionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupUserPaging_OrderByType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GroupUserPaging_OrderByType_strings[3] = {};

static const char GroupUserPaging_OrderByType_names[] = {
    "GROUP_ID"
    "ORDER_BY_TYPE_UNKNOWN"
    "USER_ID"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupUserPaging_OrderByType_entries[] =
    {
        {{&GroupUserPaging_OrderByType_names[0], 8}, 1},
        {{&GroupUserPaging_OrderByType_names[8], 21}, 0},
        {{&GroupUserPaging_OrderByType_names[29], 7}, 2},
};

static const int GroupUserPaging_OrderByType_entries_by_number[] = {
    1,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> GROUP_ID
    2,  // 2 -> USER_ID
};

const std::string& GroupUserPaging_OrderByType_Name(GroupUserPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupUserPaging_OrderByType_entries, GroupUserPaging_OrderByType_entries_by_number,
          3, GroupUserPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupUserPaging_OrderByType_entries, GroupUserPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupUserPaging_OrderByType_strings[idx].get();
}

bool GroupUserPaging_OrderByType_Parse(absl::string_view name, GroupUserPaging_OrderByType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      GroupUserPaging_OrderByType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<GroupUserPaging_OrderByType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr GroupUserPaging_OrderByType GroupUserPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr GroupUserPaging_OrderByType GroupUserPaging::GROUP_ID;
constexpr GroupUserPaging_OrderByType GroupUserPaging::USER_ID;
constexpr GroupUserPaging_OrderByType GroupUserPaging::OrderByType_MIN;
constexpr GroupUserPaging_OrderByType GroupUserPaging::OrderByType_MAX;
constexpr int GroupUserPaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupUserPaging_DirectionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GroupUserPaging_DirectionType_strings[3] = {};

static const char GroupUserPaging_DirectionType_names[] = {
    "ASC"
    "DESC"
    "DIRECTION_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupUserPaging_DirectionType_entries[] =
    {
        {{&GroupUserPaging_DirectionType_names[0], 3}, 2},
        {{&GroupUserPaging_DirectionType_names[3], 4}, 1},
        {{&GroupUserPaging_DirectionType_names[7], 22}, 0},
};

static const int GroupUserPaging_DirectionType_entries_by_number[] = {
    2,  // 0 -> DIRECTION_TYPE_UNKNOWN
    1,  // 1 -> DESC
    0,  // 2 -> ASC
};

const std::string& GroupUserPaging_DirectionType_Name(GroupUserPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupUserPaging_DirectionType_entries, GroupUserPaging_DirectionType_entries_by_number,
          3, GroupUserPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupUserPaging_DirectionType_entries, GroupUserPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupUserPaging_DirectionType_strings[idx].get();
}

bool GroupUserPaging_DirectionType_Parse(absl::string_view name, GroupUserPaging_DirectionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      GroupUserPaging_DirectionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<GroupUserPaging_DirectionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr GroupUserPaging_DirectionType GroupUserPaging::DIRECTION_TYPE_UNKNOWN;
constexpr GroupUserPaging_DirectionType GroupUserPaging::DESC;
constexpr GroupUserPaging_DirectionType GroupUserPaging::ASC;
constexpr GroupUserPaging_DirectionType GroupUserPaging::DirectionType_MIN;
constexpr GroupUserPaging_DirectionType GroupUserPaging::DirectionType_MAX;
constexpr int GroupUserPaging::DirectionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupClaimPaging_OrderByType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GroupClaimPaging_OrderByType_strings[3] = {};

static const char GroupClaimPaging_OrderByType_names[] = {
    "KEY"
    "ORDER_BY_TYPE_UNKNOWN"
    "VALUE"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupClaimPaging_OrderByType_entries[] =
    {
        {{&GroupClaimPaging_OrderByType_names[0], 3}, 1},
        {{&GroupClaimPaging_OrderByType_names[3], 21}, 0},
        {{&GroupClaimPaging_OrderByType_names[24], 5}, 2},
};

static const int GroupClaimPaging_OrderByType_entries_by_number[] = {
    1,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> KEY
    2,  // 2 -> VALUE
};

const std::string& GroupClaimPaging_OrderByType_Name(GroupClaimPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupClaimPaging_OrderByType_entries, GroupClaimPaging_OrderByType_entries_by_number,
          3, GroupClaimPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupClaimPaging_OrderByType_entries, GroupClaimPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupClaimPaging_OrderByType_strings[idx].get();
}

bool GroupClaimPaging_OrderByType_Parse(absl::string_view name, GroupClaimPaging_OrderByType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      GroupClaimPaging_OrderByType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<GroupClaimPaging_OrderByType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr GroupClaimPaging_OrderByType GroupClaimPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr GroupClaimPaging_OrderByType GroupClaimPaging::KEY;
constexpr GroupClaimPaging_OrderByType GroupClaimPaging::VALUE;
constexpr GroupClaimPaging_OrderByType GroupClaimPaging::OrderByType_MIN;
constexpr GroupClaimPaging_OrderByType GroupClaimPaging::OrderByType_MAX;
constexpr int GroupClaimPaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupClaimPaging_DirectionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GroupClaimPaging_DirectionType_strings[3] = {};

static const char GroupClaimPaging_DirectionType_names[] = {
    "ASC"
    "DESC"
    "DIRECTION_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupClaimPaging_DirectionType_entries[] =
    {
        {{&GroupClaimPaging_DirectionType_names[0], 3}, 2},
        {{&GroupClaimPaging_DirectionType_names[3], 4}, 1},
        {{&GroupClaimPaging_DirectionType_names[7], 22}, 0},
};

static const int GroupClaimPaging_DirectionType_entries_by_number[] = {
    2,  // 0 -> DIRECTION_TYPE_UNKNOWN
    1,  // 1 -> DESC
    0,  // 2 -> ASC
};

const std::string& GroupClaimPaging_DirectionType_Name(GroupClaimPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupClaimPaging_DirectionType_entries, GroupClaimPaging_DirectionType_entries_by_number,
          3, GroupClaimPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupClaimPaging_DirectionType_entries, GroupClaimPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupClaimPaging_DirectionType_strings[idx].get();
}

bool GroupClaimPaging_DirectionType_Parse(absl::string_view name, GroupClaimPaging_DirectionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      GroupClaimPaging_DirectionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<GroupClaimPaging_DirectionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr GroupClaimPaging_DirectionType GroupClaimPaging::DIRECTION_TYPE_UNKNOWN;
constexpr GroupClaimPaging_DirectionType GroupClaimPaging::DESC;
constexpr GroupClaimPaging_DirectionType GroupClaimPaging::ASC;
constexpr GroupClaimPaging_DirectionType GroupClaimPaging::DirectionType_MIN;
constexpr GroupClaimPaging_DirectionType GroupClaimPaging::DirectionType_MAX;
constexpr int GroupClaimPaging::DirectionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================

class PutGroupApiKeyCreateRequest::_Internal {
 public:
};

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

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.group_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_id().empty()) {
    _this->_impl_.group_id_.Set(from._internal_group_id(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PutGroupApiKeyCreateRequest)
}

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

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

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

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

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

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

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

const char* PutGroupApiKeyCreateRequest::_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 group_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_group_id();
          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* PutGroupApiKeyCreateRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupApiKeyCreateRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string group_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_group_id().empty()) {
    const std::string& _s = this->_internal_group_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.PutGroupApiKeyCreateRequest.group_id");
    target = stream->WriteStringMaybeAliased(1, _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.access_management.v1.PutGroupApiKeyCreateRequest)
  return target;
}

::size_t PutGroupApiKeyCreateRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupApiKeyCreateRequest)
  ::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 group_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_group_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_group_id());
  }

  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 PutGroupApiKeyCreateRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupApiKeyCreateRequest*>(
      &from));
}

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

  if (!from._internal_group_id().empty()) {
    _this->_internal_set_group_id(from._internal_group_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PutGroupApiKeyCreateRequest::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupApiKeyCreateRequest";
}

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

class PutGroupApiKeyCreateResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::PutGroupApiKeyCreateResponse, _impl_._oneof_case_);
};

PutGroupApiKeyCreateResponse::PutGroupApiKeyCreateResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PutGroupApiKeyCreateResponse)
}
PutGroupApiKeyCreateResponse::PutGroupApiKeyCreateResponse(const PutGroupApiKeyCreateResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutGroupApiKeyCreateResponse* 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_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PutGroupApiKeyCreateResponse)
}

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

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

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

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

void PutGroupApiKeyCreateResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.PutGroupApiKeyCreateResponse)
  switch (type_case()) {
    case kData: {
      _impl_.type_.data_.Destroy();
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void PutGroupApiKeyCreateResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PutGroupApiKeyCreateResponse)
  ::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* PutGroupApiKeyCreateResponse::_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 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_data();
          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* PutGroupApiKeyCreateResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupApiKeyCreateResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string data = 1;
  if (type_case() == kData) {
    const std::string& _s = this->_internal_data();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.PutGroupApiKeyCreateResponse.data");
    target = stream->WriteStringMaybeAliased(1, _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.access_management.v1.PutGroupApiKeyCreateResponse)
  return target;
}

::size_t PutGroupApiKeyCreateResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupApiKeyCreateResponse)
  ::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()) {
    // string data = 1;
    case kData: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_data());
      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 PutGroupApiKeyCreateResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupApiKeyCreateResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PutGroupApiKeyCreateResponse::InternalSwap(PutGroupApiKeyCreateResponse* 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 PutGroupApiKeyCreateResponse::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupApiKeyCreateResponse";
}

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

class PutGroupApiKeyDeleteRequest::_Internal {
 public:
};

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

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.group_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_id().empty()) {
    _this->_impl_.group_id_.Set(from._internal_group_id(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PutGroupApiKeyDeleteRequest)
}

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

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

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

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

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

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

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

const char* PutGroupApiKeyDeleteRequest::_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 group_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_group_id();
          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* PutGroupApiKeyDeleteRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupApiKeyDeleteRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string group_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_group_id().empty()) {
    const std::string& _s = this->_internal_group_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.PutGroupApiKeyDeleteRequest.group_id");
    target = stream->WriteStringMaybeAliased(1, _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.access_management.v1.PutGroupApiKeyDeleteRequest)
  return target;
}

::size_t PutGroupApiKeyDeleteRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupApiKeyDeleteRequest)
  ::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 group_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_group_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_group_id());
  }

  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 PutGroupApiKeyDeleteRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupApiKeyDeleteRequest*>(
      &from));
}

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

  if (!from._internal_group_id().empty()) {
    _this->_internal_set_group_id(from._internal_group_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PutGroupApiKeyDeleteRequest::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupApiKeyDeleteRequest";
}

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

class PutGroupApiKeyDeleteResponse::_Internal {
 public:
};

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

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

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

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

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

void PutGroupApiKeyDeleteResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PutGroupApiKeyDeleteResponse)
  ::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* PutGroupApiKeyDeleteResponse::_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* PutGroupApiKeyDeleteResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupApiKeyDeleteResponse)
  ::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.access_management.v1.PutGroupApiKeyDeleteResponse)
  return target;
}

::size_t PutGroupApiKeyDeleteResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupApiKeyDeleteResponse)
  ::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 PutGroupApiKeyDeleteResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupApiKeyDeleteResponse*>(
      &from));
}

void PutGroupApiKeyDeleteResponse::MergeFrom(const PutGroupApiKeyDeleteResponse& from) {
  PutGroupApiKeyDeleteResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PutGroupApiKeyDeleteResponse)
  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 PutGroupApiKeyDeleteResponse::CopyFrom(const PutGroupApiKeyDeleteResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_management.v1.PutGroupApiKeyDeleteResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string PutGroupApiKeyDeleteResponse::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupApiKeyDeleteResponse";
}

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

class Claim::_Internal {
 public:
};

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

    , decltype(_impl_.value_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.key_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.key_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_key().empty()) {
    _this->_impl_.key_.Set(from._internal_key(), _this->GetArenaForAllocation());
  }
  _impl_.value_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.value_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_value().empty()) {
    _this->_impl_.value_.Set(from._internal_value(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.Claim)
}

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

    , decltype(_impl_.value_) {}

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

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

inline void Claim::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.key_.Destroy();
  _impl_.value_.Destroy();
}

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

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

  _impl_.key_.ClearToEmpty();
  _impl_.value_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* Claim::_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 key = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_key();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_value();
          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* Claim::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.Claim)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // string value = 2;
  if (!this->_internal_value().empty()) {
    const std::string& _s = this->_internal_value();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.Claim.value");
    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.access_management.v1.Claim)
  return target;
}

::size_t Claim::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.Claim)
  ::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 key = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_key().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_key());
  }

  // string value = 2;
  if (!this->_internal_value().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_value());
  }

  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 Claim::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Claim*>(
      &from));
}

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

  if (!from._internal_key().empty()) {
    _this->_internal_set_key(from._internal_key());
  }
  if (!from._internal_value().empty()) {
    _this->_internal_set_value(from._internal_value());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string Claim::GetTypeName() const {
  return "keyapis.access_management.v1.Claim";
}

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

class UserGroup::_Internal {
 public:
};

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

    , decltype(_impl_.group_id_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.user_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.user_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_user_id().empty()) {
    _this->_impl_.user_id_.Set(from._internal_user_id(), _this->GetArenaForAllocation());
  }
  _impl_.group_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_id().empty()) {
    _this->_impl_.group_id_.Set(from._internal_group_id(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.UserGroup)
}

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

    , decltype(_impl_.group_id_) {}

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

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

inline void UserGroup::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.user_id_.Destroy();
  _impl_.group_id_.Destroy();
}

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

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

  _impl_.user_id_.ClearToEmpty();
  _impl_.group_id_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* UserGroup::_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 user_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_user_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string group_id = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_group_id();
          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* UserGroup::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.UserGroup)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // string group_id = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_group_id().empty()) {
    const std::string& _s = this->_internal_group_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.UserGroup.group_id");
    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.access_management.v1.UserGroup)
  return target;
}

::size_t UserGroup::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.UserGroup)
  ::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 user_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_user_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_user_id());
  }

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

  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 UserGroup::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const UserGroup*>(
      &from));
}

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

  if (!from._internal_user_id().empty()) {
    _this->_internal_set_user_id(from._internal_user_id());
  }
  if (!from._internal_group_id().empty()) {
    _this->_internal_set_group_id(from._internal_group_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string UserGroup::GetTypeName() const {
  return "keyapis.access_management.v1.UserGroup";
}

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

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

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Group::_Internal::deleted_at(const Group* msg) {
  return *msg->_impl_.deleted_at_;
}
void Group::clear_deleted_at() {
  if (_impl_.deleted_at_ != nullptr) _impl_.deleted_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
Group::Group(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.Group)
}
Group::Group(const Group& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Group* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.claims_){from._impl_.claims_}
    , decltype(_impl_.requirements_){from._impl_.requirements_}
    , decltype(_impl_.tags_){from._impl_.tags_}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.title_) {}

    , decltype(_impl_.description_) {}

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

  _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_.title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_title().empty()) {
    _this->_impl_.title_.Set(from._internal_title(), _this->GetArenaForAllocation());
  }
  _impl_.description_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.description_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_description().empty()) {
    _this->_impl_.description_.Set(from._internal_description(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.deleted_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.deleted_at_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.Group)
}

inline void Group::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.claims_){arena}
    , decltype(_impl_.requirements_){arena}
    , decltype(_impl_.tags_){arena}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.title_) {}

    , decltype(_impl_.description_) {}

    , decltype(_impl_.deleted_at_){nullptr}
  };
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.description_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.description_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void Group::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_claims()->~RepeatedPtrField();
  _internal_mutable_requirements()->~RepeatedPtrField();
  _internal_mutable_tags()->~RepeatedPtrField();
  _impl_.id_.Destroy();
  _impl_.title_.Destroy();
  _impl_.description_.Destroy();
  if (this != internal_default_instance()) delete _impl_.deleted_at_;
}

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

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

  _internal_mutable_claims()->Clear();
  _internal_mutable_requirements()->Clear();
  _internal_mutable_tags()->Clear();
  _impl_.id_.ClearToEmpty();
  _impl_.title_.ClearToEmpty();
  _impl_.description_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.deleted_at_ != nullptr);
    _impl_.deleted_at_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Group::_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 id = 1;
      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 title = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_title();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string description = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_description();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.access_management.v1.Claim claims = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_claims(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.access_management.v1.Claim requirements = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_requirements(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp deleted_at = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_deleted_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string tags = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_tags();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(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* Group::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.Group)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1;
  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.access_management.v1.Group.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

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

  // string description = 3;
  if (!this->_internal_description().empty()) {
    const std::string& _s = this->_internal_description();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.Group.description");
    target = stream->WriteStringMaybeAliased(3, _s, target);
  }

  // repeated .keyapis.access_management.v1.Claim claims = 4;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_claims_size()); i < n; i++) {
    const auto& repfield = this->_internal_claims(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
  }

  // repeated .keyapis.access_management.v1.Claim requirements = 5;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_requirements_size()); i < n; i++) {
    const auto& repfield = this->_internal_requirements(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
  }

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

  // repeated string tags = 7;
  for (int i = 0, n = this->_internal_tags_size(); i < n; ++i) {
    const auto& s = this->_internal_tags(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.Group.tags");
    target = stream->WriteString(7, 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.access_management.v1.Group)
  return target;
}

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

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

  // repeated .keyapis.access_management.v1.Claim claims = 4;
  total_size += 1UL * this->_internal_claims_size();
  for (const auto& msg : this->_internal_claims()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .keyapis.access_management.v1.Claim requirements = 5;
  total_size += 1UL * this->_internal_requirements_size();
  for (const auto& msg : this->_internal_requirements()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated string tags = 7;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_tags().size());
  for (int i = 0, n = _internal_tags().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_tags().Get(i));
  }

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

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

  // string description = 3;
  if (!this->_internal_description().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_description());
  }

  // .google.protobuf.Timestamp deleted_at = 6;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.deleted_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 Group::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Group*>(
      &from));
}

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

  _this->_internal_mutable_claims()->MergeFrom(from._internal_claims());
  _this->_internal_mutable_requirements()->MergeFrom(from._internal_requirements());
  _this->_internal_mutable_tags()->MergeFrom(from._internal_tags());
  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  if (!from._internal_title().empty()) {
    _this->_internal_set_title(from._internal_title());
  }
  if (!from._internal_description().empty()) {
    _this->_internal_set_description(from._internal_description());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_deleted_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
        from._internal_deleted_at());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void Group::InternalSwap(Group* 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]);
  _internal_mutable_claims()->InternalSwap(other->_internal_mutable_claims());
  _internal_mutable_requirements()->InternalSwap(other->_internal_mutable_requirements());
  _internal_mutable_tags()->InternalSwap(
      other->_internal_mutable_tags());
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.title_, lhs_arena,
                                       &other->_impl_.title_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.description_, lhs_arena,
                                       &other->_impl_.description_, rhs_arena);
  swap(_impl_.deleted_at_, other->_impl_.deleted_at_);
}

std::string Group::GetTypeName() const {
  return "keyapis.access_management.v1.Group";
}

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

class GetGroupRequest::_Internal {
 public:
};

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

    , /*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());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupRequest)
}

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

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

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

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

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

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

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

const char* GetGroupRequest::_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;
      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* GetGroupRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupRequest)
  ::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.access_management.v1.GetGroupRequest.id");
    target = stream->WriteStringMaybeAliased(1, _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.access_management.v1.GetGroupRequest)
  return target;
}

::size_t GetGroupRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupRequest)
  ::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());
  }

  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 GetGroupRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupRequest*>(
      &from));
}

void GetGroupRequest::MergeFrom(const GetGroupRequest& from) {
  GetGroupRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupRequest)
  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());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupRequest::InternalSwap(GetGroupRequest* 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);
}

std::string GetGroupRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupRequest";
}

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

class GetGroupResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::ValidationError& validation(const GetGroupResponse_Error* msg);
};

const ::keyapis::access_management::v1::ValidationError&
GetGroupResponse_Error::_Internal::validation(const GetGroupResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetGroupResponse_Error::set_allocated_validation(::keyapis::access_management::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(validation);
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupResponse.Error.validation)
}
GetGroupResponse_Error::GetGroupResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupResponse.Error)
}
GetGroupResponse_Error::GetGroupResponse_Error(const GetGroupResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupResponse_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 kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupResponse.Error)
}

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

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

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

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

void GetGroupResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetGroupResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupResponse.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* GetGroupResponse_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.access_management.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), 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* GetGroupResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(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.access_management.v1.GetGroupResponse.Error)
  return target;
}

::size_t GetGroupResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupResponse.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.access_management.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      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 GetGroupResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupResponse_Error::InternalSwap(GetGroupResponse_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 GetGroupResponse_Error::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupResponse.Error";
}

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

class GetGroupResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::Group& data(const GetGroupResponse* msg);
  static const ::keyapis::access_management::v1::GetGroupResponse_Error& error(const GetGroupResponse* msg);
};

const ::keyapis::access_management::v1::Group&
GetGroupResponse::_Internal::data(const GetGroupResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::access_management::v1::GetGroupResponse_Error&
GetGroupResponse::_Internal::error(const GetGroupResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetGroupResponse::set_allocated_data(::keyapis::access_management::v1::Group* 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.access_management.v1.GetGroupResponse.data)
}
void GetGroupResponse::set_allocated_error(::keyapis::access_management::v1::GetGroupResponse_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.access_management.v1.GetGroupResponse.error)
}
GetGroupResponse::GetGroupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupResponse)
}
GetGroupResponse::GetGroupResponse(const GetGroupResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupResponse* 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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::GetGroupResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupResponse)
}

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

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

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

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

void GetGroupResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupResponse)
  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 GetGroupResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupResponse)
  ::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* GetGroupResponse::_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.access_management.v1.Group 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.access_management.v1.GetGroupResponse.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* GetGroupResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupResponse)
  ::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.access_management.v1.GetGroupResponse)
  return target;
}

::size_t GetGroupResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupResponse)
  ::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.access_management.v1.Group data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.access_management.v1.GetGroupResponse.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 GetGroupResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupResponse*>(
      &from));
}

void GetGroupResponse::MergeFrom(const GetGroupResponse& from) {
  GetGroupResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupResponse)
  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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::GetGroupResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupResponse::InternalSwap(GetGroupResponse* 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 GetGroupResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupResponse";
}

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

class GetGroupListRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetGroupListRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetGroupListRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupListRequest, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::GroupFilter& filter(const GetGroupListRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::access_management::v1::GroupPaging& paging(const GetGroupListRequest* msg);
};

const ::keyapis::access_management::v1::GroupFilter&
GetGroupListRequest::_Internal::filter(const GetGroupListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::access_management::v1::GroupPaging&
GetGroupListRequest::_Internal::paging(const GetGroupListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetGroupListRequest::set_allocated_paging(::keyapis::access_management::v1::GroupPaging* paging) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_pagination();
  if (paging) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paging);
    if (message_arena != submessage_arena) {
      paging = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paging, submessage_arena);
    }
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupListRequest.paging)
}
GetGroupListRequest::GetGroupListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupListRequest)
}
GetGroupListRequest::GetGroupListRequest(const GetGroupListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupListRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupListRequest)
}

inline void GetGroupListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_pagination();
}

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

inline void GetGroupListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
  if (has_pagination()) {
    clear_pagination();
  }
}

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

void GetGroupListRequest::clear_pagination() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupListRequest)
  switch (pagination_case()) {
    case kPaging: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.pagination_.paging_;
      }
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}


void GetGroupListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupListRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  clear_pagination();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupListRequest::_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.access_management.v1.GroupFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupPaging paging = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_paging(), 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* GetGroupListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  // .keyapis.access_management.v1.GroupPaging paging = 2;
  if (pagination_case() == kPaging) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::paging(this),
        _Internal::paging(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.access_management.v1.GetGroupListRequest)
  return target;
}

::size_t GetGroupListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupListRequest)
  ::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.access_management.v1.GroupFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  switch (pagination_case()) {
    // .keyapis.access_management.v1.GroupPaging paging = 2;
    case kPaging: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.pagination_.paging_);
      break;
    }
    case PAGINATION_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 GetGroupListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupListRequest*>(
      &from));
}

void GetGroupListRequest::MergeFrom(const GetGroupListRequest& from) {
  GetGroupListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupListRequest)
  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_filter()->::keyapis::access_management::v1::GroupFilter::MergeFrom(
        from._internal_filter());
  }
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupListRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupListRequest";
}

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

class GetGroupListResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupListResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::ValidationError& validation(const GetGroupListResponse_Error* msg);
};

const ::keyapis::access_management::v1::ValidationError&
GetGroupListResponse_Error::_Internal::validation(const GetGroupListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetGroupListResponse_Error::set_allocated_validation(::keyapis::access_management::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(validation);
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupListResponse.Error.validation)
}
GetGroupListResponse_Error::GetGroupListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupListResponse.Error)
}
GetGroupListResponse_Error::GetGroupListResponse_Error(const GetGroupListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupListResponse_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 kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupListResponse.Error)
}

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

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

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

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

void GetGroupListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupListResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetGroupListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupListResponse.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* GetGroupListResponse_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.access_management.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), 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* GetGroupListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(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.access_management.v1.GetGroupListResponse.Error)
  return target;
}

::size_t GetGroupListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupListResponse.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.access_management.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      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 GetGroupListResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupListResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupListResponse_Error::InternalSwap(GetGroupListResponse_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 GetGroupListResponse_Error::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupListResponse.Error";
}

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

class GetGroupListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::Group& data(const GetGroupListResponse* msg);
  static const ::keyapis::access_management::v1::GetGroupListResponse_Error& error(const GetGroupListResponse* msg);
};

const ::keyapis::access_management::v1::Group&
GetGroupListResponse::_Internal::data(const GetGroupListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::access_management::v1::GetGroupListResponse_Error&
GetGroupListResponse::_Internal::error(const GetGroupListResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetGroupListResponse::set_allocated_data(::keyapis::access_management::v1::Group* 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.access_management.v1.GetGroupListResponse.data)
}
void GetGroupListResponse::set_allocated_error(::keyapis::access_management::v1::GetGroupListResponse_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.access_management.v1.GetGroupListResponse.error)
}
GetGroupListResponse::GetGroupListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupListResponse)
}
GetGroupListResponse::GetGroupListResponse(const GetGroupListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupListResponse* 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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::GetGroupListResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupListResponse)
}

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

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

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

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

void GetGroupListResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupListResponse)
  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 GetGroupListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupListResponse)
  ::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* GetGroupListResponse::_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.access_management.v1.Group 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.access_management.v1.GetGroupListResponse.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* GetGroupListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupListResponse)
  ::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.access_management.v1.GetGroupListResponse)
  return target;
}

::size_t GetGroupListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupListResponse)
  ::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.access_management.v1.Group data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.access_management.v1.GetGroupListResponse.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 GetGroupListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupListResponse*>(
      &from));
}

void GetGroupListResponse::MergeFrom(const GetGroupListResponse& from) {
  GetGroupListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupListResponse)
  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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::GetGroupListResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupListResponse::InternalSwap(GetGroupListResponse* 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 GetGroupListResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupListResponse";
}

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

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

const ::keyapis::access_management::v1::GroupFilter&
GetGroupCountRequest::_Internal::filter(const GetGroupCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetGroupCountRequest::GetGroupCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupCountRequest)
}
GetGroupCountRequest::GetGroupCountRequest(const GetGroupCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupCountRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupCountRequest)
}

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

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

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

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

void GetGroupCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupCountRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupCountRequest::_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.access_management.v1.GroupFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), 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* GetGroupCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(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.access_management.v1.GetGroupCountRequest)
  return target;
}

::size_t GetGroupCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupCountRequest)
  ::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.access_management.v1.GroupFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  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 GetGroupCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupCountRequest*>(
      &from));
}

void GetGroupCountRequest::MergeFrom(const GetGroupCountRequest& from) {
  GetGroupCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupCountRequest)
  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_filter()->::keyapis::access_management::v1::GroupFilter::MergeFrom(
        from._internal_filter());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupCountRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupCountRequest";
}

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

class GetGroupCountResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupCountResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::ValidationError& validation(const GetGroupCountResponse_Error* msg);
};

const ::keyapis::access_management::v1::ValidationError&
GetGroupCountResponse_Error::_Internal::validation(const GetGroupCountResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetGroupCountResponse_Error::set_allocated_validation(::keyapis::access_management::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(validation);
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupCountResponse.Error.validation)
}
GetGroupCountResponse_Error::GetGroupCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupCountResponse.Error)
}
GetGroupCountResponse_Error::GetGroupCountResponse_Error(const GetGroupCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupCountResponse_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 kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupCountResponse.Error)
}

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

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

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

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

void GetGroupCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupCountResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetGroupCountResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupCountResponse.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* GetGroupCountResponse_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.access_management.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), 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* GetGroupCountResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupCountResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(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.access_management.v1.GetGroupCountResponse.Error)
  return target;
}

::size_t GetGroupCountResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupCountResponse.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.access_management.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      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 GetGroupCountResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupCountResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupCountResponse_Error::InternalSwap(GetGroupCountResponse_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 GetGroupCountResponse_Error::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupCountResponse.Error";
}

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

class GetGroupCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupCountResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::GetGroupCountResponse_Error& error(const GetGroupCountResponse* msg);
};

const ::keyapis::access_management::v1::GetGroupCountResponse_Error&
GetGroupCountResponse::_Internal::error(const GetGroupCountResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetGroupCountResponse::set_allocated_error(::keyapis::access_management::v1::GetGroupCountResponse_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.access_management.v1.GetGroupCountResponse.error)
}
GetGroupCountResponse::GetGroupCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupCountResponse)
}
GetGroupCountResponse::GetGroupCountResponse(const GetGroupCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupCountResponse* 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_set_data(from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::GetGroupCountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupCountResponse)
}

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

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

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

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

void GetGroupCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetGroupCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupCountResponse)
  ::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* GetGroupCountResponse::_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) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GetGroupCountResponse.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* GetGroupCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          1, this->_internal_data(), target);
      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.access_management.v1.GetGroupCountResponse)
  return target;
}

::size_t GetGroupCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupCountResponse)
  ::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()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    // .keyapis.access_management.v1.GetGroupCountResponse.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 GetGroupCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupCountResponse*>(
      &from));
}

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

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

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

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

void GetGroupCountResponse::InternalSwap(GetGroupCountResponse* 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 GetGroupCountResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupCountResponse";
}

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

GroupFilter_RequirementsEntry_DoNotUse::GroupFilter_RequirementsEntry_DoNotUse() {}
GroupFilter_RequirementsEntry_DoNotUse::GroupFilter_RequirementsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void GroupFilter_RequirementsEntry_DoNotUse::MergeFrom(const GroupFilter_RequirementsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}
// ===================================================================

GroupFilter_ClaimsEntry_DoNotUse::GroupFilter_ClaimsEntry_DoNotUse() {}
GroupFilter_ClaimsEntry_DoNotUse::GroupFilter_ClaimsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void GroupFilter_ClaimsEntry_DoNotUse::MergeFrom(const GroupFilter_ClaimsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}
// ===================================================================

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

const ::PROTOBUF_NAMESPACE_ID::BoolValue&
GroupFilter::_Internal::hide_deleted(const GroupFilter* msg) {
  return *msg->_impl_.hide_deleted_;
}
void GroupFilter::clear_hide_deleted() {
  if (_impl_.hide_deleted_ != nullptr) _impl_.hide_deleted_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
GroupFilter::GroupFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupFilter)
}
GroupFilter::GroupFilter(const GroupFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GroupFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_.requirements_)*/{}
    , /*decltype(_impl_.claims_)*/{}
    , decltype(_impl_.tags_){from._impl_.tags_}
    , decltype(_impl_.text_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.requirements_.MergeFrom(from._impl_.requirements_);
  _this->_impl_.claims_.MergeFrom(from._impl_.claims_);
  _impl_.text_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.text_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_text().empty()) {
    _this->_impl_.text_.Set(from._internal_text(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.hide_deleted_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.hide_deleted_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupFilter)
}

inline void GroupFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_.requirements_)*/{::_pbi::ArenaInitialized(), arena}
    , /*decltype(_impl_.claims_)*/{::_pbi::ArenaInitialized(), arena}
    , decltype(_impl_.tags_){arena}
    , decltype(_impl_.text_) {}

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

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

inline void GroupFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.requirements_.~MapFieldLite();
  _impl_.claims_.~MapFieldLite();
  _internal_mutable_tags()->~RepeatedPtrField();
  _impl_.text_.Destroy();
  if (this != internal_default_instance()) delete _impl_.hide_deleted_;
}

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

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

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

const char* GroupFilter::_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 text = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_text();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // map<string, string> requirements = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&_impl_.requirements_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // map<string, string> claims = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&_impl_.claims_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string tags = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_tags();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.BoolValue hide_deleted = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_hide_deleted(), 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* GroupFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string text = 1;
  if (!this->_internal_text().empty()) {
    const std::string& _s = this->_internal_text();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupFilter.text");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // map<string, string> requirements = 2;
  if (!this->_internal_requirements().empty()) {
    using MapType = ::_pb::Map<std::string, std::string>;
    using WireHelper = GroupFilter_RequirementsEntry_DoNotUse::Funcs;
    const auto& map_field = this->_internal_requirements();
    auto check_utf8 = [](const MapType::value_type& entry) {
      (void)entry;
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.first.data(), static_cast<int>(entry.first.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupFilter.requirements");
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.second.data(), static_cast<int>(entry.second.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupFilter.requirements");
    };

    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
      for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    } else {
      for (const auto& entry : map_field) {
        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    }
  }

  // map<string, string> claims = 3;
  if (!this->_internal_claims().empty()) {
    using MapType = ::_pb::Map<std::string, std::string>;
    using WireHelper = GroupFilter_ClaimsEntry_DoNotUse::Funcs;
    const auto& map_field = this->_internal_claims();
    auto check_utf8 = [](const MapType::value_type& entry) {
      (void)entry;
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.first.data(), static_cast<int>(entry.first.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupFilter.claims");
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.second.data(), static_cast<int>(entry.second.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupFilter.claims");
    };

    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
      for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
        target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    } else {
      for (const auto& entry : map_field) {
        target = WireHelper::InternalSerialize(3, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    }
  }

  // repeated string tags = 4;
  for (int i = 0, n = this->_internal_tags_size(); i < n; ++i) {
    const auto& s = this->_internal_tags(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupFilter.tags");
    target = stream->WriteString(4, s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.BoolValue hide_deleted = 5;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::hide_deleted(this),
        _Internal::hide_deleted(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.access_management.v1.GroupFilter)
  return target;
}

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

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

  // map<string, string> requirements = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_requirements_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
      it = this->_internal_requirements().begin();
      it != this->_internal_requirements().end(); ++it) {
    total_size += GroupFilter_RequirementsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // map<string, string> claims = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_claims_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
      it = this->_internal_claims().begin();
      it != this->_internal_claims().end(); ++it) {
    total_size += GroupFilter_ClaimsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // repeated string tags = 4;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_tags().size());
  for (int i = 0, n = _internal_tags().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_tags().Get(i));
  }

  // string text = 1;
  if (!this->_internal_text().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_text());
  }

  // .google.protobuf.BoolValue hide_deleted = 5;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.hide_deleted_);
  }

  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 GroupFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupFilter*>(
      &from));
}

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

  _this->_impl_.requirements_.MergeFrom(from._impl_.requirements_);
  _this->_impl_.claims_.MergeFrom(from._impl_.claims_);
  _this->_internal_mutable_tags()->MergeFrom(from._internal_tags());
  if (!from._internal_text().empty()) {
    _this->_internal_set_text(from._internal_text());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_hide_deleted()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom(
        from._internal_hide_deleted());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GroupFilter::InternalSwap(GroupFilter* 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]);
  _impl_.requirements_.InternalSwap(&other->_impl_.requirements_);
  _impl_.claims_.InternalSwap(&other->_impl_.claims_);
  _internal_mutable_tags()->InternalSwap(
      other->_internal_mutable_tags());
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.text_, lhs_arena,
                                       &other->_impl_.text_, rhs_arena);
  swap(_impl_.hide_deleted_, other->_impl_.hide_deleted_);
}

std::string GroupFilter::GetTypeName() const {
  return "keyapis.access_management.v1.GroupFilter";
}

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

class GroupPaging::_Internal {
 public:
};

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

inline void GroupPaging::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.order_by_type_) { 0 }

    , decltype(_impl_.direction_type_) { 0 }

    , decltype(_impl_.limit_) { 0 }

    , decltype(_impl_.offset_) { 0 }

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

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

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

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

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

  ::memset(&_impl_.order_by_type_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.offset_) -
      reinterpret_cast<char*>(&_impl_.order_by_type_)) + sizeof(_impl_.offset_));
  _internal_metadata_.Clear<std::string>();
}

const char* GroupPaging::_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.access_management.v1.GroupPaging.OrderByType order_by_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_order_by_type(static_cast<::keyapis::access_management::v1::GroupPaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupPaging.DirectionType direction_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_direction_type(static_cast<::keyapis::access_management::v1::GroupPaging_DirectionType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 limit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 offset = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.offset_ = ::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* GroupPaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupPaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.GroupPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_order_by_type(), target);
  }

  // .keyapis.access_management.v1.GroupPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_direction_type(), target);
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_limit(), target);
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        4, this->_internal_offset(), 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.access_management.v1.GroupPaging)
  return target;
}

::size_t GroupPaging::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GroupPaging)
  ::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.access_management.v1.GroupPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_order_by_type());
  }

  // .keyapis.access_management.v1.GroupPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_direction_type());
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_limit());
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_offset());
  }

  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 GroupPaging::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupPaging*>(
      &from));
}

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

  if (from._internal_order_by_type() != 0) {
    _this->_internal_set_order_by_type(from._internal_order_by_type());
  }
  if (from._internal_direction_type() != 0) {
    _this->_internal_set_direction_type(from._internal_direction_type());
  }
  if (from._internal_limit() != 0) {
    _this->_internal_set_limit(from._internal_limit());
  }
  if (from._internal_offset() != 0) {
    _this->_internal_set_offset(from._internal_offset());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GroupPaging::InternalSwap(GroupPaging* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GroupPaging, _impl_.offset_)
      + sizeof(GroupPaging::_impl_.offset_)
      - PROTOBUF_FIELD_OFFSET(GroupPaging, _impl_.order_by_type_)>(
          reinterpret_cast<char*>(&_impl_.order_by_type_),
          reinterpret_cast<char*>(&other->_impl_.order_by_type_));
}

std::string GroupPaging::GetTypeName() const {
  return "keyapis.access_management.v1.GroupPaging";
}

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

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

const ::keyapis::access_management::v1::Group&
PostGroupRequest::_Internal::data(const PostGroupRequest* msg) {
  return *msg->_impl_.data_;
}
PostGroupRequest::PostGroupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupRequest)
}
PostGroupRequest::PostGroupRequest(const PostGroupRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::keyapis::access_management::v1::Group(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupRequest)
}

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

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

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

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

void PostGroupRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PostGroupRequest)
  ::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_.data_ != nullptr);
    _impl_.data_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PostGroupRequest::_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.access_management.v1.Group data = 1 [(.google.api.field_behavior) = REQUIRED];
      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;
      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* PostGroupRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PostGroupRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.Group data = 1 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(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.access_management.v1.PostGroupRequest)
  return target;
}

::size_t PostGroupRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PostGroupRequest)
  ::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.access_management.v1.Group data = 1 [(.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_.data_);
  }

  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 PostGroupRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostGroupRequest*>(
      &from));
}

void PostGroupRequest::MergeFrom(const PostGroupRequest& from) {
  PostGroupRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PostGroupRequest)
  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_data()->::keyapis::access_management::v1::Group::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PostGroupRequest::GetTypeName() const {
  return "keyapis.access_management.v1.PostGroupRequest";
}

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

class PostGroupByTemplateRequest::_Internal {
 public:
};

PostGroupByTemplateRequest::PostGroupByTemplateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupByTemplateRequest)
}
PostGroupByTemplateRequest::PostGroupByTemplateRequest(const PostGroupByTemplateRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupByTemplateRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.group_requirements_){from._impl_.group_requirements_}
    , decltype(_impl_.group_template_id_) {}

    , decltype(_impl_.group_title_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.group_template_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_template_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_template_id().empty()) {
    _this->_impl_.group_template_id_.Set(from._internal_group_template_id(), _this->GetArenaForAllocation());
  }
  _impl_.group_title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_title().empty()) {
    _this->_impl_.group_title_.Set(from._internal_group_title(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupByTemplateRequest)
}

inline void PostGroupByTemplateRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.group_requirements_){arena}
    , decltype(_impl_.group_template_id_) {}

    , decltype(_impl_.group_title_) {}

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

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

inline void PostGroupByTemplateRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_group_requirements()->~RepeatedPtrField();
  _impl_.group_template_id_.Destroy();
  _impl_.group_title_.Destroy();
}

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

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

  _internal_mutable_group_requirements()->Clear();
  _impl_.group_template_id_.ClearToEmpty();
  _impl_.group_title_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PostGroupByTemplateRequest::_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 group_template_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_group_template_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string group_title = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_group_title();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.access_management.v1.Claim group_requirements = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_group_requirements(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(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* PostGroupByTemplateRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PostGroupByTemplateRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // repeated .keyapis.access_management.v1.Claim group_requirements = 3;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_group_requirements_size()); i < n; i++) {
    const auto& repfield = this->_internal_group_requirements(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, repfield, repfield.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.access_management.v1.PostGroupByTemplateRequest)
  return target;
}

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

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

  // repeated .keyapis.access_management.v1.Claim group_requirements = 3;
  total_size += 1UL * this->_internal_group_requirements_size();
  for (const auto& msg : this->_internal_group_requirements()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

  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 PostGroupByTemplateRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostGroupByTemplateRequest*>(
      &from));
}

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

  _this->_internal_mutable_group_requirements()->MergeFrom(from._internal_group_requirements());
  if (!from._internal_group_template_id().empty()) {
    _this->_internal_set_group_template_id(from._internal_group_template_id());
  }
  if (!from._internal_group_title().empty()) {
    _this->_internal_set_group_title(from._internal_group_title());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostGroupByTemplateRequest::InternalSwap(PostGroupByTemplateRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _internal_mutable_group_requirements()->InternalSwap(other->_internal_mutable_group_requirements());
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.group_template_id_, lhs_arena,
                                       &other->_impl_.group_template_id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.group_title_, lhs_arena,
                                       &other->_impl_.group_title_, rhs_arena);
}

std::string PostGroupByTemplateRequest::GetTypeName() const {
  return "keyapis.access_management.v1.PostGroupByTemplateRequest";
}

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

class PostGroupResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::PostGroupResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::ValidationError& validation(const PostGroupResponse_Error* msg);
};

const ::keyapis::access_management::v1::ValidationError&
PostGroupResponse_Error::_Internal::validation(const PostGroupResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PostGroupResponse_Error::set_allocated_validation(::keyapis::access_management::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(validation);
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.PostGroupResponse.Error.validation)
}
PostGroupResponse_Error::PostGroupResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupResponse.Error)
}
PostGroupResponse_Error::PostGroupResponse_Error(const PostGroupResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupResponse_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 kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupResponse.Error)
}

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

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

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

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

void PostGroupResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.PostGroupResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostGroupResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PostGroupResponse.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* PostGroupResponse_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.access_management.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), 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* PostGroupResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PostGroupResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(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.access_management.v1.PostGroupResponse.Error)
  return target;
}

::size_t PostGroupResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PostGroupResponse.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.access_management.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      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 PostGroupResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostGroupResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostGroupResponse_Error::InternalSwap(PostGroupResponse_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 PostGroupResponse_Error::GetTypeName() const {
  return "keyapis.access_management.v1.PostGroupResponse.Error";
}

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

class PostGroupResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::PostGroupResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::Group& data(const PostGroupResponse* msg);
  static const ::keyapis::access_management::v1::PostGroupResponse_Error& error(const PostGroupResponse* msg);
};

const ::keyapis::access_management::v1::Group&
PostGroupResponse::_Internal::data(const PostGroupResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::access_management::v1::PostGroupResponse_Error&
PostGroupResponse::_Internal::error(const PostGroupResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void PostGroupResponse::set_allocated_data(::keyapis::access_management::v1::Group* 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.access_management.v1.PostGroupResponse.data)
}
void PostGroupResponse::set_allocated_error(::keyapis::access_management::v1::PostGroupResponse_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.access_management.v1.PostGroupResponse.error)
}
PostGroupResponse::PostGroupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupResponse)
}
PostGroupResponse::PostGroupResponse(const PostGroupResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupResponse* 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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::PostGroupResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupResponse)
}

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

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

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

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

void PostGroupResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.PostGroupResponse)
  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 PostGroupResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PostGroupResponse)
  ::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* PostGroupResponse::_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.access_management.v1.Group 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.access_management.v1.PostGroupResponse.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* PostGroupResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PostGroupResponse)
  ::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.access_management.v1.PostGroupResponse)
  return target;
}

::size_t PostGroupResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PostGroupResponse)
  ::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.access_management.v1.Group data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.access_management.v1.PostGroupResponse.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 PostGroupResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostGroupResponse*>(
      &from));
}

void PostGroupResponse::MergeFrom(const PostGroupResponse& from) {
  PostGroupResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PostGroupResponse)
  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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::PostGroupResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostGroupResponse::InternalSwap(PostGroupResponse* 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 PostGroupResponse::GetTypeName() const {
  return "keyapis.access_management.v1.PostGroupResponse";
}

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

class PostGroupByTemplateResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::PostGroupByTemplateResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::ValidationError& validation(const PostGroupByTemplateResponse_Error* msg);
  static const ::keyapis::access_management::v1::GroupTemplateNotFoundError& group_template_not_found_error(const PostGroupByTemplateResponse_Error* msg);
};

const ::keyapis::access_management::v1::ValidationError&
PostGroupByTemplateResponse_Error::_Internal::validation(const PostGroupByTemplateResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
const ::keyapis::access_management::v1::GroupTemplateNotFoundError&
PostGroupByTemplateResponse_Error::_Internal::group_template_not_found_error(const PostGroupByTemplateResponse_Error* msg) {
  return *msg->_impl_.reason_.group_template_not_found_error_;
}
void PostGroupByTemplateResponse_Error::set_allocated_validation(::keyapis::access_management::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(validation);
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.PostGroupByTemplateResponse.Error.validation)
}
void PostGroupByTemplateResponse_Error::set_allocated_group_template_not_found_error(::keyapis::access_management::v1::GroupTemplateNotFoundError* group_template_not_found_error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (group_template_not_found_error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(group_template_not_found_error);
    if (message_arena != submessage_arena) {
      group_template_not_found_error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, group_template_not_found_error, submessage_arena);
    }
    set_has_group_template_not_found_error();
    _impl_.reason_.group_template_not_found_error_ = group_template_not_found_error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.PostGroupByTemplateResponse.Error.group_template_not_found_error)
}
PostGroupByTemplateResponse_Error::PostGroupByTemplateResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupByTemplateResponse.Error)
}
PostGroupByTemplateResponse_Error::PostGroupByTemplateResponse_Error(const PostGroupByTemplateResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupByTemplateResponse_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 kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case kGroupTemplateNotFoundError: {
      _this->_internal_mutable_group_template_not_found_error()->::keyapis::access_management::v1::GroupTemplateNotFoundError::MergeFrom(
          from._internal_group_template_not_found_error());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupByTemplateResponse.Error)
}

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

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

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

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

void PostGroupByTemplateResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.PostGroupByTemplateResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case kGroupTemplateNotFoundError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.group_template_not_found_error_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostGroupByTemplateResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PostGroupByTemplateResponse.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* PostGroupByTemplateResponse_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.access_management.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupTemplateNotFoundError group_template_not_found_error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_group_template_not_found_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* PostGroupByTemplateResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PostGroupByTemplateResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::validation(this),
          _Internal::validation(this).GetCachedSize(), target, stream);
      break;
    }
    case kGroupTemplateNotFoundError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::group_template_not_found_error(this),
          _Internal::group_template_not_found_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.access_management.v1.PostGroupByTemplateResponse.Error)
  return target;
}

::size_t PostGroupByTemplateResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PostGroupByTemplateResponse.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.access_management.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    // .keyapis.access_management.v1.GroupTemplateNotFoundError group_template_not_found_error = 2;
    case kGroupTemplateNotFoundError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.group_template_not_found_error_);
      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 PostGroupByTemplateResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostGroupByTemplateResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::access_management::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case kGroupTemplateNotFoundError: {
      _this->_internal_mutable_group_template_not_found_error()->::keyapis::access_management::v1::GroupTemplateNotFoundError::MergeFrom(
          from._internal_group_template_not_found_error());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostGroupByTemplateResponse_Error::InternalSwap(PostGroupByTemplateResponse_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 PostGroupByTemplateResponse_Error::GetTypeName() const {
  return "keyapis.access_management.v1.PostGroupByTemplateResponse.Error";
}

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

class PostGroupByTemplateResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::PostGroupByTemplateResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::Group& data(const PostGroupByTemplateResponse* msg);
  static const ::keyapis::access_management::v1::PostGroupByTemplateResponse_Error& error(const PostGroupByTemplateResponse* msg);
};

const ::keyapis::access_management::v1::Group&
PostGroupByTemplateResponse::_Internal::data(const PostGroupByTemplateResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::access_management::v1::PostGroupByTemplateResponse_Error&
PostGroupByTemplateResponse::_Internal::error(const PostGroupByTemplateResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void PostGroupByTemplateResponse::set_allocated_data(::keyapis::access_management::v1::Group* 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.access_management.v1.PostGroupByTemplateResponse.data)
}
void PostGroupByTemplateResponse::set_allocated_error(::keyapis::access_management::v1::PostGroupByTemplateResponse_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.access_management.v1.PostGroupByTemplateResponse.error)
}
PostGroupByTemplateResponse::PostGroupByTemplateResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupByTemplateResponse)
}
PostGroupByTemplateResponse::PostGroupByTemplateResponse(const PostGroupByTemplateResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupByTemplateResponse* 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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::PostGroupByTemplateResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupByTemplateResponse)
}

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

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

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

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

void PostGroupByTemplateResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.PostGroupByTemplateResponse)
  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 PostGroupByTemplateResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PostGroupByTemplateResponse)
  ::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* PostGroupByTemplateResponse::_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.access_management.v1.Group 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.access_management.v1.PostGroupByTemplateResponse.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* PostGroupByTemplateResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PostGroupByTemplateResponse)
  ::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.access_management.v1.PostGroupByTemplateResponse)
  return target;
}

::size_t PostGroupByTemplateResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PostGroupByTemplateResponse)
  ::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.access_management.v1.Group data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    // .keyapis.access_management.v1.PostGroupByTemplateResponse.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 PostGroupByTemplateResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostGroupByTemplateResponse*>(
      &from));
}

void PostGroupByTemplateResponse::MergeFrom(const PostGroupByTemplateResponse& from) {
  PostGroupByTemplateResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PostGroupByTemplateResponse)
  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::access_management::v1::Group::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::PostGroupByTemplateResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostGroupByTemplateResponse::InternalSwap(PostGroupByTemplateResponse* 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 PostGroupByTemplateResponse::GetTypeName() const {
  return "keyapis.access_management.v1.PostGroupByTemplateResponse";
}

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

class DeleteGroupRequest::_Internal {
 public:
};

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

    , /*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());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.DeleteGroupRequest)
}

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

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

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

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

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

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

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

const char* DeleteGroupRequest::_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;
      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* DeleteGroupRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.DeleteGroupRequest)
  ::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.access_management.v1.DeleteGroupRequest.id");
    target = stream->WriteStringMaybeAliased(1, _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.access_management.v1.DeleteGroupRequest)
  return target;
}

::size_t DeleteGroupRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.DeleteGroupRequest)
  ::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());
  }

  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 DeleteGroupRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteGroupRequest*>(
      &from));
}

void DeleteGroupRequest::MergeFrom(const DeleteGroupRequest& from) {
  DeleteGroupRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.DeleteGroupRequest)
  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());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void DeleteGroupRequest::InternalSwap(DeleteGroupRequest* 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);
}

std::string DeleteGroupRequest::GetTypeName() const {
  return "keyapis.access_management.v1.DeleteGroupRequest";
}

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

class DeleteGroupResponse::_Internal {
 public:
};

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

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

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

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

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

void DeleteGroupResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.DeleteGroupResponse)
  ::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* DeleteGroupResponse::_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* DeleteGroupResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.DeleteGroupResponse)
  ::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.access_management.v1.DeleteGroupResponse)
  return target;
}

::size_t DeleteGroupResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.DeleteGroupResponse)
  ::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 DeleteGroupResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteGroupResponse*>(
      &from));
}

void DeleteGroupResponse::MergeFrom(const DeleteGroupResponse& from) {
  DeleteGroupResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.DeleteGroupResponse)
  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 DeleteGroupResponse::CopyFrom(const DeleteGroupResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_management.v1.DeleteGroupResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string DeleteGroupResponse::GetTypeName() const {
  return "keyapis.access_management.v1.DeleteGroupResponse";
}

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

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

const ::keyapis::access_management::v1::UserGroup&
PutGroupUserAttachRequest::_Internal::user_group(const PutGroupUserAttachRequest* msg) {
  return *msg->_impl_.user_group_;
}
PutGroupUserAttachRequest::PutGroupUserAttachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PutGroupUserAttachRequest)
}
PutGroupUserAttachRequest::PutGroupUserAttachRequest(const PutGroupUserAttachRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutGroupUserAttachRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.user_group_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.user_group_ = new ::keyapis::access_management::v1::UserGroup(*from._impl_.user_group_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PutGroupUserAttachRequest)
}

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

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

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

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

void PutGroupUserAttachRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PutGroupUserAttachRequest)
  ::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_.user_group_ != nullptr);
    _impl_.user_group_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PutGroupUserAttachRequest::_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.access_management.v1.UserGroup user_group = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_group(), 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* PutGroupUserAttachRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupUserAttachRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.UserGroup user_group = 1 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::user_group(this),
        _Internal::user_group(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.access_management.v1.PutGroupUserAttachRequest)
  return target;
}

::size_t PutGroupUserAttachRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupUserAttachRequest)
  ::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.access_management.v1.UserGroup user_group = 1 [(.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_.user_group_);
  }

  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 PutGroupUserAttachRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupUserAttachRequest*>(
      &from));
}

void PutGroupUserAttachRequest::MergeFrom(const PutGroupUserAttachRequest& from) {
  PutGroupUserAttachRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PutGroupUserAttachRequest)
  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_user_group()->::keyapis::access_management::v1::UserGroup::MergeFrom(
        from._internal_user_group());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PutGroupUserAttachRequest::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupUserAttachRequest";
}

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

class PutGroupUserAttachResponse::_Internal {
 public:
};

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

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

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

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

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

void PutGroupUserAttachResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PutGroupUserAttachResponse)
  ::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* PutGroupUserAttachResponse::_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* PutGroupUserAttachResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupUserAttachResponse)
  ::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.access_management.v1.PutGroupUserAttachResponse)
  return target;
}

::size_t PutGroupUserAttachResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupUserAttachResponse)
  ::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 PutGroupUserAttachResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupUserAttachResponse*>(
      &from));
}

void PutGroupUserAttachResponse::MergeFrom(const PutGroupUserAttachResponse& from) {
  PutGroupUserAttachResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PutGroupUserAttachResponse)
  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 PutGroupUserAttachResponse::CopyFrom(const PutGroupUserAttachResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_management.v1.PutGroupUserAttachResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string PutGroupUserAttachResponse::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupUserAttachResponse";
}

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

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

const ::keyapis::access_management::v1::UserGroup&
PutGroupUserDetachRequest::_Internal::user_group(const PutGroupUserDetachRequest* msg) {
  return *msg->_impl_.user_group_;
}
PutGroupUserDetachRequest::PutGroupUserDetachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PutGroupUserDetachRequest)
}
PutGroupUserDetachRequest::PutGroupUserDetachRequest(const PutGroupUserDetachRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutGroupUserDetachRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.user_group_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.user_group_ = new ::keyapis::access_management::v1::UserGroup(*from._impl_.user_group_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PutGroupUserDetachRequest)
}

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

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

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

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

void PutGroupUserDetachRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PutGroupUserDetachRequest)
  ::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_.user_group_ != nullptr);
    _impl_.user_group_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PutGroupUserDetachRequest::_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.access_management.v1.UserGroup user_group = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_group(), 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* PutGroupUserDetachRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupUserDetachRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.UserGroup user_group = 1 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::user_group(this),
        _Internal::user_group(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.access_management.v1.PutGroupUserDetachRequest)
  return target;
}

::size_t PutGroupUserDetachRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupUserDetachRequest)
  ::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.access_management.v1.UserGroup user_group = 1 [(.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_.user_group_);
  }

  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 PutGroupUserDetachRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupUserDetachRequest*>(
      &from));
}

void PutGroupUserDetachRequest::MergeFrom(const PutGroupUserDetachRequest& from) {
  PutGroupUserDetachRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PutGroupUserDetachRequest)
  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_user_group()->::keyapis::access_management::v1::UserGroup::MergeFrom(
        from._internal_user_group());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PutGroupUserDetachRequest::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupUserDetachRequest";
}

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

class GetGroupUserListRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetGroupUserListRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetGroupUserListRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupUserListRequest, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::GroupUserFilter& filter(const GetGroupUserListRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::access_management::v1::GroupUserPaging& paging(const GetGroupUserListRequest* msg);
};

const ::keyapis::access_management::v1::GroupUserFilter&
GetGroupUserListRequest::_Internal::filter(const GetGroupUserListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::access_management::v1::GroupUserPaging&
GetGroupUserListRequest::_Internal::paging(const GetGroupUserListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetGroupUserListRequest::set_allocated_paging(::keyapis::access_management::v1::GroupUserPaging* paging) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_pagination();
  if (paging) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paging);
    if (message_arena != submessage_arena) {
      paging = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paging, submessage_arena);
    }
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupUserListRequest.paging)
}
GetGroupUserListRequest::GetGroupUserListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupUserListRequest)
}
GetGroupUserListRequest::GetGroupUserListRequest(const GetGroupUserListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupUserListRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupUserFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupUserPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupUserListRequest)
}

inline void GetGroupUserListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_pagination();
}

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

inline void GetGroupUserListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
  if (has_pagination()) {
    clear_pagination();
  }
}

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

void GetGroupUserListRequest::clear_pagination() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupUserListRequest)
  switch (pagination_case()) {
    case kPaging: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.pagination_.paging_;
      }
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}


void GetGroupUserListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupUserListRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  clear_pagination();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupUserListRequest::_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.access_management.v1.GroupUserFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupUserPaging paging = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_paging(), 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* GetGroupUserListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupUserListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupUserFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  // .keyapis.access_management.v1.GroupUserPaging paging = 2;
  if (pagination_case() == kPaging) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::paging(this),
        _Internal::paging(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.access_management.v1.GetGroupUserListRequest)
  return target;
}

::size_t GetGroupUserListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupUserListRequest)
  ::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.access_management.v1.GroupUserFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  switch (pagination_case()) {
    // .keyapis.access_management.v1.GroupUserPaging paging = 2;
    case kPaging: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.pagination_.paging_);
      break;
    }
    case PAGINATION_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 GetGroupUserListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupUserListRequest*>(
      &from));
}

void GetGroupUserListRequest::MergeFrom(const GetGroupUserListRequest& from) {
  GetGroupUserListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupUserListRequest)
  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_filter()->::keyapis::access_management::v1::GroupUserFilter::MergeFrom(
        from._internal_filter());
  }
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupUserPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupUserListRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupUserListRequest";
}

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

class GroupUserPaging::_Internal {
 public:
};

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

inline void GroupUserPaging::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.order_by_type_) { 0 }

    , decltype(_impl_.direction_type_) { 0 }

    , decltype(_impl_.limit_) { 0 }

    , decltype(_impl_.offset_) { 0 }

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

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

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

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

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

  ::memset(&_impl_.order_by_type_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.offset_) -
      reinterpret_cast<char*>(&_impl_.order_by_type_)) + sizeof(_impl_.offset_));
  _internal_metadata_.Clear<std::string>();
}

const char* GroupUserPaging::_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.access_management.v1.GroupUserPaging.OrderByType order_by_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_order_by_type(static_cast<::keyapis::access_management::v1::GroupUserPaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupUserPaging.DirectionType direction_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_direction_type(static_cast<::keyapis::access_management::v1::GroupUserPaging_DirectionType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 limit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 offset = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.offset_ = ::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* GroupUserPaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupUserPaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.GroupUserPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_order_by_type(), target);
  }

  // .keyapis.access_management.v1.GroupUserPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_direction_type(), target);
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_limit(), target);
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        4, this->_internal_offset(), 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.access_management.v1.GroupUserPaging)
  return target;
}

::size_t GroupUserPaging::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GroupUserPaging)
  ::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.access_management.v1.GroupUserPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_order_by_type());
  }

  // .keyapis.access_management.v1.GroupUserPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_direction_type());
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_limit());
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_offset());
  }

  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 GroupUserPaging::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupUserPaging*>(
      &from));
}

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

  if (from._internal_order_by_type() != 0) {
    _this->_internal_set_order_by_type(from._internal_order_by_type());
  }
  if (from._internal_direction_type() != 0) {
    _this->_internal_set_direction_type(from._internal_direction_type());
  }
  if (from._internal_limit() != 0) {
    _this->_internal_set_limit(from._internal_limit());
  }
  if (from._internal_offset() != 0) {
    _this->_internal_set_offset(from._internal_offset());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GroupUserPaging::InternalSwap(GroupUserPaging* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GroupUserPaging, _impl_.offset_)
      + sizeof(GroupUserPaging::_impl_.offset_)
      - PROTOBUF_FIELD_OFFSET(GroupUserPaging, _impl_.order_by_type_)>(
          reinterpret_cast<char*>(&_impl_.order_by_type_),
          reinterpret_cast<char*>(&other->_impl_.order_by_type_));
}

std::string GroupUserPaging::GetTypeName() const {
  return "keyapis.access_management.v1.GroupUserPaging";
}

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

class GroupUserFilter::_Internal {
 public:
};

GroupUserFilter::GroupUserFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupUserFilter)
}
GroupUserFilter::GroupUserFilter(const GroupUserFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GroupUserFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.group_ids_){from._impl_.group_ids_}
    , decltype(_impl_.user_ids_){from._impl_.user_ids_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupUserFilter)
}

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

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

inline void GroupUserFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_group_ids()->~RepeatedPtrField();
  _internal_mutable_user_ids()->~RepeatedPtrField();
}

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

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

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

const char* GroupUserFilter::_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) {
      // repeated string group_ids = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_group_ids();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string user_ids = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_user_ids();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* GroupUserFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupUserFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string group_ids = 1;
  for (int i = 0, n = this->_internal_group_ids_size(); i < n; ++i) {
    const auto& s = this->_internal_group_ids(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupUserFilter.group_ids");
    target = stream->WriteString(1, s, target);
  }

  // repeated string user_ids = 2;
  for (int i = 0, n = this->_internal_user_ids_size(); i < n; ++i) {
    const auto& s = this->_internal_user_ids(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupUserFilter.user_ids");
    target = stream->WriteString(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.access_management.v1.GroupUserFilter)
  return target;
}

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

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

  // repeated string group_ids = 1;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_group_ids().size());
  for (int i = 0, n = _internal_group_ids().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_group_ids().Get(i));
  }

  // repeated string user_ids = 2;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_user_ids().size());
  for (int i = 0, n = _internal_user_ids().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_user_ids().Get(i));
  }

  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 GroupUserFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupUserFilter*>(
      &from));
}

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

  _this->_internal_mutable_group_ids()->MergeFrom(from._internal_group_ids());
  _this->_internal_mutable_user_ids()->MergeFrom(from._internal_user_ids());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GroupUserFilter::GetTypeName() const {
  return "keyapis.access_management.v1.GroupUserFilter";
}

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

class GetGroupUserListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupUserListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::UserGroup& data(const GetGroupUserListResponse* msg);
};

const ::keyapis::access_management::v1::UserGroup&
GetGroupUserListResponse::_Internal::data(const GetGroupUserListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetGroupUserListResponse::set_allocated_data(::keyapis::access_management::v1::UserGroup* 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.access_management.v1.GetGroupUserListResponse.data)
}
GetGroupUserListResponse::GetGroupUserListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupUserListResponse)
}
GetGroupUserListResponse::GetGroupUserListResponse(const GetGroupUserListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupUserListResponse* 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::access_management::v1::UserGroup::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupUserListResponse)
}

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

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

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

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

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


void GetGroupUserListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupUserListResponse)
  ::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* GetGroupUserListResponse::_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.access_management.v1.UserGroup 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;
      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* GetGroupUserListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupUserListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.UserGroup data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(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.access_management.v1.GetGroupUserListResponse)
  return target;
}

::size_t GetGroupUserListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupUserListResponse)
  ::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.access_management.v1.UserGroup data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      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 GetGroupUserListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupUserListResponse*>(
      &from));
}

void GetGroupUserListResponse::MergeFrom(const GetGroupUserListResponse& from) {
  GetGroupUserListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupUserListResponse)
  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::access_management::v1::UserGroup::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupUserListResponse::InternalSwap(GetGroupUserListResponse* 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 GetGroupUserListResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupUserListResponse";
}

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

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

const ::keyapis::access_management::v1::GroupUserFilter&
GetGroupUserCountRequest::_Internal::filter(const GetGroupUserCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetGroupUserCountRequest::GetGroupUserCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupUserCountRequest)
}
GetGroupUserCountRequest::GetGroupUserCountRequest(const GetGroupUserCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupUserCountRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupUserFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupUserCountRequest)
}

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

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

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

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

void GetGroupUserCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupUserCountRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupUserCountRequest::_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.access_management.v1.GroupUserFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), 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* GetGroupUserCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupUserCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupUserFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(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.access_management.v1.GetGroupUserCountRequest)
  return target;
}

::size_t GetGroupUserCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupUserCountRequest)
  ::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.access_management.v1.GroupUserFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  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 GetGroupUserCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupUserCountRequest*>(
      &from));
}

void GetGroupUserCountRequest::MergeFrom(const GetGroupUserCountRequest& from) {
  GetGroupUserCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupUserCountRequest)
  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_filter()->::keyapis::access_management::v1::GroupUserFilter::MergeFrom(
        from._internal_filter());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupUserCountRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupUserCountRequest";
}

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

class GetGroupUserCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupUserCountResponse, _impl_._oneof_case_);
};

GetGroupUserCountResponse::GetGroupUserCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupUserCountResponse)
}
GetGroupUserCountResponse::GetGroupUserCountResponse(const GetGroupUserCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupUserCountResponse* 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_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupUserCountResponse)
}

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

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

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

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

void GetGroupUserCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupUserCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetGroupUserCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupUserCountResponse)
  ::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* GetGroupUserCountResponse::_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) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::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* GetGroupUserCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupUserCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), 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.access_management.v1.GetGroupUserCountResponse)
  return target;
}

::size_t GetGroupUserCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupUserCountResponse)
  ::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()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      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 GetGroupUserCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupUserCountResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupUserCountResponse::InternalSwap(GetGroupUserCountResponse* 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 GetGroupUserCountResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupUserCountResponse";
}

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

class PutGroupUserDetachResponse::_Internal {
 public:
};

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

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

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

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

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

void PutGroupUserDetachResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.PutGroupUserDetachResponse)
  ::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* PutGroupUserDetachResponse::_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* PutGroupUserDetachResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.PutGroupUserDetachResponse)
  ::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.access_management.v1.PutGroupUserDetachResponse)
  return target;
}

::size_t PutGroupUserDetachResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.PutGroupUserDetachResponse)
  ::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 PutGroupUserDetachResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutGroupUserDetachResponse*>(
      &from));
}

void PutGroupUserDetachResponse::MergeFrom(const PutGroupUserDetachResponse& from) {
  PutGroupUserDetachResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.PutGroupUserDetachResponse)
  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 PutGroupUserDetachResponse::CopyFrom(const PutGroupUserDetachResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_management.v1.PutGroupUserDetachResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string PutGroupUserDetachResponse::GetTypeName() const {
  return "keyapis.access_management.v1.PutGroupUserDetachResponse";
}

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

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

const ::keyapis::access_management::v1::GroupClaimFilter&
GetGroupClaimCountRequest::_Internal::filter(const GetGroupClaimCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetGroupClaimCountRequest::GetGroupClaimCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimCountRequest)
}
GetGroupClaimCountRequest::GetGroupClaimCountRequest(const GetGroupClaimCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimCountRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupClaimFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimCountRequest)
}

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

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

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

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

void GetGroupClaimCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimCountRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupClaimCountRequest::_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.access_management.v1.GroupClaimFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), 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* GetGroupClaimCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupClaimFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(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.access_management.v1.GetGroupClaimCountRequest)
  return target;
}

::size_t GetGroupClaimCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimCountRequest)
  ::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.access_management.v1.GroupClaimFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  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 GetGroupClaimCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimCountRequest*>(
      &from));
}

void GetGroupClaimCountRequest::MergeFrom(const GetGroupClaimCountRequest& from) {
  GetGroupClaimCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupClaimCountRequest)
  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_filter()->::keyapis::access_management::v1::GroupClaimFilter::MergeFrom(
        from._internal_filter());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupClaimCountRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimCountRequest";
}

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

class GetGroupClaimCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupClaimCountResponse, _impl_._oneof_case_);
};

GetGroupClaimCountResponse::GetGroupClaimCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimCountResponse)
}
GetGroupClaimCountResponse::GetGroupClaimCountResponse(const GetGroupClaimCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimCountResponse* 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_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimCountResponse)
}

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

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

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

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

void GetGroupClaimCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupClaimCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetGroupClaimCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimCountResponse)
  ::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* GetGroupClaimCountResponse::_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) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::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* GetGroupClaimCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), 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.access_management.v1.GetGroupClaimCountResponse)
  return target;
}

::size_t GetGroupClaimCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimCountResponse)
  ::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()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      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 GetGroupClaimCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimCountResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupClaimCountResponse::InternalSwap(GetGroupClaimCountResponse* 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 GetGroupClaimCountResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimCountResponse";
}

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

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

const ::keyapis::access_management::v1::GroupClaimFilter&
GetGroupClaimExistRequest::_Internal::filter(const GetGroupClaimExistRequest* msg) {
  return *msg->_impl_.filter_;
}
GetGroupClaimExistRequest::GetGroupClaimExistRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimExistRequest)
}
GetGroupClaimExistRequest::GetGroupClaimExistRequest(const GetGroupClaimExistRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimExistRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupClaimFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimExistRequest)
}

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

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

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

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

void GetGroupClaimExistRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimExistRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupClaimExistRequest::_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.access_management.v1.GroupClaimFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), 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* GetGroupClaimExistRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimExistRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupClaimFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(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.access_management.v1.GetGroupClaimExistRequest)
  return target;
}

::size_t GetGroupClaimExistRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimExistRequest)
  ::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.access_management.v1.GroupClaimFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  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 GetGroupClaimExistRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimExistRequest*>(
      &from));
}

void GetGroupClaimExistRequest::MergeFrom(const GetGroupClaimExistRequest& from) {
  GetGroupClaimExistRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupClaimExistRequest)
  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_filter()->::keyapis::access_management::v1::GroupClaimFilter::MergeFrom(
        from._internal_filter());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupClaimExistRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimExistRequest";
}

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

class GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::_Internal {
 public:
};

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

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

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

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

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

void GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError)
  ::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* GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::_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* GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError)
  ::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.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError)
  return target;
}

::size_t GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError)
  ::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 GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimExistResponse_Error_ClaimFilterEmptyError*>(
      &from));
}

void GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::MergeFrom(const GetGroupClaimExistResponse_Error_ClaimFilterEmptyError& from) {
  GetGroupClaimExistResponse_Error_ClaimFilterEmptyError* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError)
  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 GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::CopyFrom(const GetGroupClaimExistResponse_Error_ClaimFilterEmptyError& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError";
}

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

class GetGroupClaimExistResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupClaimExistResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError& claim_filter_empty(const GetGroupClaimExistResponse_Error* msg);
};

const ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError&
GetGroupClaimExistResponse_Error::_Internal::claim_filter_empty(const GetGroupClaimExistResponse_Error* msg) {
  return *msg->_impl_.reason_.claim_filter_empty_;
}
void GetGroupClaimExistResponse_Error::set_allocated_claim_filter_empty(::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError* claim_filter_empty) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (claim_filter_empty) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(claim_filter_empty);
    if (message_arena != submessage_arena) {
      claim_filter_empty = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, claim_filter_empty, submessage_arena);
    }
    set_has_claim_filter_empty();
    _impl_.reason_.claim_filter_empty_ = claim_filter_empty;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupClaimExistResponse.Error.claim_filter_empty)
}
GetGroupClaimExistResponse_Error::GetGroupClaimExistResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimExistResponse.Error)
}
GetGroupClaimExistResponse_Error::GetGroupClaimExistResponse_Error(const GetGroupClaimExistResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimExistResponse_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 kClaimFilterEmpty: {
      _this->_internal_mutable_claim_filter_empty()->::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::MergeFrom(
          from._internal_claim_filter_empty());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimExistResponse.Error)
}

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

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

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

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

void GetGroupClaimExistResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error)
  switch (reason_case()) {
    case kClaimFilterEmpty: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.claim_filter_empty_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetGroupClaimExistResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimExistResponse.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* GetGroupClaimExistResponse_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.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError claim_filter_empty = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_claim_filter_empty(), 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* GetGroupClaimExistResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimExistResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError claim_filter_empty = 1;
  if (reason_case() == kClaimFilterEmpty) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::claim_filter_empty(this),
        _Internal::claim_filter_empty(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.access_management.v1.GetGroupClaimExistResponse.Error)
  return target;
}

::size_t GetGroupClaimExistResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimExistResponse.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.access_management.v1.GetGroupClaimExistResponse.Error.ClaimFilterEmptyError claim_filter_empty = 1;
    case kClaimFilterEmpty: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.claim_filter_empty_);
      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 GetGroupClaimExistResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimExistResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kClaimFilterEmpty: {
      _this->_internal_mutable_claim_filter_empty()->::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError::MergeFrom(
          from._internal_claim_filter_empty());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupClaimExistResponse_Error::InternalSwap(GetGroupClaimExistResponse_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 GetGroupClaimExistResponse_Error::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimExistResponse.Error";
}

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

class GetGroupClaimExistResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupClaimExistResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error& error(const GetGroupClaimExistResponse* msg);
};

const ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error&
GetGroupClaimExistResponse::_Internal::error(const GetGroupClaimExistResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetGroupClaimExistResponse::set_allocated_error(::keyapis::access_management::v1::GetGroupClaimExistResponse_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.access_management.v1.GetGroupClaimExistResponse.error)
}
GetGroupClaimExistResponse::GetGroupClaimExistResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimExistResponse)
}
GetGroupClaimExistResponse::GetGroupClaimExistResponse(const GetGroupClaimExistResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimExistResponse* 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_set_data(from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_management::v1::GetGroupClaimExistResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimExistResponse)
}

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

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

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

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

void GetGroupClaimExistResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupClaimExistResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetGroupClaimExistResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimExistResponse)
  ::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* GetGroupClaimExistResponse::_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) {
      // bool data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GetGroupClaimExistResponse.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* GetGroupClaimExistResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimExistResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteBoolToArray(
          1, this->_internal_data(), target);
      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.access_management.v1.GetGroupClaimExistResponse)
  return target;
}

::size_t GetGroupClaimExistResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimExistResponse)
  ::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()) {
    // bool data = 1;
    case kData: {
      total_size += 2;
      break;
    }
    // .keyapis.access_management.v1.GetGroupClaimExistResponse.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 GetGroupClaimExistResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimExistResponse*>(
      &from));
}

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

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

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

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

void GetGroupClaimExistResponse::InternalSwap(GetGroupClaimExistResponse* 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 GetGroupClaimExistResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimExistResponse";
}

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

class GetGroupClaimListRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetGroupClaimListRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetGroupClaimListRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupClaimListRequest, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::GroupClaimFilter& filter(const GetGroupClaimListRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::access_management::v1::GroupClaimPaging& paging(const GetGroupClaimListRequest* msg);
};

const ::keyapis::access_management::v1::GroupClaimFilter&
GetGroupClaimListRequest::_Internal::filter(const GetGroupClaimListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::access_management::v1::GroupClaimPaging&
GetGroupClaimListRequest::_Internal::paging(const GetGroupClaimListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetGroupClaimListRequest::set_allocated_paging(::keyapis::access_management::v1::GroupClaimPaging* paging) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_pagination();
  if (paging) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paging);
    if (message_arena != submessage_arena) {
      paging = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paging, submessage_arena);
    }
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.access_management.v1.GetGroupClaimListRequest.paging)
}
GetGroupClaimListRequest::GetGroupClaimListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimListRequest)
}
GetGroupClaimListRequest::GetGroupClaimListRequest(const GetGroupClaimListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimListRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::access_management::v1::GroupClaimFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupClaimPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimListRequest)
}

inline void GetGroupClaimListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_pagination();
}

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

inline void GetGroupClaimListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
  if (has_pagination()) {
    clear_pagination();
  }
}

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

void GetGroupClaimListRequest::clear_pagination() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_management.v1.GetGroupClaimListRequest)
  switch (pagination_case()) {
    case kPaging: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.pagination_.paging_;
      }
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}


void GetGroupClaimListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimListRequest)
  ::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_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  clear_pagination();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetGroupClaimListRequest::_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.access_management.v1.GroupClaimFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupClaimPaging paging = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_paging(), 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* GetGroupClaimListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupClaimFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  // .keyapis.access_management.v1.GroupClaimPaging paging = 2;
  if (pagination_case() == kPaging) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::paging(this),
        _Internal::paging(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.access_management.v1.GetGroupClaimListRequest)
  return target;
}

::size_t GetGroupClaimListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimListRequest)
  ::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.access_management.v1.GroupClaimFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  switch (pagination_case()) {
    // .keyapis.access_management.v1.GroupClaimPaging paging = 2;
    case kPaging: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.pagination_.paging_);
      break;
    }
    case PAGINATION_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 GetGroupClaimListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimListRequest*>(
      &from));
}

void GetGroupClaimListRequest::MergeFrom(const GetGroupClaimListRequest& from) {
  GetGroupClaimListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupClaimListRequest)
  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_filter()->::keyapis::access_management::v1::GroupClaimFilter::MergeFrom(
        from._internal_filter());
  }
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupClaimPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GetGroupClaimListRequest::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimListRequest";
}

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

class GetGroupClaimListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_management::v1::GetGroupClaimListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_management::v1::Claim& data(const GetGroupClaimListResponse* msg);
};

const ::keyapis::access_management::v1::Claim&
GetGroupClaimListResponse::_Internal::data(const GetGroupClaimListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetGroupClaimListResponse::set_allocated_data(::keyapis::access_management::v1::Claim* 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.access_management.v1.GetGroupClaimListResponse.data)
}
GetGroupClaimListResponse::GetGroupClaimListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupClaimListResponse)
}
GetGroupClaimListResponse::GetGroupClaimListResponse(const GetGroupClaimListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupClaimListResponse* 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::access_management::v1::Claim::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupClaimListResponse)
}

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

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

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

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

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


void GetGroupClaimListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GetGroupClaimListResponse)
  ::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* GetGroupClaimListResponse::_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.access_management.v1.Claim 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;
      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* GetGroupClaimListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GetGroupClaimListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.Claim data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(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.access_management.v1.GetGroupClaimListResponse)
  return target;
}

::size_t GetGroupClaimListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GetGroupClaimListResponse)
  ::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.access_management.v1.Claim data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      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 GetGroupClaimListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetGroupClaimListResponse*>(
      &from));
}

void GetGroupClaimListResponse::MergeFrom(const GetGroupClaimListResponse& from) {
  GetGroupClaimListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GetGroupClaimListResponse)
  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::access_management::v1::Claim::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetGroupClaimListResponse::InternalSwap(GetGroupClaimListResponse* 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 GetGroupClaimListResponse::GetTypeName() const {
  return "keyapis.access_management.v1.GetGroupClaimListResponse";
}

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

GroupClaimFilter_ClaimsEntry_DoNotUse::GroupClaimFilter_ClaimsEntry_DoNotUse() {}
GroupClaimFilter_ClaimsEntry_DoNotUse::GroupClaimFilter_ClaimsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void GroupClaimFilter_ClaimsEntry_DoNotUse::MergeFrom(const GroupClaimFilter_ClaimsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}
// ===================================================================

GroupClaimFilter_UserData_ClaimsEntry_DoNotUse::GroupClaimFilter_UserData_ClaimsEntry_DoNotUse() {}
GroupClaimFilter_UserData_ClaimsEntry_DoNotUse::GroupClaimFilter_UserData_ClaimsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void GroupClaimFilter_UserData_ClaimsEntry_DoNotUse::MergeFrom(const GroupClaimFilter_UserData_ClaimsEntry_DoNotUse& other) {
  MergeFromInternal(other);
}
// ===================================================================

class GroupClaimFilter_UserData::_Internal {
 public:
};

GroupClaimFilter_UserData::GroupClaimFilter_UserData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupClaimFilter.UserData)
}
GroupClaimFilter_UserData::GroupClaimFilter_UserData(const GroupClaimFilter_UserData& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GroupClaimFilter_UserData* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      /*decltype(_impl_.claims_)*/{}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.claims_.MergeFrom(from._impl_.claims_);
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupClaimFilter.UserData)
}

inline void GroupClaimFilter_UserData::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_.claims_)*/{::_pbi::ArenaInitialized(), arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

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

inline void GroupClaimFilter_UserData::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.claims_.~MapFieldLite();
}

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

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

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

const char* GroupClaimFilter_UserData::_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) {
      // map<string, string> claims = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&_impl_.claims_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* GroupClaimFilter_UserData::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupClaimFilter.UserData)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // map<string, string> claims = 1;
  if (!this->_internal_claims().empty()) {
    using MapType = ::_pb::Map<std::string, std::string>;
    using WireHelper = GroupClaimFilter_UserData_ClaimsEntry_DoNotUse::Funcs;
    const auto& map_field = this->_internal_claims();
    auto check_utf8 = [](const MapType::value_type& entry) {
      (void)entry;
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.first.data(), static_cast<int>(entry.first.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupClaimFilter.UserData.claims");
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.second.data(), static_cast<int>(entry.second.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupClaimFilter.UserData.claims");
    };

    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
      for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
        target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    } else {
      for (const auto& entry : map_field) {
        target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    }
  }

  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.access_management.v1.GroupClaimFilter.UserData)
  return target;
}

::size_t GroupClaimFilter_UserData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GroupClaimFilter.UserData)
  ::size_t total_size = 0;

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

  // map<string, string> claims = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_claims_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
      it = this->_internal_claims().begin();
      it != this->_internal_claims().end(); ++it) {
    total_size += GroupClaimFilter_UserData_ClaimsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  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 GroupClaimFilter_UserData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupClaimFilter_UserData*>(
      &from));
}

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

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

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

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

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

std::string GroupClaimFilter_UserData::GetTypeName() const {
  return "keyapis.access_management.v1.GroupClaimFilter.UserData";
}

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

class GroupClaimFilter::_Internal {
 public:
  using HasBits = decltype(std::declval<GroupClaimFilter>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GroupClaimFilter, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& user_id(const GroupClaimFilter* msg);
  static void set_has_user_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::access_management::v1::GroupClaimFilter_UserData& user_data(const GroupClaimFilter* msg);
  static void set_has_user_data(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::StringValue&
GroupClaimFilter::_Internal::user_id(const GroupClaimFilter* msg) {
  return *msg->_impl_.user_id_;
}
const ::keyapis::access_management::v1::GroupClaimFilter_UserData&
GroupClaimFilter::_Internal::user_data(const GroupClaimFilter* msg) {
  return *msg->_impl_.user_data_;
}
void GroupClaimFilter::clear_user_id() {
  if (_impl_.user_id_ != nullptr) _impl_.user_id_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
GroupClaimFilter::GroupClaimFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupClaimFilter)
}
GroupClaimFilter::GroupClaimFilter(const GroupClaimFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GroupClaimFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_.claims_)*/{}
    , decltype(_impl_.api_key_hash_) {}

    , decltype(_impl_.user_id_){nullptr}
    , decltype(_impl_.user_data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _this->_impl_.claims_.MergeFrom(from._impl_.claims_);
  _impl_.api_key_hash_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.api_key_hash_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_api_key_hash().empty()) {
    _this->_impl_.api_key_hash_.Set(from._internal_api_key_hash(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.user_id_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.user_id_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.user_data_ = new ::keyapis::access_management::v1::GroupClaimFilter_UserData(*from._impl_.user_data_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupClaimFilter)
}

inline void GroupClaimFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_.claims_)*/{::_pbi::ArenaInitialized(), arena}
    , decltype(_impl_.api_key_hash_) {}

    , decltype(_impl_.user_id_){nullptr}
    , decltype(_impl_.user_data_){nullptr}
  };
  _impl_.api_key_hash_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.api_key_hash_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void GroupClaimFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.claims_.~MapFieldLite();
  _impl_.api_key_hash_.Destroy();
  if (this != internal_default_instance()) delete _impl_.user_id_;
  if (this != internal_default_instance()) delete _impl_.user_data_;
}

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

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

  _impl_.claims_.Clear();
  _impl_.api_key_hash_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.user_id_ != nullptr);
      _impl_.user_id_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.user_data_ != nullptr);
      _impl_.user_data_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GroupClaimFilter::_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) {
      // .google.protobuf.StringValue user_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_id(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // map<string, string> claims = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&_impl_.claims_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupClaimFilter.UserData user_data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_user_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string api_key_hash = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_api_key_hash();
          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:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.StringValue user_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::user_id(this),
        _Internal::user_id(this).GetCachedSize(), target, stream);
  }

  // map<string, string> claims = 2;
  if (!this->_internal_claims().empty()) {
    using MapType = ::_pb::Map<std::string, std::string>;
    using WireHelper = GroupClaimFilter_ClaimsEntry_DoNotUse::Funcs;
    const auto& map_field = this->_internal_claims();
    auto check_utf8 = [](const MapType::value_type& entry) {
      (void)entry;
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.first.data(), static_cast<int>(entry.first.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupClaimFilter.claims");
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          entry.second.data(), static_cast<int>(entry.second.length()),
 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupClaimFilter.claims");
    };

    if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
      for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    } else {
      for (const auto& entry : map_field) {
        target = WireHelper::InternalSerialize(2, entry.first, entry.second, target, stream);
        check_utf8(entry);
      }
    }
  }

  // .keyapis.access_management.v1.GroupClaimFilter.UserData user_data = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::user_data(this),
        _Internal::user_data(this).GetCachedSize(), target, stream);
  }

  // string api_key_hash = 4;
  if (!this->_internal_api_key_hash().empty()) {
    const std::string& _s = this->_internal_api_key_hash();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupClaimFilter.api_key_hash");
    target = stream->WriteStringMaybeAliased(4, _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.access_management.v1.GroupClaimFilter)
  return target;
}

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

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

  // map<string, string> claims = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_claims_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >::const_iterator
      it = this->_internal_claims().begin();
      it != this->_internal_claims().end(); ++it) {
    total_size += GroupClaimFilter_ClaimsEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // string api_key_hash = 4;
  if (!this->_internal_api_key_hash().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_api_key_hash());
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // .google.protobuf.StringValue user_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.user_id_);
    }

    // .keyapis.access_management.v1.GroupClaimFilter.UserData user_data = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.user_data_);
    }

  }
  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 GroupClaimFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupClaimFilter*>(
      &from));
}

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

  _this->_impl_.claims_.MergeFrom(from._impl_.claims_);
  if (!from._internal_api_key_hash().empty()) {
    _this->_internal_set_api_key_hash(from._internal_api_key_hash());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_user_id()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_user_id());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_user_data()->::keyapis::access_management::v1::GroupClaimFilter_UserData::MergeFrom(
          from._internal_user_data());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GroupClaimFilter::InternalSwap(GroupClaimFilter* 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]);
  _impl_.claims_.InternalSwap(&other->_impl_.claims_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.api_key_hash_, lhs_arena,
                                       &other->_impl_.api_key_hash_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GroupClaimFilter, _impl_.user_data_)
      + sizeof(GroupClaimFilter::_impl_.user_data_)
      - PROTOBUF_FIELD_OFFSET(GroupClaimFilter, _impl_.user_id_)>(
          reinterpret_cast<char*>(&_impl_.user_id_),
          reinterpret_cast<char*>(&other->_impl_.user_id_));
}

std::string GroupClaimFilter::GetTypeName() const {
  return "keyapis.access_management.v1.GroupClaimFilter";
}

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

class GroupClaimPaging::_Internal {
 public:
};

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

inline void GroupClaimPaging::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.order_by_type_) { 0 }

    , decltype(_impl_.direction_type_) { 0 }

    , decltype(_impl_.limit_) { 0 }

    , decltype(_impl_.offset_) { 0 }

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

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

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

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

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

  ::memset(&_impl_.order_by_type_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.offset_) -
      reinterpret_cast<char*>(&_impl_.order_by_type_)) + sizeof(_impl_.offset_));
  _internal_metadata_.Clear<std::string>();
}

const char* GroupClaimPaging::_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.access_management.v1.GroupClaimPaging.OrderByType order_by_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_order_by_type(static_cast<::keyapis::access_management::v1::GroupClaimPaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupClaimPaging.DirectionType direction_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_direction_type(static_cast<::keyapis::access_management::v1::GroupClaimPaging_DirectionType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 limit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 offset = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.offset_ = ::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* GroupClaimPaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupClaimPaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.GroupClaimPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_order_by_type(), target);
  }

  // .keyapis.access_management.v1.GroupClaimPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_direction_type(), target);
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_limit(), target);
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        4, this->_internal_offset(), 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.access_management.v1.GroupClaimPaging)
  return target;
}

::size_t GroupClaimPaging::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GroupClaimPaging)
  ::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.access_management.v1.GroupClaimPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_order_by_type());
  }

  // .keyapis.access_management.v1.GroupClaimPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_direction_type());
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_limit());
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_offset());
  }

  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 GroupClaimPaging::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupClaimPaging*>(
      &from));
}

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

  if (from._internal_order_by_type() != 0) {
    _this->_internal_set_order_by_type(from._internal_order_by_type());
  }
  if (from._internal_direction_type() != 0) {
    _this->_internal_set_direction_type(from._internal_direction_type());
  }
  if (from._internal_limit() != 0) {
    _this->_internal_set_limit(from._internal_limit());
  }
  if (from._internal_offset() != 0) {
    _this->_internal_set_offset(from._internal_offset());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GroupClaimPaging::InternalSwap(GroupClaimPaging* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GroupClaimPaging, _impl_.offset_)
      + sizeof(GroupClaimPaging::_impl_.offset_)
      - PROTOBUF_FIELD_OFFSET(GroupClaimPaging, _impl_.order_by_type_)>(
          reinterpret_cast<char*>(&_impl_.order_by_type_),
          reinterpret_cast<char*>(&other->_impl_.order_by_type_));
}

std::string GroupClaimPaging::GetTypeName() const {
  return "keyapis.access_management.v1.GroupClaimPaging";
}

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

class ValidationError::_Internal {
 public:
};

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

    , decltype(_impl_.message_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.path_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.path_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_path().empty()) {
    _this->_impl_.path_.Set(from._internal_path(), _this->GetArenaForAllocation());
  }
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.ValidationError)
}

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

    , decltype(_impl_.message_) {}

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

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

inline void ValidationError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.path_.Destroy();
  _impl_.message_.Destroy();
}

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

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

  _impl_.path_.ClearToEmpty();
  _impl_.message_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* ValidationError::_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 path = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_path();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          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* ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // string message = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_message().empty()) {
    const std::string& _s = this->_internal_message();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.ValidationError.message");
    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.access_management.v1.ValidationError)
  return target;
}

::size_t ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.ValidationError)
  ::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 path = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_path().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_path());
  }

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

  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 ValidationError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ValidationError*>(
      &from));
}

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

  if (!from._internal_path().empty()) {
    _this->_internal_set_path(from._internal_path());
  }
  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string ValidationError::GetTypeName() const {
  return "keyapis.access_management.v1.ValidationError";
}

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

class GroupTemplateNotFoundError::_Internal {
 public:
};

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

    , decltype(_impl_.message_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.group_template_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_template_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_template_id().empty()) {
    _this->_impl_.group_template_id_.Set(from._internal_group_template_id(), _this->GetArenaForAllocation());
  }
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupTemplateNotFoundError)
}

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

    , decltype(_impl_.message_) {}

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

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

inline void GroupTemplateNotFoundError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.group_template_id_.Destroy();
  _impl_.message_.Destroy();
}

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

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

  _impl_.group_template_id_.ClearToEmpty();
  _impl_.message_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* GroupTemplateNotFoundError::_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 group_template_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_group_template_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          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* GroupTemplateNotFoundError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplateNotFoundError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // string message = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_message().empty()) {
    const std::string& _s = this->_internal_message();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.access_management.v1.GroupTemplateNotFoundError.message");
    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.access_management.v1.GroupTemplateNotFoundError)
  return target;
}

::size_t GroupTemplateNotFoundError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GroupTemplateNotFoundError)
  ::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 group_template_id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_group_template_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_group_template_id());
  }

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

  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 GroupTemplateNotFoundError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupTemplateNotFoundError*>(
      &from));
}

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

  if (!from._internal_group_template_id().empty()) {
    _this->_internal_set_group_template_id(from._internal_group_template_id());
  }
  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string GroupTemplateNotFoundError::GetTypeName() const {
  return "keyapis.access_management.v1.GroupTemplateNotFoundError";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace access_management
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupApiKeyCreateRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupApiKeyCreateRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupApiKeyCreateRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupApiKeyCreateResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupApiKeyCreateResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupApiKeyCreateResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupApiKeyDeleteRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupApiKeyDeleteRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupApiKeyDeleteRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupApiKeyDeleteResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupApiKeyDeleteResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupApiKeyDeleteResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::Claim*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::Claim >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::Claim >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::UserGroup*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::UserGroup >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::UserGroup >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::Group*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::Group >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::Group >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupFilter_RequirementsEntry_DoNotUse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupFilter_RequirementsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupFilter_RequirementsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupFilter_ClaimsEntry_DoNotUse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupFilter_ClaimsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupFilter_ClaimsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupFilter*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupPaging*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupByTemplateRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupByTemplateRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupByTemplateRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupByTemplateResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupByTemplateResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupByTemplateResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupByTemplateResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupByTemplateResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupByTemplateResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::DeleteGroupRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::DeleteGroupRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::DeleteGroupRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::DeleteGroupResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::DeleteGroupResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::DeleteGroupResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupUserAttachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupUserAttachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupUserAttachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupUserAttachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupUserAttachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupUserAttachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupUserDetachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupUserDetachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupUserDetachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupUserListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupUserListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupUserListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupUserPaging*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupUserPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupUserPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupUserFilter*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupUserFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupUserFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupUserListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupUserListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupUserListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupUserCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupUserCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupUserCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupUserCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupUserCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupUserCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupUserDetachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupUserDetachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupUserDetachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimExistRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimExistRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimExistRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error_ClaimFilterEmptyError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimExistResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimExistResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimExistResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimExistResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupClaimListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupClaimListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupClaimListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupClaimFilter_ClaimsEntry_DoNotUse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupClaimFilter_ClaimsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupClaimFilter_ClaimsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupClaimFilter_UserData_ClaimsEntry_DoNotUse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupClaimFilter_UserData_ClaimsEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupClaimFilter_UserData_ClaimsEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupClaimFilter_UserData*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupClaimFilter_UserData >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupClaimFilter_UserData >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupClaimFilter*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupClaimFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupClaimFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupClaimPaging*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupClaimPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupClaimPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::ValidationError*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplateNotFoundError*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplateNotFoundError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplateNotFoundError >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"