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

#include "keyapis/access_control/v1/keyapis_access_control_flatgramm_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_control {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR Flatgramm::Flatgramm(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.title_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.id_)*/ 0

  , /*decltype(_impl_.company_id_)*/ 0
} {}
struct FlatgrammDefaultTypeInternal {
  PROTOBUF_CONSTEXPR FlatgrammDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~FlatgrammDefaultTypeInternal() {}
  union {
    Flatgramm _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlatgrammDefaultTypeInternal _Flatgramm_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammRequest::GetFlatgrammRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammRequestDefaultTypeInternal _GetFlatgrammRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammResponse_Error::GetFlatgrammResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammResponse_ErrorDefaultTypeInternal() {}
  union {
    GetFlatgrammResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammResponse_ErrorDefaultTypeInternal _GetFlatgrammResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammResponse::GetFlatgrammResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammListRequestDefaultTypeInternal _GetFlatgrammListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammListResponse_Error::GetFlatgrammListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetFlatgrammListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammListResponse_ErrorDefaultTypeInternal _GetFlatgrammListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammListResponse::GetFlatgrammListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammListResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammListResponseDefaultTypeInternal _GetFlatgrammListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCountRequest::GetFlatgrammCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetFlatgrammCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCountRequestDefaultTypeInternal() {}
  union {
    GetFlatgrammCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCountRequestDefaultTypeInternal _GetFlatgrammCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCountResponse::GetFlatgrammCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCountResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCountResponseDefaultTypeInternal _GetFlatgrammCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FlatgrammFilter::FlatgrammFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.company_ids_)*/ {}
  ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.dc_company_ids_)*/ {}
  ,/* _impl_._dc_company_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.flatgramm_company_relation_types_)*/ {}
  , /*decltype(_impl_._flatgramm_company_relation_types_cached_byte_size_)*/ { 0 }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlatgrammFilterDefaultTypeInternal _FlatgrammFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FlatgrammPaging::FlatgrammPaging(
    ::_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 FlatgrammPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR FlatgrammPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~FlatgrammPagingDefaultTypeInternal() {}
  union {
    FlatgrammPaging _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCompanyRelationListRequestDefaultTypeInternal _GetFlatgrammCompanyRelationListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyCountRequest::GetFlatgrammDcCompanyCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetFlatgrammDcCompanyCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammDcCompanyCountRequestDefaultTypeInternal() {}
  union {
    GetFlatgrammDcCompanyCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammDcCompanyCountRequestDefaultTypeInternal _GetFlatgrammDcCompanyCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationCountRequest::GetFlatgrammCompanyRelationCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetFlatgrammCompanyRelationCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCompanyRelationCountRequestDefaultTypeInternal() {}
  union {
    GetFlatgrammCompanyRelationCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCompanyRelationCountRequestDefaultTypeInternal _GetFlatgrammCompanyRelationCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyCountResponse_Error::GetFlatgrammDcCompanyCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammDcCompanyCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammDcCompanyCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetFlatgrammDcCompanyCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammDcCompanyCountResponse_ErrorDefaultTypeInternal _GetFlatgrammDcCompanyCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyCountResponse::GetFlatgrammDcCompanyCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammDcCompanyCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammDcCompanyCountResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammDcCompanyCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammDcCompanyCountResponseDefaultTypeInternal _GetFlatgrammDcCompanyCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationCountResponse_Error::GetFlatgrammCompanyRelationCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammCompanyRelationCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCompanyRelationCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetFlatgrammCompanyRelationCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCompanyRelationCountResponse_ErrorDefaultTypeInternal _GetFlatgrammCompanyRelationCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationCountResponse::GetFlatgrammCompanyRelationCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammCompanyRelationCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCompanyRelationCountResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammCompanyRelationCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCompanyRelationCountResponseDefaultTypeInternal _GetFlatgrammCompanyRelationCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DcCompanyFlatgrammPaging::DcCompanyFlatgrammPaging(
    ::_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 DcCompanyFlatgrammPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DcCompanyFlatgrammPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DcCompanyFlatgrammPagingDefaultTypeInternal() {}
  union {
    DcCompanyFlatgrammPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DcCompanyFlatgrammPagingDefaultTypeInternal _DcCompanyFlatgrammPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FlatgrammCompanyRelationPaging::FlatgrammCompanyRelationPaging(
    ::_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 FlatgrammCompanyRelationPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR FlatgrammCompanyRelationPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~FlatgrammCompanyRelationPagingDefaultTypeInternal() {}
  union {
    FlatgrammCompanyRelationPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlatgrammCompanyRelationPagingDefaultTypeInternal _FlatgrammCompanyRelationPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyListResponse_Error::GetFlatgrammDcCompanyListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammDcCompanyListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammDcCompanyListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetFlatgrammDcCompanyListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammDcCompanyListResponse_ErrorDefaultTypeInternal _GetFlatgrammDcCompanyListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyListResponse::GetFlatgrammDcCompanyListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammDcCompanyListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammDcCompanyListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammDcCompanyListResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammDcCompanyListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammDcCompanyListResponseDefaultTypeInternal _GetFlatgrammDcCompanyListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationListResponse_Error::GetFlatgrammCompanyRelationListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammCompanyRelationListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCompanyRelationListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetFlatgrammCompanyRelationListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCompanyRelationListResponse_ErrorDefaultTypeInternal _GetFlatgrammCompanyRelationListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationListResponse::GetFlatgrammCompanyRelationListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetFlatgrammCompanyRelationListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetFlatgrammCompanyRelationListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetFlatgrammCompanyRelationListResponseDefaultTypeInternal() {}
  union {
    GetFlatgrammCompanyRelationListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetFlatgrammCompanyRelationListResponseDefaultTypeInternal _GetFlatgrammCompanyRelationListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyAttachRequest::PutFlatgrammDcCompanyAttachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.dc_company_flatgramm_)*/nullptr} {}
struct PutFlatgrammDcCompanyAttachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyAttachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammDcCompanyAttachRequestDefaultTypeInternal() {}
  union {
    PutFlatgrammDcCompanyAttachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammDcCompanyAttachRequestDefaultTypeInternal _PutFlatgrammDcCompanyAttachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationAttachRequest::PutFlatgrammCompanyRelationAttachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.flatgramm_company_relation_)*/nullptr} {}
struct PutFlatgrammCompanyRelationAttachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationAttachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammCompanyRelationAttachRequestDefaultTypeInternal() {}
  union {
    PutFlatgrammCompanyRelationAttachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammCompanyRelationAttachRequestDefaultTypeInternal _PutFlatgrammCompanyRelationAttachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyAttachResponse_Error::PutFlatgrammDcCompanyAttachResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammDcCompanyAttachResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyAttachResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammDcCompanyAttachResponse_ErrorDefaultTypeInternal() {}
  union {
    PutFlatgrammDcCompanyAttachResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammDcCompanyAttachResponse_ErrorDefaultTypeInternal _PutFlatgrammDcCompanyAttachResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyAttachResponse::PutFlatgrammDcCompanyAttachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammDcCompanyAttachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyAttachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammDcCompanyAttachResponseDefaultTypeInternal() {}
  union {
    PutFlatgrammDcCompanyAttachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammDcCompanyAttachResponseDefaultTypeInternal _PutFlatgrammDcCompanyAttachResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationAttachResponse_Error::PutFlatgrammCompanyRelationAttachResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammCompanyRelationAttachResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationAttachResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammCompanyRelationAttachResponse_ErrorDefaultTypeInternal() {}
  union {
    PutFlatgrammCompanyRelationAttachResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammCompanyRelationAttachResponse_ErrorDefaultTypeInternal _PutFlatgrammCompanyRelationAttachResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationAttachResponse::PutFlatgrammCompanyRelationAttachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammCompanyRelationAttachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationAttachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammCompanyRelationAttachResponseDefaultTypeInternal() {}
  union {
    PutFlatgrammCompanyRelationAttachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammCompanyRelationAttachResponseDefaultTypeInternal _PutFlatgrammCompanyRelationAttachResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyDetachRequest::PutFlatgrammDcCompanyDetachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.dc_company_flatgramm_)*/nullptr} {}
struct PutFlatgrammDcCompanyDetachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyDetachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammDcCompanyDetachRequestDefaultTypeInternal() {}
  union {
    PutFlatgrammDcCompanyDetachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammDcCompanyDetachRequestDefaultTypeInternal _PutFlatgrammDcCompanyDetachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationDetachRequest::PutFlatgrammCompanyRelationDetachRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.flatgramm_company_relation_)*/nullptr} {}
struct PutFlatgrammCompanyRelationDetachRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationDetachRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammCompanyRelationDetachRequestDefaultTypeInternal() {}
  union {
    PutFlatgrammCompanyRelationDetachRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammCompanyRelationDetachRequestDefaultTypeInternal _PutFlatgrammCompanyRelationDetachRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DcCompanyFlatgramm::DcCompanyFlatgramm(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.company_id_)*/ 0

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DcCompanyFlatgrammDefaultTypeInternal _DcCompanyFlatgramm_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FlatgrammCompanyRelation::FlatgrammCompanyRelation(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.company_id_)*/ 0

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlatgrammCompanyRelationDefaultTypeInternal _FlatgrammCompanyRelation_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DcCompanyFlatgrammFilter::DcCompanyFlatgrammFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.company_ids_)*/ {}
  ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.flatgramm_ids_)*/ {}
  ,/* _impl_._flatgramm_ids_cached_byte_size_ = */ { 0 }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DcCompanyFlatgrammFilterDefaultTypeInternal _DcCompanyFlatgrammFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR FlatgrammCompanyRelationFilter::FlatgrammCompanyRelationFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.flatgramm_ids_)*/ {}
  ,/* _impl_._flatgramm_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.company_ids_)*/ {}
  ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.flatgramm_company_relation_types_)*/ {}
  , /*decltype(_impl_._flatgramm_company_relation_types_cached_byte_size_)*/ { 0 }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlatgrammCompanyRelationFilterDefaultTypeInternal _FlatgrammCompanyRelationFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyDetachResponse_Error::PutFlatgrammDcCompanyDetachResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammDcCompanyDetachResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyDetachResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammDcCompanyDetachResponse_ErrorDefaultTypeInternal() {}
  union {
    PutFlatgrammDcCompanyDetachResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammDcCompanyDetachResponse_ErrorDefaultTypeInternal _PutFlatgrammDcCompanyDetachResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyDetachResponse::PutFlatgrammDcCompanyDetachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammDcCompanyDetachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammDcCompanyDetachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammDcCompanyDetachResponseDefaultTypeInternal() {}
  union {
    PutFlatgrammDcCompanyDetachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammDcCompanyDetachResponseDefaultTypeInternal _PutFlatgrammDcCompanyDetachResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationDetachResponse_Error::PutFlatgrammCompanyRelationDetachResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammCompanyRelationDetachResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationDetachResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammCompanyRelationDetachResponse_ErrorDefaultTypeInternal() {}
  union {
    PutFlatgrammCompanyRelationDetachResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammCompanyRelationDetachResponse_ErrorDefaultTypeInternal _PutFlatgrammCompanyRelationDetachResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationDetachResponse::PutFlatgrammCompanyRelationDetachResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PutFlatgrammCompanyRelationDetachResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PutFlatgrammCompanyRelationDetachResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PutFlatgrammCompanyRelationDetachResponseDefaultTypeInternal() {}
  union {
    PutFlatgrammCompanyRelationDetachResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutFlatgrammCompanyRelationDetachResponseDefaultTypeInternal _PutFlatgrammCompanyRelationDetachResponse_default_instance_;
}  // namespace v1
}  // namespace access_control
}  // namespace keyapis
namespace keyapis {
namespace access_control {
namespace v1 {
bool FlatgrammPaging_OrderByType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    FlatgrammPaging_OrderByType_strings[5] = {};

static const char FlatgrammPaging_OrderByType_names[] = {
    "CHANGED_AT"
    "CREATED_AT"
    "ID"
    "ORDER_BY_TYPE_UNKNOWN"
    "RANK"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FlatgrammPaging_OrderByType_entries[] =
    {
        {{&FlatgrammPaging_OrderByType_names[0], 10}, 3},
        {{&FlatgrammPaging_OrderByType_names[10], 10}, 2},
        {{&FlatgrammPaging_OrderByType_names[20], 2}, 1},
        {{&FlatgrammPaging_OrderByType_names[22], 21}, 0},
        {{&FlatgrammPaging_OrderByType_names[43], 4}, 4},
};

static const int FlatgrammPaging_OrderByType_entries_by_number[] = {
    3,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    2,  // 1 -> ID
    1,  // 2 -> CREATED_AT
    0,  // 3 -> CHANGED_AT
    4,  // 4 -> RANK
};

const std::string& FlatgrammPaging_OrderByType_Name(FlatgrammPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FlatgrammPaging_OrderByType_entries, FlatgrammPaging_OrderByType_entries_by_number,
          5, FlatgrammPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FlatgrammPaging_OrderByType_entries, FlatgrammPaging_OrderByType_entries_by_number, 5,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : FlatgrammPaging_OrderByType_strings[idx].get();
}

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

constexpr FlatgrammPaging_OrderByType FlatgrammPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr FlatgrammPaging_OrderByType FlatgrammPaging::ID;
constexpr FlatgrammPaging_OrderByType FlatgrammPaging::CREATED_AT;
constexpr FlatgrammPaging_OrderByType FlatgrammPaging::CHANGED_AT;
constexpr FlatgrammPaging_OrderByType FlatgrammPaging::RANK;
constexpr FlatgrammPaging_OrderByType FlatgrammPaging::OrderByType_MIN;
constexpr FlatgrammPaging_OrderByType FlatgrammPaging::OrderByType_MAX;
constexpr int FlatgrammPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& FlatgrammPaging_DirectionType_Name(FlatgrammPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FlatgrammPaging_DirectionType_entries, FlatgrammPaging_DirectionType_entries_by_number,
          3, FlatgrammPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FlatgrammPaging_DirectionType_entries, FlatgrammPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : FlatgrammPaging_DirectionType_strings[idx].get();
}

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

constexpr FlatgrammPaging_DirectionType FlatgrammPaging::DIRECTION_TYPE_UNKNOWN;
constexpr FlatgrammPaging_DirectionType FlatgrammPaging::DESC;
constexpr FlatgrammPaging_DirectionType FlatgrammPaging::ASC;
constexpr FlatgrammPaging_DirectionType FlatgrammPaging::DirectionType_MIN;
constexpr FlatgrammPaging_DirectionType FlatgrammPaging::DirectionType_MAX;
constexpr int FlatgrammPaging::DirectionType_ARRAYSIZE;

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

static const char DcCompanyFlatgrammPaging_OrderByType_names[] = {
    "COMPANY_ID"
    "FLATGRAMM_ID"
    "ORDER_BY_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DcCompanyFlatgrammPaging_OrderByType_entries[] =
    {
        {{&DcCompanyFlatgrammPaging_OrderByType_names[0], 10}, 1},
        {{&DcCompanyFlatgrammPaging_OrderByType_names[10], 12}, 2},
        {{&DcCompanyFlatgrammPaging_OrderByType_names[22], 21}, 0},
};

static const int DcCompanyFlatgrammPaging_OrderByType_entries_by_number[] = {
    2,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> COMPANY_ID
    1,  // 2 -> FLATGRAMM_ID
};

const std::string& DcCompanyFlatgrammPaging_OrderByType_Name(DcCompanyFlatgrammPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DcCompanyFlatgrammPaging_OrderByType_entries, DcCompanyFlatgrammPaging_OrderByType_entries_by_number,
          3, DcCompanyFlatgrammPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DcCompanyFlatgrammPaging_OrderByType_entries, DcCompanyFlatgrammPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DcCompanyFlatgrammPaging_OrderByType_strings[idx].get();
}

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

constexpr DcCompanyFlatgrammPaging_OrderByType DcCompanyFlatgrammPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr DcCompanyFlatgrammPaging_OrderByType DcCompanyFlatgrammPaging::COMPANY_ID;
constexpr DcCompanyFlatgrammPaging_OrderByType DcCompanyFlatgrammPaging::FLATGRAMM_ID;
constexpr DcCompanyFlatgrammPaging_OrderByType DcCompanyFlatgrammPaging::OrderByType_MIN;
constexpr DcCompanyFlatgrammPaging_OrderByType DcCompanyFlatgrammPaging::OrderByType_MAX;
constexpr int DcCompanyFlatgrammPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& DcCompanyFlatgrammPaging_DirectionType_Name(DcCompanyFlatgrammPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DcCompanyFlatgrammPaging_DirectionType_entries, DcCompanyFlatgrammPaging_DirectionType_entries_by_number,
          3, DcCompanyFlatgrammPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DcCompanyFlatgrammPaging_DirectionType_entries, DcCompanyFlatgrammPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DcCompanyFlatgrammPaging_DirectionType_strings[idx].get();
}

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

constexpr DcCompanyFlatgrammPaging_DirectionType DcCompanyFlatgrammPaging::DIRECTION_TYPE_UNKNOWN;
constexpr DcCompanyFlatgrammPaging_DirectionType DcCompanyFlatgrammPaging::DESC;
constexpr DcCompanyFlatgrammPaging_DirectionType DcCompanyFlatgrammPaging::ASC;
constexpr DcCompanyFlatgrammPaging_DirectionType DcCompanyFlatgrammPaging::DirectionType_MIN;
constexpr DcCompanyFlatgrammPaging_DirectionType DcCompanyFlatgrammPaging::DirectionType_MAX;
constexpr int DcCompanyFlatgrammPaging::DirectionType_ARRAYSIZE;

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

static const char FlatgrammCompanyRelationPaging_OrderByType_names[] = {
    "COMPANY_ID"
    "FLATGRAMM_ID"
    "ORDER_BY_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FlatgrammCompanyRelationPaging_OrderByType_entries[] =
    {
        {{&FlatgrammCompanyRelationPaging_OrderByType_names[0], 10}, 1},
        {{&FlatgrammCompanyRelationPaging_OrderByType_names[10], 12}, 2},
        {{&FlatgrammCompanyRelationPaging_OrderByType_names[22], 21}, 0},
};

static const int FlatgrammCompanyRelationPaging_OrderByType_entries_by_number[] = {
    2,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> COMPANY_ID
    1,  // 2 -> FLATGRAMM_ID
};

const std::string& FlatgrammCompanyRelationPaging_OrderByType_Name(FlatgrammCompanyRelationPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FlatgrammCompanyRelationPaging_OrderByType_entries, FlatgrammCompanyRelationPaging_OrderByType_entries_by_number,
          3, FlatgrammCompanyRelationPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FlatgrammCompanyRelationPaging_OrderByType_entries, FlatgrammCompanyRelationPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : FlatgrammCompanyRelationPaging_OrderByType_strings[idx].get();
}

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

constexpr FlatgrammCompanyRelationPaging_OrderByType FlatgrammCompanyRelationPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr FlatgrammCompanyRelationPaging_OrderByType FlatgrammCompanyRelationPaging::COMPANY_ID;
constexpr FlatgrammCompanyRelationPaging_OrderByType FlatgrammCompanyRelationPaging::FLATGRAMM_ID;
constexpr FlatgrammCompanyRelationPaging_OrderByType FlatgrammCompanyRelationPaging::OrderByType_MIN;
constexpr FlatgrammCompanyRelationPaging_OrderByType FlatgrammCompanyRelationPaging::OrderByType_MAX;
constexpr int FlatgrammCompanyRelationPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& FlatgrammCompanyRelationPaging_DirectionType_Name(FlatgrammCompanyRelationPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FlatgrammCompanyRelationPaging_DirectionType_entries, FlatgrammCompanyRelationPaging_DirectionType_entries_by_number,
          3, FlatgrammCompanyRelationPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FlatgrammCompanyRelationPaging_DirectionType_entries, FlatgrammCompanyRelationPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : FlatgrammCompanyRelationPaging_DirectionType_strings[idx].get();
}

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

constexpr FlatgrammCompanyRelationPaging_DirectionType FlatgrammCompanyRelationPaging::DIRECTION_TYPE_UNKNOWN;
constexpr FlatgrammCompanyRelationPaging_DirectionType FlatgrammCompanyRelationPaging::DESC;
constexpr FlatgrammCompanyRelationPaging_DirectionType FlatgrammCompanyRelationPaging::ASC;
constexpr FlatgrammCompanyRelationPaging_DirectionType FlatgrammCompanyRelationPaging::DirectionType_MIN;
constexpr FlatgrammCompanyRelationPaging_DirectionType FlatgrammCompanyRelationPaging::DirectionType_MAX;
constexpr int FlatgrammCompanyRelationPaging::DirectionType_ARRAYSIZE;

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

static const char FlatgrammCompanyRelation_Type_names[] = {
    "DEVICE_SERVICE"
    "MANAGEMENT"
    "TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FlatgrammCompanyRelation_Type_entries[] =
    {
        {{&FlatgrammCompanyRelation_Type_names[0], 14}, 2},
        {{&FlatgrammCompanyRelation_Type_names[14], 10}, 1},
        {{&FlatgrammCompanyRelation_Type_names[24], 12}, 0},
};

static const int FlatgrammCompanyRelation_Type_entries_by_number[] = {
    2,  // 0 -> TYPE_UNKNOWN
    1,  // 1 -> MANAGEMENT
    0,  // 2 -> DEVICE_SERVICE
};

const std::string& FlatgrammCompanyRelation_Type_Name(FlatgrammCompanyRelation_Type value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          FlatgrammCompanyRelation_Type_entries, FlatgrammCompanyRelation_Type_entries_by_number,
          3, FlatgrammCompanyRelation_Type_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      FlatgrammCompanyRelation_Type_entries, FlatgrammCompanyRelation_Type_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : FlatgrammCompanyRelation_Type_strings[idx].get();
}

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

constexpr FlatgrammCompanyRelation_Type FlatgrammCompanyRelation::TYPE_UNKNOWN;
constexpr FlatgrammCompanyRelation_Type FlatgrammCompanyRelation::MANAGEMENT;
constexpr FlatgrammCompanyRelation_Type FlatgrammCompanyRelation::DEVICE_SERVICE;
constexpr FlatgrammCompanyRelation_Type FlatgrammCompanyRelation::Type_MIN;
constexpr FlatgrammCompanyRelation_Type FlatgrammCompanyRelation::Type_MAX;
constexpr int FlatgrammCompanyRelation::Type_ARRAYSIZE;

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

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

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Flatgramm::_Internal::created_at(const Flatgramm* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Flatgramm::_Internal::changed_at(const Flatgramm* msg) {
  return *msg->_impl_.changed_at_;
}
void Flatgramm::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void Flatgramm::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
Flatgramm::Flatgramm(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.Flatgramm)
}
Flatgramm::Flatgramm(const Flatgramm& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Flatgramm* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.title_) {}

    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.company_id_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _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());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  ::memcpy(&_impl_.id_, &from._impl_.id_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.company_id_) -
    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.company_id_));
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.Flatgramm)
}

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

    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.id_) { 0 }

    , decltype(_impl_.company_id_) { 0 }

  };
  _impl_.title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void Flatgramm::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.title_.Destroy();
  if (this != internal_default_instance()) delete _impl_.created_at_;
  if (this != internal_default_instance()) delete _impl_.changed_at_;
}

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

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

  _impl_.title_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
  }
  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.company_id_) -
      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.company_id_));
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Flatgramm::_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) {
      // int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } 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;
      // int32 company_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.company_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 5 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // int32 id = 1;
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), 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_control.v1.Flatgramm.title");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

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

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

  // .google.protobuf.Timestamp changed_at = 5 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::changed_at(this),
        _Internal::changed_at(this).GetCachedSize(), target, stream);
  }

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

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

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // .google.protobuf.Timestamp created_at = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.created_at_);
    }

    // .google.protobuf.Timestamp changed_at = 5 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.changed_at_);
    }

  }
  // int32 id = 1;
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_id());
  }

  // int32 company_id = 3;
  if (this->_internal_company_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_company_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 Flatgramm::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Flatgramm*>(
      &from));
}

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

  if (!from._internal_title().empty()) {
    _this->_internal_set_title(from._internal_title());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  if (from._internal_company_id() != 0) {
    _this->_internal_set_company_id(from._internal_company_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void Flatgramm::InternalSwap(Flatgramm* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.title_, lhs_arena,
                                       &other->_impl_.title_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Flatgramm, _impl_.company_id_)
      + sizeof(Flatgramm::_impl_.company_id_)
      - PROTOBUF_FIELD_OFFSET(Flatgramm, _impl_.created_at_)>(
          reinterpret_cast<char*>(&_impl_.created_at_),
          reinterpret_cast<char*>(&other->_impl_.created_at_));
}

std::string Flatgramm::GetTypeName() const {
  return "keyapis.access_control.v1.Flatgramm";
}

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

class GetFlatgrammRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

const char* GetFlatgrammRequest::_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 id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::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* GetFlatgrammRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), 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_control.v1.GetFlatgrammRequest)
  return target;
}

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

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

  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        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 GetFlatgrammRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetFlatgrammRequest*>(
      &from));
}

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

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

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

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

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

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

std::string GetFlatgrammRequest::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammRequest";
}

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

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

const ::keyapis::access_control::v1::ValidationError&
GetFlatgrammResponse_Error::_Internal::validation(const GetFlatgrammResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetFlatgrammResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.GetFlatgrammResponse.Error.validation)
}
void GetFlatgrammResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetFlatgrammResponse_Error::GetFlatgrammResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetFlatgrammResponse.Error)
}
GetFlatgrammResponse_Error::GetFlatgrammResponse_Error(const GetFlatgrammResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetFlatgrammResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetFlatgrammResponse.Error)
}

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

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

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

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

void GetFlatgrammResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetFlatgrammResponse.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 GetFlatgrammResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammResponse.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* GetFlatgrammResponse_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_control.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* GetFlatgrammResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.GetFlatgrammResponse.Error)
  return target;
}

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

void GetFlatgrammResponse_Error::MergeFrom(const GetFlatgrammResponse_Error& from) {
  GetFlatgrammResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetFlatgrammResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetFlatgrammResponse_Error::InternalSwap(GetFlatgrammResponse_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 GetFlatgrammResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammResponse.Error";
}

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

class GetFlatgrammResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetFlatgrammResponse, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::Flatgramm& data(const GetFlatgrammResponse* msg);
  static const ::keyapis::access_control::v1::GetFlatgrammResponse_Error& error(const GetFlatgrammResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.FlatgrammFilter 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_control.v1.FlatgrammPaging 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_control.v1.GetFlatgrammListRequest)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_control::v1::ValidationError&
GetFlatgrammListResponse_Error::_Internal::validation(const GetFlatgrammListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetFlatgrammListResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.GetFlatgrammListResponse.Error.validation)
}
void GetFlatgrammListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetFlatgrammListResponse_Error::GetFlatgrammListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetFlatgrammListResponse.Error)
}
GetFlatgrammListResponse_Error::GetFlatgrammListResponse_Error(const GetFlatgrammListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetFlatgrammListResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetFlatgrammListResponse.Error)
}

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

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

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

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

void GetFlatgrammListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetFlatgrammListResponse.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 GetFlatgrammListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammListResponse.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* GetFlatgrammListResponse_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_control.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* GetFlatgrammListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.GetFlatgrammListResponse.Error)
  return target;
}

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

void GetFlatgrammListResponse_Error::MergeFrom(const GetFlatgrammListResponse_Error& from) {
  GetFlatgrammListResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetFlatgrammListResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetFlatgrammListResponse_Error::InternalSwap(GetFlatgrammListResponse_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 GetFlatgrammListResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammListResponse.Error";
}

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

class GetFlatgrammListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetFlatgrammListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::Flatgramm& data(const GetFlatgrammListResponse* msg);
  static const ::keyapis::access_control::v1::GetFlatgrammListResponse_Error& error(const GetFlatgrammListResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.FlatgrammFilter 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_control.v1.GetFlatgrammCountRequest)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

class FlatgrammFilter::_Internal {
 public:
};

FlatgrammFilter::FlatgrammFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.FlatgrammFilter)
}
FlatgrammFilter::FlatgrammFilter(const FlatgrammFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  FlatgrammFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.company_ids_) { from._impl_.company_ids_ }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.dc_company_ids_) { from._impl_.dc_company_ids_ }
    ,/* _impl_._dc_company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.flatgramm_company_relation_types_) { from._internal_flatgramm_company_relation_types() }
    , /*decltype(_impl_._flatgramm_company_relation_types_cached_byte_size_)*/ { 0 }

    , 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_control.v1.FlatgrammFilter)
}

inline void FlatgrammFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.company_ids_) { arena }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.dc_company_ids_) { arena }
    ,/* _impl_._dc_company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.flatgramm_company_relation_types_) { arena }
    , /*decltype(_impl_._flatgramm_company_relation_types_cached_byte_size_)*/ { 0 }

    , 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
}

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

inline void FlatgrammFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.company_ids_.~RepeatedField();
  _impl_.dc_company_ids_.~RepeatedField();
  _internal_mutable_flatgramm_company_relation_types()->~RepeatedField();
  _impl_.text_.Destroy();
}

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

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

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

const char* FlatgrammFilter::_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 int32 company_ids = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_company_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          _internal_add_company_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string text = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_text();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 dc_company_ids = 3 [deprecated = true, (.google.api.field_visibility) = {
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_dc_company_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 24) {
          _internal_add_dc_company_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.access_control.v1.FlatgrammCompanyRelation.Type flatgramm_company_relation_types = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_flatgramm_company_relation_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 32) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_flatgramm_company_relation_types(static_cast<::keyapis::access_control::v1::FlatgrammCompanyRelation_Type>(val));
        } 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* FlatgrammFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.FlatgrammFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 company_ids = 1;
  {
    int byte_size = _impl_._company_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(1, _internal_company_ids(),
                                                 byte_size, target);
    }
  }

  // string text = 2;
  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_control.v1.FlatgrammFilter.text");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  // repeated int32 dc_company_ids = 3 [deprecated = true, (.google.api.field_visibility) = {
  {
    int byte_size = _impl_._dc_company_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(3, _internal_dc_company_ids(),
                                                 byte_size, target);
    }
  }

  // repeated .keyapis.access_control.v1.FlatgrammCompanyRelation.Type flatgramm_company_relation_types = 4;
  {
    int byte_size = _impl_._flatgramm_company_relation_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(4, _internal_flatgramm_company_relation_types(),
                                       byte_size, 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_control.v1.FlatgrammFilter)
  return target;
}

::size_t FlatgrammFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.FlatgrammFilter)
  ::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 int32 company_ids = 1;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_company_ids())
    ;
    _impl_._company_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  // repeated int32 dc_company_ids = 3 [deprecated = true, (.google.api.field_visibility) = {
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_dc_company_ids())
    ;
    _impl_._dc_company_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  // repeated .keyapis.access_control.v1.FlatgrammCompanyRelation.Type flatgramm_company_relation_types = 4;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_flatgramm_company_relation_types_size());

    for (std::size_t i = 0; i < count; ++i) {
      data_size += ::_pbi::WireFormatLite::EnumSize(
          this->_internal_flatgramm_company_relation_types(static_cast<int>(i)));
    }
    total_size += data_size;
    if (data_size > 0) {
      total_size += 1;
      total_size += ::_pbi::WireFormatLite::Int32Size(
          static_cast<int32_t>(data_size));
    }
    _impl_._flatgramm_company_relation_types_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
  }

  // string text = 2;
  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 FlatgrammFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const FlatgrammFilter*>(
      &from));
}

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

  _this->_impl_.company_ids_.MergeFrom(from._impl_.company_ids_);
  _this->_impl_.dc_company_ids_.MergeFrom(from._impl_.dc_company_ids_);
  _this->_internal_mutable_flatgramm_company_relation_types()->MergeFrom(from._internal_flatgramm_company_relation_types());
  if (!from._internal_text().empty()) {
    _this->_internal_set_text(from._internal_text());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string FlatgrammFilter::GetTypeName() const {
  return "keyapis.access_control.v1.FlatgrammFilter";
}

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

class FlatgrammPaging::_Internal {
 public:
};

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

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

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

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

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

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

  // .keyapis.access_control.v1.FlatgrammPaging.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_control.v1.FlatgrammPaging.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_control.v1.FlatgrammPaging)
  return target;
}

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

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

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

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

std::string FlatgrammPaging::GetTypeName() const {
  return "keyapis.access_control.v1.FlatgrammPaging";
}

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.DcCompanyFlatgrammFilter 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_control.v1.DcCompanyFlatgrammPaging 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_control.v1.GetFlatgrammDcCompanyListRequest)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.FlatgrammCompanyRelationFilter 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_control.v1.FlatgrammCompanyRelationPaging 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_control.v1.GetFlatgrammCompanyRelationListRequest)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.DcCompanyFlatgrammFilter 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_control.v1.GetFlatgrammDcCompanyCountRequest)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.access_control.v1.FlatgrammCompanyRelationFilter 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_control.v1.GetFlatgrammCompanyRelationCountRequest)
  return target;
}

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

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

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

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

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

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

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

const ::keyapis::access_control::v1::ValidationError&
GetFlatgrammDcCompanyCountResponse_Error::_Internal::validation(const GetFlatgrammDcCompanyCountResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetFlatgrammDcCompanyCountResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.GetFlatgrammDcCompanyCountResponse.Error.validation)
}
void GetFlatgrammDcCompanyCountResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetFlatgrammDcCompanyCountResponse_Error::GetFlatgrammDcCompanyCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.Error)
}
GetFlatgrammDcCompanyCountResponse_Error::GetFlatgrammDcCompanyCountResponse_Error(const GetFlatgrammDcCompanyCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetFlatgrammDcCompanyCountResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.Error)
}

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

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

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

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

void GetFlatgrammDcCompanyCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.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 GetFlatgrammDcCompanyCountResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.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* GetFlatgrammDcCompanyCountResponse_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_control.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* GetFlatgrammDcCompanyCountResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.GetFlatgrammDcCompanyCountResponse.Error)
  return target;
}

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

void GetFlatgrammDcCompanyCountResponse_Error::MergeFrom(const GetFlatgrammDcCompanyCountResponse_Error& from) {
  GetFlatgrammDcCompanyCountResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetFlatgrammDcCompanyCountResponse_Error::InternalSwap(GetFlatgrammDcCompanyCountResponse_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 GetFlatgrammDcCompanyCountResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse.Error";
}

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

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

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

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

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

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

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

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


void GetFlatgrammDcCompanyCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse)
  ::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* GetFlatgrammDcCompanyCountResponse::_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_control.v1.GetFlatgrammDcCompanyCountResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _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* GetFlatgrammDcCompanyCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          2, this->_internal_data(), target);
      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_control.v1.GetFlatgrammDcCompanyCountResponse)
  return target;
}

::size_t GetFlatgrammDcCompanyCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse)
  ::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_control.v1.GetFlatgrammDcCompanyCountResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    // int32 data = 2;
    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 GetFlatgrammDcCompanyCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetFlatgrammDcCompanyCountResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    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 GetFlatgrammDcCompanyCountResponse::CopyFrom(const GetFlatgrammDcCompanyCountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetFlatgrammDcCompanyCountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

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

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

const ::keyapis::access_control::v1::ValidationError&
GetFlatgrammCompanyRelationCountResponse_Error::_Internal::validation(const GetFlatgrammCompanyRelationCountResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetFlatgrammCompanyRelationCountResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.GetFlatgrammCompanyRelationCountResponse.Error.validation)
}
void GetFlatgrammCompanyRelationCountResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetFlatgrammCompanyRelationCountResponse_Error::GetFlatgrammCompanyRelationCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.Error)
}
GetFlatgrammCompanyRelationCountResponse_Error::GetFlatgrammCompanyRelationCountResponse_Error(const GetFlatgrammCompanyRelationCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetFlatgrammCompanyRelationCountResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.Error)
}

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

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

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

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

void GetFlatgrammCompanyRelationCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.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 GetFlatgrammCompanyRelationCountResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.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* GetFlatgrammCompanyRelationCountResponse_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_control.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* GetFlatgrammCompanyRelationCountResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.GetFlatgrammCompanyRelationCountResponse.Error)
  return target;
}

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

void GetFlatgrammCompanyRelationCountResponse_Error::MergeFrom(const GetFlatgrammCompanyRelationCountResponse_Error& from) {
  GetFlatgrammCompanyRelationCountResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetFlatgrammCompanyRelationCountResponse_Error::InternalSwap(GetFlatgrammCompanyRelationCountResponse_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 GetFlatgrammCompanyRelationCountResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse.Error";
}

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

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

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

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

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

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

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

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


void GetFlatgrammCompanyRelationCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse)
  ::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* GetFlatgrammCompanyRelationCountResponse::_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_control.v1.GetFlatgrammCompanyRelationCountResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _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* GetFlatgrammCompanyRelationCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          2, this->_internal_data(), target);
      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_control.v1.GetFlatgrammCompanyRelationCountResponse)
  return target;
}

::size_t GetFlatgrammCompanyRelationCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse)
  ::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_control.v1.GetFlatgrammCompanyRelationCountResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    // int32 data = 2;
    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 GetFlatgrammCompanyRelationCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetFlatgrammCompanyRelationCountResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    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 GetFlatgrammCompanyRelationCountResponse::CopyFrom(const GetFlatgrammCompanyRelationCountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationCountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

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

class DcCompanyFlatgrammPaging::_Internal {
 public:
};

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

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

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

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

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

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

  // .keyapis.access_control.v1.DcCompanyFlatgrammPaging.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_control.v1.DcCompanyFlatgrammPaging.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_control.v1.DcCompanyFlatgrammPaging)
  return target;
}

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

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

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

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

std::string DcCompanyFlatgrammPaging::GetTypeName() const {
  return "keyapis.access_control.v1.DcCompanyFlatgrammPaging";
}

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

class FlatgrammCompanyRelationPaging::_Internal {
 public:
};

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

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

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

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

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

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

  // .keyapis.access_control.v1.FlatgrammCompanyRelationPaging.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_control.v1.FlatgrammCompanyRelationPaging.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_control.v1.FlatgrammCompanyRelationPaging)
  return target;
}

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

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

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

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

std::string FlatgrammCompanyRelationPaging::GetTypeName() const {
  return "keyapis.access_control.v1.FlatgrammCompanyRelationPaging";
}

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

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

const ::keyapis::access_control::v1::ValidationError&
GetFlatgrammDcCompanyListResponse_Error::_Internal::validation(const GetFlatgrammDcCompanyListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetFlatgrammDcCompanyListResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.GetFlatgrammDcCompanyListResponse.Error.validation)
}
void GetFlatgrammDcCompanyListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetFlatgrammDcCompanyListResponse_Error::GetFlatgrammDcCompanyListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.Error)
}
GetFlatgrammDcCompanyListResponse_Error::GetFlatgrammDcCompanyListResponse_Error(const GetFlatgrammDcCompanyListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetFlatgrammDcCompanyListResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.Error)
}

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

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

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

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

void GetFlatgrammDcCompanyListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.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 GetFlatgrammDcCompanyListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.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* GetFlatgrammDcCompanyListResponse_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_control.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* GetFlatgrammDcCompanyListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.GetFlatgrammDcCompanyListResponse.Error)
  return target;
}

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

void GetFlatgrammDcCompanyListResponse_Error::MergeFrom(const GetFlatgrammDcCompanyListResponse_Error& from) {
  GetFlatgrammDcCompanyListResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetFlatgrammDcCompanyListResponse_Error::InternalSwap(GetFlatgrammDcCompanyListResponse_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 GetFlatgrammDcCompanyListResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse.Error";
}

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

class GetFlatgrammDcCompanyListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse_Error& error(const GetFlatgrammDcCompanyListResponse* msg);
  static const ::keyapis::access_control::v1::DcCompanyFlatgramm& data(const GetFlatgrammDcCompanyListResponse* msg);
};

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

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

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

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

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

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


void GetFlatgrammDcCompanyListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse)
  ::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* GetFlatgrammDcCompanyListResponse::_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_control.v1.GetFlatgrammDcCompanyListResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_control.v1.DcCompanyFlatgramm data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          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* GetFlatgrammDcCompanyListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::data(this),
          _Internal::data(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_control.v1.GetFlatgrammDcCompanyListResponse)
  return target;
}

::size_t GetFlatgrammDcCompanyListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetFlatgrammDcCompanyListResponse)
  ::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_control.v1.GetFlatgrammDcCompanyListResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    // .keyapis.access_control.v1.DcCompanyFlatgramm data = 2;
    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 GetFlatgrammDcCompanyListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetFlatgrammDcCompanyListResponse*>(
      &from));
}

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

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

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

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

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

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

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

const ::keyapis::access_control::v1::ValidationError&
GetFlatgrammCompanyRelationListResponse_Error::_Internal::validation(const GetFlatgrammCompanyRelationListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetFlatgrammCompanyRelationListResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.GetFlatgrammCompanyRelationListResponse.Error.validation)
}
void GetFlatgrammCompanyRelationListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetFlatgrammCompanyRelationListResponse_Error::GetFlatgrammCompanyRelationListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.Error)
}
GetFlatgrammCompanyRelationListResponse_Error::GetFlatgrammCompanyRelationListResponse_Error(const GetFlatgrammCompanyRelationListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetFlatgrammCompanyRelationListResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.Error)
}

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

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

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

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

void GetFlatgrammCompanyRelationListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.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 GetFlatgrammCompanyRelationListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.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* GetFlatgrammCompanyRelationListResponse_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_control.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* GetFlatgrammCompanyRelationListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.GetFlatgrammCompanyRelationListResponse.Error)
  return target;
}

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

void GetFlatgrammCompanyRelationListResponse_Error::MergeFrom(const GetFlatgrammCompanyRelationListResponse_Error& from) {
  GetFlatgrammCompanyRelationListResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetFlatgrammCompanyRelationListResponse_Error::InternalSwap(GetFlatgrammCompanyRelationListResponse_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 GetFlatgrammCompanyRelationListResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse.Error";
}

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

class GetFlatgrammCompanyRelationListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse, _impl_._oneof_case_);
  static const ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse_Error& error(const GetFlatgrammCompanyRelationListResponse* msg);
  static const ::keyapis::access_control::v1::FlatgrammCompanyRelation& data(const GetFlatgrammCompanyRelationListResponse* msg);
};

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

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

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

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

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

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


void GetFlatgrammCompanyRelationListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse)
  ::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* GetFlatgrammCompanyRelationListResponse::_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_control.v1.GetFlatgrammCompanyRelationListResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_control.v1.FlatgrammCompanyRelation data = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          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* GetFlatgrammCompanyRelationListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::data(this),
          _Internal::data(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_control.v1.GetFlatgrammCompanyRelationListResponse)
  return target;
}

::size_t GetFlatgrammCompanyRelationListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.GetFlatgrammCompanyRelationListResponse)
  ::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_control.v1.GetFlatgrammCompanyRelationListResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    // .keyapis.access_control.v1.FlatgrammCompanyRelation data = 2;
    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 GetFlatgrammCompanyRelationListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetFlatgrammCompanyRelationListResponse*>(
      &from));
}

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

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

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

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

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

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

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

const ::keyapis::access_control::v1::DcCompanyFlatgramm&
PutFlatgrammDcCompanyAttachRequest::_Internal::dc_company_flatgramm(const PutFlatgrammDcCompanyAttachRequest* msg) {
  return *msg->_impl_.dc_company_flatgramm_;
}
PutFlatgrammDcCompanyAttachRequest::PutFlatgrammDcCompanyAttachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachRequest)
}
PutFlatgrammDcCompanyAttachRequest::PutFlatgrammDcCompanyAttachRequest(const PutFlatgrammDcCompanyAttachRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammDcCompanyAttachRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.dc_company_flatgramm_){nullptr}};

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

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

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

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

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

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

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

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

::size_t PutFlatgrammDcCompanyAttachRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachRequest)
  ::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_control.v1.DcCompanyFlatgramm dc_company_flatgramm = 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_.dc_company_flatgramm_);
  }

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

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

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

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

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

std::string PutFlatgrammDcCompanyAttachRequest::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammDcCompanyAttachRequest";
}

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

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

const ::keyapis::access_control::v1::FlatgrammCompanyRelation&
PutFlatgrammCompanyRelationAttachRequest::_Internal::flatgramm_company_relation(const PutFlatgrammCompanyRelationAttachRequest* msg) {
  return *msg->_impl_.flatgramm_company_relation_;
}
PutFlatgrammCompanyRelationAttachRequest::PutFlatgrammCompanyRelationAttachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachRequest)
}
PutFlatgrammCompanyRelationAttachRequest::PutFlatgrammCompanyRelationAttachRequest(const PutFlatgrammCompanyRelationAttachRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammCompanyRelationAttachRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.flatgramm_company_relation_){nullptr}};

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

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

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

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

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

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

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

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

::size_t PutFlatgrammCompanyRelationAttachRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachRequest)
  ::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_control.v1.FlatgrammCompanyRelation flatgramm_company_relation = 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_.flatgramm_company_relation_);
  }

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

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

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

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

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

std::string PutFlatgrammCompanyRelationAttachRequest::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachRequest";
}

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

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

const ::keyapis::access_control::v1::ValidationError&
PutFlatgrammDcCompanyAttachResponse_Error::_Internal::validation(const PutFlatgrammDcCompanyAttachResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PutFlatgrammDcCompanyAttachResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.PutFlatgrammDcCompanyAttachResponse.Error.validation)
}
void PutFlatgrammDcCompanyAttachResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
PutFlatgrammDcCompanyAttachResponse_Error::PutFlatgrammDcCompanyAttachResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.Error)
}
PutFlatgrammDcCompanyAttachResponse_Error::PutFlatgrammDcCompanyAttachResponse_Error(const PutFlatgrammDcCompanyAttachResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammDcCompanyAttachResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.Error)
}

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

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

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

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

void PutFlatgrammDcCompanyAttachResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.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 PutFlatgrammDcCompanyAttachResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.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* PutFlatgrammDcCompanyAttachResponse_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_control.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* PutFlatgrammDcCompanyAttachResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.PutFlatgrammDcCompanyAttachResponse.Error)
  return target;
}

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

void PutFlatgrammDcCompanyAttachResponse_Error::MergeFrom(const PutFlatgrammDcCompanyAttachResponse_Error& from) {
  PutFlatgrammDcCompanyAttachResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PutFlatgrammDcCompanyAttachResponse_Error::InternalSwap(PutFlatgrammDcCompanyAttachResponse_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 PutFlatgrammDcCompanyAttachResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.Error";
}

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

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

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

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

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

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

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

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


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

  // .keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(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_control.v1.PutFlatgrammDcCompanyAttachResponse)
  return target;
}

::size_t PutFlatgrammDcCompanyAttachResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammDcCompanyAttachResponse)
  ::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_control.v1.PutFlatgrammDcCompanyAttachResponse.Error error = 1;
    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 PutFlatgrammDcCompanyAttachResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutFlatgrammDcCompanyAttachResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

const ::keyapis::access_control::v1::ValidationError&
PutFlatgrammCompanyRelationAttachResponse_Error::_Internal::validation(const PutFlatgrammCompanyRelationAttachResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PutFlatgrammCompanyRelationAttachResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error.validation)
}
void PutFlatgrammCompanyRelationAttachResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
PutFlatgrammCompanyRelationAttachResponse_Error::PutFlatgrammCompanyRelationAttachResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error)
}
PutFlatgrammCompanyRelationAttachResponse_Error::PutFlatgrammCompanyRelationAttachResponse_Error(const PutFlatgrammCompanyRelationAttachResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammCompanyRelationAttachResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error)
}

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

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

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

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

void PutFlatgrammCompanyRelationAttachResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.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 PutFlatgrammCompanyRelationAttachResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.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* PutFlatgrammCompanyRelationAttachResponse_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_control.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* PutFlatgrammCompanyRelationAttachResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error)
  return target;
}

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

void PutFlatgrammCompanyRelationAttachResponse_Error::MergeFrom(const PutFlatgrammCompanyRelationAttachResponse_Error& from) {
  PutFlatgrammCompanyRelationAttachResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PutFlatgrammCompanyRelationAttachResponse_Error::InternalSwap(PutFlatgrammCompanyRelationAttachResponse_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 PutFlatgrammCompanyRelationAttachResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error";
}

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

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

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

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

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

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

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

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


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

  // .keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(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_control.v1.PutFlatgrammCompanyRelationAttachResponse)
  return target;
}

::size_t PutFlatgrammCompanyRelationAttachResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationAttachResponse)
  ::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_control.v1.PutFlatgrammCompanyRelationAttachResponse.Error error = 1;
    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 PutFlatgrammCompanyRelationAttachResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutFlatgrammCompanyRelationAttachResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

const ::keyapis::access_control::v1::DcCompanyFlatgramm&
PutFlatgrammDcCompanyDetachRequest::_Internal::dc_company_flatgramm(const PutFlatgrammDcCompanyDetachRequest* msg) {
  return *msg->_impl_.dc_company_flatgramm_;
}
PutFlatgrammDcCompanyDetachRequest::PutFlatgrammDcCompanyDetachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachRequest)
}
PutFlatgrammDcCompanyDetachRequest::PutFlatgrammDcCompanyDetachRequest(const PutFlatgrammDcCompanyDetachRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammDcCompanyDetachRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.dc_company_flatgramm_){nullptr}};

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

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

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

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

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

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

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

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

::size_t PutFlatgrammDcCompanyDetachRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachRequest)
  ::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_control.v1.DcCompanyFlatgramm dc_company_flatgramm = 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_.dc_company_flatgramm_);
  }

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

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

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

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

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

std::string PutFlatgrammDcCompanyDetachRequest::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammDcCompanyDetachRequest";
}

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

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

const ::keyapis::access_control::v1::FlatgrammCompanyRelation&
PutFlatgrammCompanyRelationDetachRequest::_Internal::flatgramm_company_relation(const PutFlatgrammCompanyRelationDetachRequest* msg) {
  return *msg->_impl_.flatgramm_company_relation_;
}
PutFlatgrammCompanyRelationDetachRequest::PutFlatgrammCompanyRelationDetachRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachRequest)
}
PutFlatgrammCompanyRelationDetachRequest::PutFlatgrammCompanyRelationDetachRequest(const PutFlatgrammCompanyRelationDetachRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammCompanyRelationDetachRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.flatgramm_company_relation_){nullptr}};

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

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

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

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

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

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

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

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

::size_t PutFlatgrammCompanyRelationDetachRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachRequest)
  ::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_control.v1.FlatgrammCompanyRelation flatgramm_company_relation = 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_.flatgramm_company_relation_);
  }

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

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

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

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

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

std::string PutFlatgrammCompanyRelationDetachRequest::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachRequest";
}

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

class DcCompanyFlatgramm::_Internal {
 public:
};

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

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

    , decltype(_impl_.flatgramm_id_) { 0 }

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

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

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

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

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

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

const char* DcCompanyFlatgramm::_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 company_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.company_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 flatgramm_id = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.flatgramm_id_ = ::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* DcCompanyFlatgramm::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.DcCompanyFlatgramm)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // int32 flatgramm_id = 2 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_flatgramm_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        2, this->_internal_flatgramm_id(), 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_control.v1.DcCompanyFlatgramm)
  return target;
}

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

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

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

  // int32 flatgramm_id = 2 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_flatgramm_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_flatgramm_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 DcCompanyFlatgramm::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DcCompanyFlatgramm*>(
      &from));
}

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

  if (from._internal_company_id() != 0) {
    _this->_internal_set_company_id(from._internal_company_id());
  }
  if (from._internal_flatgramm_id() != 0) {
    _this->_internal_set_flatgramm_id(from._internal_flatgramm_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string DcCompanyFlatgramm::GetTypeName() const {
  return "keyapis.access_control.v1.DcCompanyFlatgramm";
}

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

class FlatgrammCompanyRelation::_Internal {
 public:
};

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

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

    , decltype(_impl_.flatgramm_id_) { 0 }

    , decltype(_impl_.type_) { 0 }

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

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

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

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

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

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

const char* FlatgrammCompanyRelation::_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 company_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.company_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 flatgramm_id = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.flatgramm_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.access_control.v1.FlatgrammCompanyRelation.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::keyapis::access_control::v1::FlatgrammCompanyRelation_Type>(val));
        } 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* FlatgrammCompanyRelation::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.FlatgrammCompanyRelation)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // .keyapis.access_control.v1.FlatgrammCompanyRelation.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        3, this->_internal_type(), 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_control.v1.FlatgrammCompanyRelation)
  return target;
}

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

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

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

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

  // .keyapis.access_control.v1.FlatgrammCompanyRelation.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
  }

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

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

  if (from._internal_company_id() != 0) {
    _this->_internal_set_company_id(from._internal_company_id());
  }
  if (from._internal_flatgramm_id() != 0) {
    _this->_internal_set_flatgramm_id(from._internal_flatgramm_id());
  }
  if (from._internal_type() != 0) {
    _this->_internal_set_type(from._internal_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string FlatgrammCompanyRelation::GetTypeName() const {
  return "keyapis.access_control.v1.FlatgrammCompanyRelation";
}

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

class DcCompanyFlatgrammFilter::_Internal {
 public:
};

DcCompanyFlatgrammFilter::DcCompanyFlatgrammFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.DcCompanyFlatgrammFilter)
}
DcCompanyFlatgrammFilter::DcCompanyFlatgrammFilter(const DcCompanyFlatgrammFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DcCompanyFlatgrammFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.company_ids_) { from._impl_.company_ids_ }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.flatgramm_ids_) { from._impl_.flatgramm_ids_ }
    ,/* _impl_._flatgramm_ids_cached_byte_size_ = */ { 0 }

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

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

inline void DcCompanyFlatgrammFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.company_ids_) { arena }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.flatgramm_ids_) { arena }
    ,/* _impl_._flatgramm_ids_cached_byte_size_ = */ { 0 }

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

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

inline void DcCompanyFlatgrammFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.company_ids_.~RepeatedField();
  _impl_.flatgramm_ids_.~RepeatedField();
}

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

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

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

const char* DcCompanyFlatgrammFilter::_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 int32 company_ids = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_company_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          _internal_add_company_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 flatgramm_ids = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_flatgramm_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 16) {
          _internal_add_flatgramm_ids(::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* DcCompanyFlatgrammFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.DcCompanyFlatgrammFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 company_ids = 1;
  {
    int byte_size = _impl_._company_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(1, _internal_company_ids(),
                                                 byte_size, target);
    }
  }

  // repeated int32 flatgramm_ids = 2;
  {
    int byte_size = _impl_._flatgramm_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(2, _internal_flatgramm_ids(),
                                                 byte_size, 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_control.v1.DcCompanyFlatgrammFilter)
  return target;
}

::size_t DcCompanyFlatgrammFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.DcCompanyFlatgrammFilter)
  ::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 int32 company_ids = 1;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_company_ids())
    ;
    _impl_._company_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  // repeated int32 flatgramm_ids = 2;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_flatgramm_ids())
    ;
    _impl_._flatgramm_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

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

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

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

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

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

void DcCompanyFlatgrammFilter::InternalSwap(DcCompanyFlatgrammFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.company_ids_.InternalSwap(&other->_impl_.company_ids_);
  _impl_.flatgramm_ids_.InternalSwap(&other->_impl_.flatgramm_ids_);
}

std::string DcCompanyFlatgrammFilter::GetTypeName() const {
  return "keyapis.access_control.v1.DcCompanyFlatgrammFilter";
}

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

class FlatgrammCompanyRelationFilter::_Internal {
 public:
};

FlatgrammCompanyRelationFilter::FlatgrammCompanyRelationFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.FlatgrammCompanyRelationFilter)
}
FlatgrammCompanyRelationFilter::FlatgrammCompanyRelationFilter(const FlatgrammCompanyRelationFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  FlatgrammCompanyRelationFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.flatgramm_ids_) { from._impl_.flatgramm_ids_ }
    ,/* _impl_._flatgramm_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.company_ids_) { from._impl_.company_ids_ }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.flatgramm_company_relation_types_) { from._internal_flatgramm_company_relation_types() }
    , /*decltype(_impl_._flatgramm_company_relation_types_cached_byte_size_)*/ { 0 }

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

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

inline void FlatgrammCompanyRelationFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.flatgramm_ids_) { arena }
    ,/* _impl_._flatgramm_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.company_ids_) { arena }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.flatgramm_company_relation_types_) { arena }
    , /*decltype(_impl_._flatgramm_company_relation_types_cached_byte_size_)*/ { 0 }

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

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

inline void FlatgrammCompanyRelationFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.flatgramm_ids_.~RepeatedField();
  _impl_.company_ids_.~RepeatedField();
  _internal_mutable_flatgramm_company_relation_types()->~RepeatedField();
}

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

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

  _internal_mutable_flatgramm_ids()->Clear();
  _internal_mutable_company_ids()->Clear();
  _internal_mutable_flatgramm_company_relation_types()->Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* FlatgrammCompanyRelationFilter::_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 int32 flatgramm_ids = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_flatgramm_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          _internal_add_flatgramm_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 company_ids = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_company_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 16) {
          _internal_add_company_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.access_control.v1.FlatgrammCompanyRelation.Type flatgramm_company_relation_types = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_flatgramm_company_relation_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 24) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_flatgramm_company_relation_types(static_cast<::keyapis::access_control::v1::FlatgrammCompanyRelation_Type>(val));
        } 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* FlatgrammCompanyRelationFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.FlatgrammCompanyRelationFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 flatgramm_ids = 1;
  {
    int byte_size = _impl_._flatgramm_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(1, _internal_flatgramm_ids(),
                                                 byte_size, target);
    }
  }

  // repeated int32 company_ids = 2;
  {
    int byte_size = _impl_._company_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(2, _internal_company_ids(),
                                                 byte_size, target);
    }
  }

  // repeated .keyapis.access_control.v1.FlatgrammCompanyRelation.Type flatgramm_company_relation_types = 3;
  {
    int byte_size = _impl_._flatgramm_company_relation_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(3, _internal_flatgramm_company_relation_types(),
                                       byte_size, 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_control.v1.FlatgrammCompanyRelationFilter)
  return target;
}

::size_t FlatgrammCompanyRelationFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.FlatgrammCompanyRelationFilter)
  ::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 int32 flatgramm_ids = 1;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_flatgramm_ids())
    ;
    _impl_._flatgramm_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  // repeated int32 company_ids = 2;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_company_ids())
    ;
    _impl_._company_ids_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
    std::size_t tag_size = data_size == 0
        ? 0
        : 1 + ::_pbi::WireFormatLite::Int32Size(
                            static_cast<int32_t>(data_size))
    ;
    total_size += tag_size + data_size;
  }

  // repeated .keyapis.access_control.v1.FlatgrammCompanyRelation.Type flatgramm_company_relation_types = 3;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_flatgramm_company_relation_types_size());

    for (std::size_t i = 0; i < count; ++i) {
      data_size += ::_pbi::WireFormatLite::EnumSize(
          this->_internal_flatgramm_company_relation_types(static_cast<int>(i)));
    }
    total_size += data_size;
    if (data_size > 0) {
      total_size += 1;
      total_size += ::_pbi::WireFormatLite::Int32Size(
          static_cast<int32_t>(data_size));
    }
    _impl_._flatgramm_company_relation_types_cached_byte_size_.Set(::_pbi::ToCachedSize(data_size));
  }

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

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

  _this->_impl_.flatgramm_ids_.MergeFrom(from._impl_.flatgramm_ids_);
  _this->_impl_.company_ids_.MergeFrom(from._impl_.company_ids_);
  _this->_internal_mutable_flatgramm_company_relation_types()->MergeFrom(from._internal_flatgramm_company_relation_types());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void FlatgrammCompanyRelationFilter::InternalSwap(FlatgrammCompanyRelationFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.flatgramm_ids_.InternalSwap(&other->_impl_.flatgramm_ids_);
  _impl_.company_ids_.InternalSwap(&other->_impl_.company_ids_);
  _internal_mutable_flatgramm_company_relation_types()->InternalSwap(
      other->_internal_mutable_flatgramm_company_relation_types());
}

std::string FlatgrammCompanyRelationFilter::GetTypeName() const {
  return "keyapis.access_control.v1.FlatgrammCompanyRelationFilter";
}

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

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

const ::keyapis::access_control::v1::ValidationError&
PutFlatgrammDcCompanyDetachResponse_Error::_Internal::validation(const PutFlatgrammDcCompanyDetachResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PutFlatgrammDcCompanyDetachResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.PutFlatgrammDcCompanyDetachResponse.Error.validation)
}
void PutFlatgrammDcCompanyDetachResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
PutFlatgrammDcCompanyDetachResponse_Error::PutFlatgrammDcCompanyDetachResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.Error)
}
PutFlatgrammDcCompanyDetachResponse_Error::PutFlatgrammDcCompanyDetachResponse_Error(const PutFlatgrammDcCompanyDetachResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammDcCompanyDetachResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.Error)
}

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

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

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

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

void PutFlatgrammDcCompanyDetachResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.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 PutFlatgrammDcCompanyDetachResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.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* PutFlatgrammDcCompanyDetachResponse_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_control.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* PutFlatgrammDcCompanyDetachResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.PutFlatgrammDcCompanyDetachResponse.Error)
  return target;
}

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

void PutFlatgrammDcCompanyDetachResponse_Error::MergeFrom(const PutFlatgrammDcCompanyDetachResponse_Error& from) {
  PutFlatgrammDcCompanyDetachResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PutFlatgrammDcCompanyDetachResponse_Error::InternalSwap(PutFlatgrammDcCompanyDetachResponse_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 PutFlatgrammDcCompanyDetachResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.Error";
}

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

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

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

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

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

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

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

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


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

  // .keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(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_control.v1.PutFlatgrammDcCompanyDetachResponse)
  return target;
}

::size_t PutFlatgrammDcCompanyDetachResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammDcCompanyDetachResponse)
  ::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_control.v1.PutFlatgrammDcCompanyDetachResponse.Error error = 1;
    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 PutFlatgrammDcCompanyDetachResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutFlatgrammDcCompanyDetachResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

const ::keyapis::access_control::v1::ValidationError&
PutFlatgrammCompanyRelationDetachResponse_Error::_Internal::validation(const PutFlatgrammCompanyRelationDetachResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PutFlatgrammCompanyRelationDetachResponse_Error::set_allocated_validation(::keyapis::access_control::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_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error.validation)
}
void PutFlatgrammCompanyRelationDetachResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
PutFlatgrammCompanyRelationDetachResponse_Error::PutFlatgrammCompanyRelationDetachResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error)
}
PutFlatgrammCompanyRelationDetachResponse_Error::PutFlatgrammCompanyRelationDetachResponse_Error(const PutFlatgrammCompanyRelationDetachResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PutFlatgrammCompanyRelationDetachResponse_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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error)
}

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

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

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

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

void PutFlatgrammCompanyRelationDetachResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.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 PutFlatgrammCompanyRelationDetachResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.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* PutFlatgrammCompanyRelationDetachResponse_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_control.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* PutFlatgrammCompanyRelationDetachResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.access_control.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_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error)
  return target;
}

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

void PutFlatgrammCompanyRelationDetachResponse_Error::MergeFrom(const PutFlatgrammCompanyRelationDetachResponse_Error& from) {
  PutFlatgrammCompanyRelationDetachResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.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_control::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PutFlatgrammCompanyRelationDetachResponse_Error::InternalSwap(PutFlatgrammCompanyRelationDetachResponse_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 PutFlatgrammCompanyRelationDetachResponse_Error::GetTypeName() const {
  return "keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error";
}

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

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

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

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

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

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

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

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


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

  // .keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(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_control.v1.PutFlatgrammCompanyRelationDetachResponse)
  return target;
}

::size_t PutFlatgrammCompanyRelationDetachResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.access_control.v1.PutFlatgrammCompanyRelationDetachResponse)
  ::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_control.v1.PutFlatgrammCompanyRelationDetachResponse.Error error = 1;
    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 PutFlatgrammCompanyRelationDetachResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PutFlatgrammCompanyRelationDetachResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace access_control
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::Flatgramm*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::Flatgramm >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::Flatgramm >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::FlatgrammFilter*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::FlatgrammFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::FlatgrammFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::FlatgrammPaging*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::FlatgrammPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::FlatgrammPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammDcCompanyListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammDcCompanyListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammDcCompanyListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammDcCompanyCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::DcCompanyFlatgrammPaging*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::DcCompanyFlatgrammPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::DcCompanyFlatgrammPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::FlatgrammCompanyRelationPaging*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::FlatgrammCompanyRelationPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::FlatgrammCompanyRelationPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammDcCompanyListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::GetFlatgrammCompanyRelationListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammDcCompanyAttachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationAttachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachRequest*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::DcCompanyFlatgramm*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::DcCompanyFlatgramm >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::DcCompanyFlatgramm >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::FlatgrammCompanyRelation*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::FlatgrammCompanyRelation >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::FlatgrammCompanyRelation >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::DcCompanyFlatgrammFilter*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::DcCompanyFlatgrammFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::DcCompanyFlatgrammFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::FlatgrammCompanyRelationFilter*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::FlatgrammCompanyRelationFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::FlatgrammCompanyRelationFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammDcCompanyDetachResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse*
Arena::CreateMaybeMessage< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::access_control::v1::PutFlatgrammCompanyRelationDetachResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"