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

#include "keyapis/access_management/v1/keyapis_access_management_template_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 GroupTemplate::GroupTemplate(
    ::_pbi::ConstantInitialized): _impl_{
    /*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_.group_title_suffix_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateGroupListRequestDefaultTypeInternal _GetGroupTemplateGroupListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateGroupCountRequest::GetGroupTemplateGroupCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetGroupTemplateGroupCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateGroupCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateGroupCountRequestDefaultTypeInternal() {}
  union {
    GetGroupTemplateGroupCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateGroupCountRequestDefaultTypeInternal _GetGroupTemplateGroupCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateGroupCountResponse::GetGroupTemplateGroupCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateGroupCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateGroupCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateGroupCountResponseDefaultTypeInternal() {}
  union {
    GetGroupTemplateGroupCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateGroupCountResponseDefaultTypeInternal _GetGroupTemplateGroupCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupTemplateGroupPaging::GroupTemplateGroupPaging(
    ::_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 GroupTemplateGroupPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupTemplateGroupPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupTemplateGroupPagingDefaultTypeInternal() {}
  union {
    GroupTemplateGroupPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupTemplateGroupPagingDefaultTypeInternal _GroupTemplateGroupPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateGroupListResponse::GetGroupTemplateGroupListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateGroupListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateGroupListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateGroupListResponseDefaultTypeInternal() {}
  union {
    GetGroupTemplateGroupListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateGroupListResponseDefaultTypeInternal _GetGroupTemplateGroupListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupTemplateGroupAttachRequest::PutGroupTemplateGroupAttachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.group_template_group_)*/nullptr} {}
struct PutGroupTemplateGroupAttachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupTemplateGroupAttachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupTemplateGroupAttachRequestDefaultTypeInternal() {}
  union {
    PutGroupTemplateGroupAttachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupTemplateGroupAttachRequestDefaultTypeInternal _PutGroupTemplateGroupAttachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupTemplateGroupAttachResponse::PutGroupTemplateGroupAttachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PutGroupTemplateGroupAttachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupTemplateGroupAttachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupTemplateGroupAttachResponseDefaultTypeInternal() {}
  union {
    PutGroupTemplateGroupAttachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutGroupTemplateGroupAttachResponseDefaultTypeInternal _PutGroupTemplateGroupAttachResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupTemplateGroupDetachRequest::PutGroupTemplateGroupDetachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.group_template_group_)*/nullptr} {}
struct PutGroupTemplateGroupDetachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupTemplateGroupDetachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupTemplateGroupDetachRequestDefaultTypeInternal() {}
  union {
    PutGroupTemplateGroupDetachRequest _instance;
  };
};

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupTemplateGroupDefaultTypeInternal _GroupTemplateGroup_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupTemplateGroupFilter::GroupTemplateGroupFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.group_ids_)*/{}
  , /*decltype(_impl_.group_template_ids_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GroupTemplateGroupFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupTemplateGroupFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupTemplateGroupFilterDefaultTypeInternal() {}
  union {
    GroupTemplateGroupFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupTemplateGroupFilterDefaultTypeInternal _GroupTemplateGroupFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutGroupTemplateGroupDetachResponse::PutGroupTemplateGroupDetachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct PutGroupTemplateGroupDetachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutGroupTemplateGroupDetachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutGroupTemplateGroupDetachResponseDefaultTypeInternal() {}
  union {
    PutGroupTemplateGroupDetachResponse _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateRequestDefaultTypeInternal _GetGroupTemplateRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateResponse_Error::GetGroupTemplateResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupTemplateResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateResponse_ErrorDefaultTypeInternal _GetGroupTemplateResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateResponse::GetGroupTemplateResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateResponseDefaultTypeInternal() {}
  union {
    GetGroupTemplateResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateListRequestDefaultTypeInternal _GetGroupTemplateListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateListResponse_Error::GetGroupTemplateListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupTemplateListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateListResponse_ErrorDefaultTypeInternal _GetGroupTemplateListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateListResponse::GetGroupTemplateListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateListResponseDefaultTypeInternal() {}
  union {
    GetGroupTemplateListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateListResponseDefaultTypeInternal _GetGroupTemplateListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateCountRequest::GetGroupTemplateCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetGroupTemplateCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateCountRequestDefaultTypeInternal() {}
  union {
    GetGroupTemplateCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateCountRequestDefaultTypeInternal _GetGroupTemplateCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateCountResponse_Error::GetGroupTemplateCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetGroupTemplateCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateCountResponse_ErrorDefaultTypeInternal _GetGroupTemplateCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetGroupTemplateCountResponse::GetGroupTemplateCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetGroupTemplateCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetGroupTemplateCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetGroupTemplateCountResponseDefaultTypeInternal() {}
  union {
    GetGroupTemplateCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetGroupTemplateCountResponseDefaultTypeInternal _GetGroupTemplateCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupTemplateFilter::GroupTemplateFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.tags_)*/{}
  , /*decltype(_impl_.text_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupTemplateFilterDefaultTypeInternal _GroupTemplateFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GroupTemplatePaging::GroupTemplatePaging(
    ::_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 GroupTemplatePagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GroupTemplatePagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GroupTemplatePagingDefaultTypeInternal() {}
  union {
    GroupTemplatePaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GroupTemplatePagingDefaultTypeInternal _GroupTemplatePaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupTemplateRequest::PostGroupTemplateRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostGroupTemplateRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupTemplateRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupTemplateRequestDefaultTypeInternal() {}
  union {
    PostGroupTemplateRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupTemplateRequestDefaultTypeInternal _PostGroupTemplateRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupTemplateResponse_Error::PostGroupTemplateResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostGroupTemplateResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupTemplateResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupTemplateResponse_ErrorDefaultTypeInternal() {}
  union {
    PostGroupTemplateResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostGroupTemplateResponse_ErrorDefaultTypeInternal _PostGroupTemplateResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostGroupTemplateResponse::PostGroupTemplateResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostGroupTemplateResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostGroupTemplateResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostGroupTemplateResponseDefaultTypeInternal() {}
  union {
    PostGroupTemplateResponse _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteGroupTemplateRequestDefaultTypeInternal _DeleteGroupTemplateRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteGroupTemplateResponse::DeleteGroupTemplateResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteGroupTemplateResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteGroupTemplateResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteGroupTemplateResponseDefaultTypeInternal() {}
  union {
    DeleteGroupTemplateResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteGroupTemplateResponseDefaultTypeInternal _DeleteGroupTemplateResponse_default_instance_;
}  // namespace v1
}  // namespace access_management
}  // namespace keyapis
namespace keyapis {
namespace access_management {
namespace v1 {
bool GroupTemplateGroupPaging_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>
    GroupTemplateGroupPaging_OrderByType_strings[3] = {};

static const char GroupTemplateGroupPaging_OrderByType_names[] = {
    "GROUP_ID"
    "GROUP_TEMPLATE_ID"
    "ORDER_BY_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GroupTemplateGroupPaging_OrderByType_entries[] =
    {
        {{&GroupTemplateGroupPaging_OrderByType_names[0], 8}, 1},
        {{&GroupTemplateGroupPaging_OrderByType_names[8], 17}, 2},
        {{&GroupTemplateGroupPaging_OrderByType_names[25], 21}, 0},
};

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

const std::string& GroupTemplateGroupPaging_OrderByType_Name(GroupTemplateGroupPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupTemplateGroupPaging_OrderByType_entries, GroupTemplateGroupPaging_OrderByType_entries_by_number,
          3, GroupTemplateGroupPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupTemplateGroupPaging_OrderByType_entries, GroupTemplateGroupPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupTemplateGroupPaging_OrderByType_strings[idx].get();
}

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

constexpr GroupTemplateGroupPaging_OrderByType GroupTemplateGroupPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr GroupTemplateGroupPaging_OrderByType GroupTemplateGroupPaging::GROUP_ID;
constexpr GroupTemplateGroupPaging_OrderByType GroupTemplateGroupPaging::GROUP_TEMPLATE_ID;
constexpr GroupTemplateGroupPaging_OrderByType GroupTemplateGroupPaging::OrderByType_MIN;
constexpr GroupTemplateGroupPaging_OrderByType GroupTemplateGroupPaging::OrderByType_MAX;
constexpr int GroupTemplateGroupPaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupTemplateGroupPaging_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>
    GroupTemplateGroupPaging_DirectionType_strings[3] = {};

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

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

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

const std::string& GroupTemplateGroupPaging_DirectionType_Name(GroupTemplateGroupPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupTemplateGroupPaging_DirectionType_entries, GroupTemplateGroupPaging_DirectionType_entries_by_number,
          3, GroupTemplateGroupPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupTemplateGroupPaging_DirectionType_entries, GroupTemplateGroupPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupTemplateGroupPaging_DirectionType_strings[idx].get();
}

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

constexpr GroupTemplateGroupPaging_DirectionType GroupTemplateGroupPaging::DIRECTION_TYPE_UNKNOWN;
constexpr GroupTemplateGroupPaging_DirectionType GroupTemplateGroupPaging::DESC;
constexpr GroupTemplateGroupPaging_DirectionType GroupTemplateGroupPaging::ASC;
constexpr GroupTemplateGroupPaging_DirectionType GroupTemplateGroupPaging::DirectionType_MIN;
constexpr GroupTemplateGroupPaging_DirectionType GroupTemplateGroupPaging::DirectionType_MAX;
constexpr int GroupTemplateGroupPaging::DirectionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupTemplatePaging_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>
    GroupTemplatePaging_OrderByType_strings[3] = {};

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

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

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

const std::string& GroupTemplatePaging_OrderByType_Name(GroupTemplatePaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupTemplatePaging_OrderByType_entries, GroupTemplatePaging_OrderByType_entries_by_number,
          3, GroupTemplatePaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupTemplatePaging_OrderByType_entries, GroupTemplatePaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupTemplatePaging_OrderByType_strings[idx].get();
}

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

constexpr GroupTemplatePaging_OrderByType GroupTemplatePaging::ORDER_BY_TYPE_UNKNOWN;
constexpr GroupTemplatePaging_OrderByType GroupTemplatePaging::ID;
constexpr GroupTemplatePaging_OrderByType GroupTemplatePaging::TITLE;
constexpr GroupTemplatePaging_OrderByType GroupTemplatePaging::OrderByType_MIN;
constexpr GroupTemplatePaging_OrderByType GroupTemplatePaging::OrderByType_MAX;
constexpr int GroupTemplatePaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool GroupTemplatePaging_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>
    GroupTemplatePaging_DirectionType_strings[3] = {};

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

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

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

const std::string& GroupTemplatePaging_DirectionType_Name(GroupTemplatePaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GroupTemplatePaging_DirectionType_entries, GroupTemplatePaging_DirectionType_entries_by_number,
          3, GroupTemplatePaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GroupTemplatePaging_DirectionType_entries, GroupTemplatePaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GroupTemplatePaging_DirectionType_strings[idx].get();
}

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

constexpr GroupTemplatePaging_DirectionType GroupTemplatePaging::DIRECTION_TYPE_UNKNOWN;
constexpr GroupTemplatePaging_DirectionType GroupTemplatePaging::DESC;
constexpr GroupTemplatePaging_DirectionType GroupTemplatePaging::ASC;
constexpr GroupTemplatePaging_DirectionType GroupTemplatePaging::DirectionType_MIN;
constexpr GroupTemplatePaging_DirectionType GroupTemplatePaging::DirectionType_MAX;
constexpr int GroupTemplatePaging::DirectionType_ARRAYSIZE;

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

class GroupTemplate::_Internal {
 public:
};

void GroupTemplate::clear_claims() {
  _internal_mutable_claims()->Clear();
}
void GroupTemplate::clear_requirements() {
  _internal_mutable_requirements()->Clear();
}
GroupTemplate::GroupTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupTemplate)
}
GroupTemplate::GroupTemplate(const GroupTemplate& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GroupTemplate* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      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_.group_title_suffix_) {}

    , decltype(_impl_.description_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  _impl_.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_.group_title_suffix_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_title_suffix_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_group_title_suffix().empty()) {
    _this->_impl_.group_title_suffix_.Set(from._internal_group_title_suffix(), _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());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupTemplate)
}

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

    , decltype(_impl_.title_) {}

    , decltype(_impl_.group_title_suffix_) {}

    , decltype(_impl_.description_) {}

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _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_.group_title_suffix_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_title_suffix_.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
}

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

inline void GroupTemplate::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_claims()->~RepeatedPtrField();
  _internal_mutable_requirements()->~RepeatedPtrField();
  _internal_mutable_tags()->~RepeatedPtrField();
  _impl_.id_.Destroy();
  _impl_.title_.Destroy();
  _impl_.group_title_suffix_.Destroy();
  _impl_.description_.Destroy();
}

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

void GroupTemplate::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GroupTemplate)
  ::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_.group_title_suffix_.ClearToEmpty();
  _impl_.description_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* GroupTemplate::_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;
      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 group_title_suffix = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_group_title_suffix();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string description = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          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 = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          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<42>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.access_management.v1.Claim requirements = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          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<50>(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:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GroupTemplate::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplate)
  ::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.GroupTemplate.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.GroupTemplate.title");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

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

  // string description = 4;
  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.GroupTemplate.description");
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }

  // repeated .keyapis.access_management.v1.Claim claims = 5;
  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(5, repfield, repfield.GetCachedSize(), target, stream);
  }

  // repeated .keyapis.access_management.v1.Claim requirements = 6;
  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(6, repfield, repfield.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.GroupTemplate.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.GroupTemplate)
  return target;
}

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

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

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

void GroupTemplate::MergeFrom(const GroupTemplate& from) {
  GroupTemplate* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_management.v1.GroupTemplate)
  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_group_title_suffix().empty()) {
    _this->_internal_set_group_title_suffix(from._internal_group_title_suffix());
  }
  if (!from._internal_description().empty()) {
    _this->_internal_set_description(from._internal_description());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GroupTemplate::InternalSwap(GroupTemplate* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _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_.group_title_suffix_, lhs_arena,
                                       &other->_impl_.group_title_suffix_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.description_, lhs_arena,
                                       &other->_impl_.description_, rhs_arena);
}

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

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

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

const ::keyapis::access_management::v1::GroupTemplateGroupFilter&
GetGroupTemplateGroupListRequest::_Internal::filter(const GetGroupTemplateGroupListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::access_management::v1::GroupTemplateGroupPaging&
GetGroupTemplateGroupListRequest::_Internal::paging(const GetGroupTemplateGroupListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetGroupTemplateGroupListRequest::set_allocated_paging(::keyapis::access_management::v1::GroupTemplateGroupPaging* 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.GetGroupTemplateGroupListRequest.paging)
}
GetGroupTemplateGroupListRequest::GetGroupTemplateGroupListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateGroupListRequest)
}
GetGroupTemplateGroupListRequest::GetGroupTemplateGroupListRequest(const GetGroupTemplateGroupListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateGroupListRequest* 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::GroupTemplateGroupFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupTemplateGroupPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupTemplateGroupListRequest)
}

inline void GetGroupTemplateGroupListRequest::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();
}

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupTemplateGroupFilter 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.GroupTemplateGroupPaging 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.GetGroupTemplateGroupListRequest)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::GroupTemplateGroupFilter&
GetGroupTemplateGroupCountRequest::_Internal::filter(const GetGroupTemplateGroupCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetGroupTemplateGroupCountRequest::GetGroupTemplateGroupCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateGroupCountRequest)
}
GetGroupTemplateGroupCountRequest::GetGroupTemplateGroupCountRequest(const GetGroupTemplateGroupCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateGroupCountRequest* 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::GroupTemplateGroupFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupTemplateGroupCountRequest)
}

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupTemplateGroupFilter 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.GetGroupTemplateGroupCountRequest)
  return target;
}

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

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

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

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

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

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

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

GetGroupTemplateGroupCountResponse::GetGroupTemplateGroupCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateGroupCountResponse)
}
GetGroupTemplateGroupCountResponse::GetGroupTemplateGroupCountResponse(const GetGroupTemplateGroupCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateGroupCountResponse* 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.GetGroupTemplateGroupCountResponse)
}

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

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

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

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

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


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

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

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

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

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

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

class GroupTemplateGroupPaging::_Internal {
 public:
};

GroupTemplateGroupPaging::GroupTemplateGroupPaging(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupTemplateGroupPaging)
}
GroupTemplateGroupPaging::GroupTemplateGroupPaging(const GroupTemplateGroupPaging& 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.GroupTemplateGroupPaging)
}

inline void GroupTemplateGroupPaging::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_)*/{}
  };
}

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

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

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

void GroupTemplateGroupPaging::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GroupTemplateGroupPaging)
  ::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* GroupTemplateGroupPaging::_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.GroupTemplateGroupPaging.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::GroupTemplateGroupPaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupTemplateGroupPaging.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::GroupTemplateGroupPaging_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* GroupTemplateGroupPaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplateGroupPaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.GroupTemplateGroupPaging.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.GroupTemplateGroupPaging.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.GroupTemplateGroupPaging)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  // .keyapis.access_management.v1.GroupTemplateGroup 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.GetGroupTemplateGroupListResponse)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class PutGroupTemplateGroupAttachResponse::_Internal {
 public:
};

PutGroupTemplateGroupAttachResponse::PutGroupTemplateGroupAttachResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PutGroupTemplateGroupAttachResponse)
}
PutGroupTemplateGroupAttachResponse::PutGroupTemplateGroupAttachResponse(const PutGroupTemplateGroupAttachResponse& 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.PutGroupTemplateGroupAttachResponse)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class GroupTemplateGroup::_Internal {
 public:
};

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

    , decltype(_impl_.group_template_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());
  }
  _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());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupTemplateGroup)
}

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

    , decltype(_impl_.group_template_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
  _impl_.group_template_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.group_template_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

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

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

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

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

const char* GroupTemplateGroup::_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;
      // string group_template_id = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          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;
      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* GroupTemplateGroup::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplateGroup)
  ::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.GroupTemplateGroup.group_id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // string group_template_id = 2 [(.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.GroupTemplateGroup.group_template_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.GroupTemplateGroup)
  return target;
}

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

  // string group_template_id = 2 [(.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());
  }

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

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

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

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

void GroupTemplateGroup::InternalSwap(GroupTemplateGroup* 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);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.group_template_id_, lhs_arena,
                                       &other->_impl_.group_template_id_, rhs_arena);
}

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

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

class GroupTemplateGroupFilter::_Internal {
 public:
};

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

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

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

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

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

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

void GroupTemplateGroupFilter::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GroupTemplateGroupFilter)
  ::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_group_template_ids()->Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GroupTemplateGroupFilter::_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 group_template_ids = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_group_template_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* GroupTemplateGroupFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplateGroupFilter)
  ::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.GroupTemplateGroupFilter.group_ids");
    target = stream->WriteString(1, s, target);
  }

  // repeated string group_template_ids = 2;
  for (int i = 0, n = this->_internal_group_template_ids_size(); i < n; ++i) {
    const auto& s = this->_internal_group_template_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.GroupTemplateGroupFilter.group_template_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.GroupTemplateGroupFilter)
  return target;
}

::size_t GroupTemplateGroupFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_management.v1.GroupTemplateGroupFilter)
  ::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 group_template_ids = 2;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_group_template_ids().size());
  for (int i = 0, n = _internal_group_template_ids().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_group_template_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 GroupTemplateGroupFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GroupTemplateGroupFilter*>(
      &from));
}

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

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

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

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

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

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

class PutGroupTemplateGroupDetachResponse::_Internal {
 public:
};

PutGroupTemplateGroupDetachResponse::PutGroupTemplateGroupDetachResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PutGroupTemplateGroupDetachResponse)
}
PutGroupTemplateGroupDetachResponse::PutGroupTemplateGroupDetachResponse(const PutGroupTemplateGroupDetachResponse& 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.PutGroupTemplateGroupDetachResponse)
}

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

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

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

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

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

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

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

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

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

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

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

class GetGroupTemplateRequest::_Internal {
 public:
};

GetGroupTemplateRequest::GetGroupTemplateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateRequest)
}
GetGroupTemplateRequest::GetGroupTemplateRequest(const GetGroupTemplateRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateRequest* 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.GetGroupTemplateRequest)
}

inline void GetGroupTemplateRequest::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
}

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

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

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

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::ValidationError&
GetGroupTemplateResponse_Error::_Internal::validation(const GetGroupTemplateResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetGroupTemplateResponse_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(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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.GetGroupTemplateResponse.Error.validation)
}
void GetGroupTemplateResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetGroupTemplateResponse_Error::GetGroupTemplateResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateResponse.Error)
}
GetGroupTemplateResponse_Error::GetGroupTemplateResponse_Error(const GetGroupTemplateResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateResponse_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.GetGroupTemplateResponse.Error)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::GroupTemplateFilter&
GetGroupTemplateListRequest::_Internal::filter(const GetGroupTemplateListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::access_management::v1::GroupTemplatePaging&
GetGroupTemplateListRequest::_Internal::paging(const GetGroupTemplateListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetGroupTemplateListRequest::set_allocated_paging(::keyapis::access_management::v1::GroupTemplatePaging* 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.GetGroupTemplateListRequest.paging)
}
GetGroupTemplateListRequest::GetGroupTemplateListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateListRequest)
}
GetGroupTemplateListRequest::GetGroupTemplateListRequest(const GetGroupTemplateListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateListRequest* 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::GroupTemplateFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::access_management::v1::GroupTemplatePaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupTemplateListRequest)
}

inline void GetGroupTemplateListRequest::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();
}

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupTemplateFilter 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.GroupTemplatePaging 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.GetGroupTemplateListRequest)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::ValidationError&
GetGroupTemplateListResponse_Error::_Internal::validation(const GetGroupTemplateListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetGroupTemplateListResponse_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(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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.GetGroupTemplateListResponse.Error.validation)
}
void GetGroupTemplateListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetGroupTemplateListResponse_Error::GetGroupTemplateListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateListResponse.Error)
}
GetGroupTemplateListResponse_Error::GetGroupTemplateListResponse_Error(const GetGroupTemplateListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateListResponse_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.GetGroupTemplateListResponse.Error)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::GroupTemplateFilter&
GetGroupTemplateCountRequest::_Internal::filter(const GetGroupTemplateCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetGroupTemplateCountRequest::GetGroupTemplateCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateCountRequest)
}
GetGroupTemplateCountRequest::GetGroupTemplateCountRequest(const GetGroupTemplateCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateCountRequest* 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::GroupTemplateFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GetGroupTemplateCountRequest)
}

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupTemplateFilter 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.GetGroupTemplateCountRequest)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::ValidationError&
GetGroupTemplateCountResponse_Error::_Internal::validation(const GetGroupTemplateCountResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetGroupTemplateCountResponse_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(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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.GetGroupTemplateCountResponse.Error.validation)
}
void GetGroupTemplateCountResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetGroupTemplateCountResponse_Error::GetGroupTemplateCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GetGroupTemplateCountResponse.Error)
}
GetGroupTemplateCountResponse_Error::GetGroupTemplateCountResponse_Error(const GetGroupTemplateCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetGroupTemplateCountResponse_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.GetGroupTemplateCountResponse.Error)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class GroupTemplateFilter::_Internal {
 public:
};

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

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _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());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.GroupTemplateFilter)
}

inline void GroupTemplateFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.tags_){arena}
    , decltype(_impl_.text_) {}

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

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

inline void GroupTemplateFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_tags()->~RepeatedPtrField();
  _impl_.text_.Destroy();
}

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

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

  _internal_mutable_tags()->Clear();
  _impl_.text_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* GroupTemplateFilter::_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 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;
      // repeated string tags = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          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<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* GroupTemplateFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplateFilter)
  ::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.GroupTemplateFilter.text");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // repeated string tags = 2;
  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.GroupTemplateFilter.tags");
    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.GroupTemplateFilter)
  return target;
}

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

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

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

  _this->_internal_mutable_tags()->MergeFrom(from._internal_tags());
  if (!from._internal_text().empty()) {
    _this->_internal_set_text(from._internal_text());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

class GroupTemplatePaging::_Internal {
 public:
};

GroupTemplatePaging::GroupTemplatePaging(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.GroupTemplatePaging)
}
GroupTemplatePaging::GroupTemplatePaging(const GroupTemplatePaging& 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.GroupTemplatePaging)
}

inline void GroupTemplatePaging::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_)*/{}
  };
}

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

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

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

void GroupTemplatePaging::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_management.v1.GroupTemplatePaging)
  ::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* GroupTemplatePaging::_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.GroupTemplatePaging.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::GroupTemplatePaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_management.v1.GroupTemplatePaging.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::GroupTemplatePaging_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* GroupTemplatePaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_management.v1.GroupTemplatePaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_management.v1.GroupTemplatePaging.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.GroupTemplatePaging.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.GroupTemplatePaging)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::GroupTemplate&
PostGroupTemplateRequest::_Internal::data(const PostGroupTemplateRequest* msg) {
  return *msg->_impl_.data_;
}
PostGroupTemplateRequest::PostGroupTemplateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupTemplateRequest)
}
PostGroupTemplateRequest::PostGroupTemplateRequest(const PostGroupTemplateRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupTemplateRequest* 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::GroupTemplate(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_management.v1.PostGroupTemplateRequest)
}

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_management.v1.GroupTemplate 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.PostGroupTemplateRequest)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_management::v1::ValidationError&
PostGroupTemplateResponse_Error::_Internal::validation(const PostGroupTemplateResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PostGroupTemplateResponse_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(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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.PostGroupTemplateResponse.Error.validation)
}
void PostGroupTemplateResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
PostGroupTemplateResponse_Error::PostGroupTemplateResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.PostGroupTemplateResponse.Error)
}
PostGroupTemplateResponse_Error::PostGroupTemplateResponse_Error(const PostGroupTemplateResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostGroupTemplateResponse_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.PostGroupTemplateResponse.Error)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class DeleteGroupTemplateRequest::_Internal {
 public:
};

DeleteGroupTemplateRequest::DeleteGroupTemplateRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.DeleteGroupTemplateRequest)
}
DeleteGroupTemplateRequest::DeleteGroupTemplateRequest(const DeleteGroupTemplateRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteGroupTemplateRequest* 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.DeleteGroupTemplateRequest)
}

inline void DeleteGroupTemplateRequest::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
}

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

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

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

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

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

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

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

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

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

class DeleteGroupTemplateResponse::_Internal {
 public:
};

DeleteGroupTemplateResponse::DeleteGroupTemplateResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_management.v1.DeleteGroupTemplateResponse)
}
DeleteGroupTemplateResponse::DeleteGroupTemplateResponse(const DeleteGroupTemplateResponse& 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.DeleteGroupTemplateResponse)
}

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

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

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace access_management
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplate*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplate >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplate >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateGroupListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateGroupListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateGroupListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateGroupCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateGroupCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateGroupCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateGroupCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateGroupCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateGroupCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplateGroupPaging*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplateGroupPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplateGroupPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateGroupListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateGroupListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateGroupListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupTemplateGroupAttachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupTemplateGroupAttachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupTemplateGroupAttachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupTemplateGroupAttachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupTemplateGroupAttachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupTemplateGroupAttachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupTemplateGroupDetachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupTemplateGroupDetachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupTemplateGroupDetachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplateGroup*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplateGroup >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplateGroup >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplateGroupFilter*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplateGroupFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplateGroupFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PutGroupTemplateGroupDetachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PutGroupTemplateGroupDetachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PutGroupTemplateGroupDetachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GetGroupTemplateCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GetGroupTemplateCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GetGroupTemplateCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplateFilter*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplateFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplateFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::GroupTemplatePaging*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::GroupTemplatePaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::GroupTemplatePaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupTemplateRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupTemplateRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupTemplateRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupTemplateResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupTemplateResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupTemplateResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::PostGroupTemplateResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::PostGroupTemplateResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::PostGroupTemplateResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::DeleteGroupTemplateRequest*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::DeleteGroupTemplateRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::DeleteGroupTemplateRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_management::v1::DeleteGroupTemplateResponse*
Arena::CreateMaybeMessage< ::keyapis::access_management::v1::DeleteGroupTemplateResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_management::v1::DeleteGroupTemplateResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
