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

#include "keyapis/subscription/v1/keyapis_subscription_subscription_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 subscription {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR Subscription::Subscription(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

  , /*decltype(_impl_.price_)*/nullptr
  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.expired_at_)*/nullptr
  , /*decltype(_impl_.parent_id_)*/nullptr
  , /*decltype(_impl_.account_)*/nullptr
  , /*decltype(_impl_.offer_)*/nullptr
  , /*decltype(_impl_.discount_price_)*/nullptr
  , /*decltype(_impl_.orpon_)*/ ::int64_t{0}

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

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

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

  , /*decltype(_impl_.is_enable_auto_subscribe_)*/ false

  , /*decltype(_impl_.billing_type_)*/ 0
} {}
struct SubscriptionDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionDefaultTypeInternal() {}
  union {
    Subscription _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionDefaultTypeInternal _Subscription_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionFilter_ValidationError_OrponsInvalid::SubscriptionFilter_ValidationError_OrponsInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SubscriptionFilter_ValidationError_OrponsInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionFilter_ValidationError_OrponsInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionFilter_ValidationError_OrponsInvalidDefaultTypeInternal() {}
  union {
    SubscriptionFilter_ValidationError_OrponsInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionFilter_ValidationError_OrponsInvalidDefaultTypeInternal _SubscriptionFilter_ValidationError_OrponsInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionFilter_ValidationError_FlatNumbersInvalid::SubscriptionFilter_ValidationError_FlatNumbersInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SubscriptionFilter_ValidationError_FlatNumbersInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionFilter_ValidationError_FlatNumbersInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionFilter_ValidationError_FlatNumbersInvalidDefaultTypeInternal() {}
  union {
    SubscriptionFilter_ValidationError_FlatNumbersInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionFilter_ValidationError_FlatNumbersInvalidDefaultTypeInternal _SubscriptionFilter_ValidationError_FlatNumbersInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionFilter_ValidationError::SubscriptionFilter_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SubscriptionFilter_ValidationErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionFilter_ValidationErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionFilter_ValidationErrorDefaultTypeInternal() {}
  union {
    SubscriptionFilter_ValidationError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionFilter_ValidationErrorDefaultTypeInternal _SubscriptionFilter_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionFilter::SubscriptionFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.orpons_)*/ {}
  ,/* _impl_._orpons_cached_byte_size_ = */ { 0 }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionFilterDefaultTypeInternal _SubscriptionFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionPaging_ValidationError_LimitInvalid::SubscriptionPaging_ValidationError_LimitInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SubscriptionPaging_ValidationError_LimitInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionPaging_ValidationError_LimitInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionPaging_ValidationError_LimitInvalidDefaultTypeInternal() {}
  union {
    SubscriptionPaging_ValidationError_LimitInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionPaging_ValidationError_LimitInvalidDefaultTypeInternal _SubscriptionPaging_ValidationError_LimitInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionPaging_ValidationError_OffsetInvalid::SubscriptionPaging_ValidationError_OffsetInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct SubscriptionPaging_ValidationError_OffsetInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionPaging_ValidationError_OffsetInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionPaging_ValidationError_OffsetInvalidDefaultTypeInternal() {}
  union {
    SubscriptionPaging_ValidationError_OffsetInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionPaging_ValidationError_OffsetInvalidDefaultTypeInternal _SubscriptionPaging_ValidationError_OffsetInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionPaging_ValidationError::SubscriptionPaging_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SubscriptionPaging_ValidationErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionPaging_ValidationErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionPaging_ValidationErrorDefaultTypeInternal() {}
  union {
    SubscriptionPaging_ValidationError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SubscriptionPaging_ValidationErrorDefaultTypeInternal _SubscriptionPaging_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SubscriptionPaging::SubscriptionPaging(
    ::_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 SubscriptionPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SubscriptionPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SubscriptionPagingDefaultTypeInternal() {}
  union {
    SubscriptionPaging _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionRequestDefaultTypeInternal _GetSubscriptionRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSubscriptionResponse::GetSubscriptionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSubscriptionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSubscriptionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSubscriptionResponseDefaultTypeInternal() {}
  union {
    GetSubscriptionResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionListRequestDefaultTypeInternal _GetSubscriptionListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSubscriptionListResponse_Error::GetSubscriptionListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSubscriptionListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSubscriptionListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSubscriptionListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetSubscriptionListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionListResponse_ErrorDefaultTypeInternal _GetSubscriptionListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSubscriptionListResponse::GetSubscriptionListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSubscriptionListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSubscriptionListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSubscriptionListResponseDefaultTypeInternal() {}
  union {
    GetSubscriptionListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionListResponseDefaultTypeInternal _GetSubscriptionListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSubscriptionCountRequest::GetSubscriptionCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetSubscriptionCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSubscriptionCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSubscriptionCountRequestDefaultTypeInternal() {}
  union {
    GetSubscriptionCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionCountRequestDefaultTypeInternal _GetSubscriptionCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSubscriptionCountResponse_Error::GetSubscriptionCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSubscriptionCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSubscriptionCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSubscriptionCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetSubscriptionCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionCountResponse_ErrorDefaultTypeInternal _GetSubscriptionCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSubscriptionCountResponse::GetSubscriptionCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSubscriptionCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSubscriptionCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSubscriptionCountResponseDefaultTypeInternal() {}
  union {
    GetSubscriptionCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSubscriptionCountResponseDefaultTypeInternal _GetSubscriptionCountResponse_default_instance_;
}  // namespace v1
}  // namespace subscription
}  // namespace keyapis
namespace keyapis {
namespace subscription {
namespace v1 {
bool Subscription_StatusType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    Subscription_StatusType_strings[6] = {};

static const char Subscription_StatusType_names[] = {
    "ACTIVE"
    "BLOCKED"
    "CANCELED"
    "SCHEDULED_CANCELED"
    "SETUP"
    "STATUS_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Subscription_StatusType_entries[] =
    {
        {{&Subscription_StatusType_names[0], 6}, 2},
        {{&Subscription_StatusType_names[6], 7}, 3},
        {{&Subscription_StatusType_names[13], 8}, 4},
        {{&Subscription_StatusType_names[21], 18}, 5},
        {{&Subscription_StatusType_names[39], 5}, 1},
        {{&Subscription_StatusType_names[44], 19}, 0},
};

static const int Subscription_StatusType_entries_by_number[] = {
    5,  // 0 -> STATUS_TYPE_UNKNOWN
    4,  // 1 -> SETUP
    0,  // 2 -> ACTIVE
    1,  // 3 -> BLOCKED
    2,  // 4 -> CANCELED
    3,  // 5 -> SCHEDULED_CANCELED
};

const std::string& Subscription_StatusType_Name(Subscription_StatusType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Subscription_StatusType_entries, Subscription_StatusType_entries_by_number,
          6, Subscription_StatusType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Subscription_StatusType_entries, Subscription_StatusType_entries_by_number, 6,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : Subscription_StatusType_strings[idx].get();
}

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

constexpr Subscription_StatusType Subscription::STATUS_TYPE_UNKNOWN;
constexpr Subscription_StatusType Subscription::SETUP;
constexpr Subscription_StatusType Subscription::ACTIVE;
constexpr Subscription_StatusType Subscription::BLOCKED;
constexpr Subscription_StatusType Subscription::CANCELED;
constexpr Subscription_StatusType Subscription::SCHEDULED_CANCELED;
constexpr Subscription_StatusType Subscription::StatusType_MIN;
constexpr Subscription_StatusType Subscription::StatusType_MAX;
constexpr int Subscription::StatusType_ARRAYSIZE;

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

static const char Subscription_BillingType_names[] = {
    "ASR_KEY"
    "ASR_MC"
    "ASR_MRF"
    "BILLING_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Subscription_BillingType_entries[] =
    {
        {{&Subscription_BillingType_names[0], 7}, 2},
        {{&Subscription_BillingType_names[7], 6}, 3},
        {{&Subscription_BillingType_names[13], 7}, 1},
        {{&Subscription_BillingType_names[20], 20}, 0},
};

static const int Subscription_BillingType_entries_by_number[] = {
    3,  // 0 -> BILLING_TYPE_UNKNOWN
    2,  // 1 -> ASR_MRF
    0,  // 2 -> ASR_KEY
    1,  // 3 -> ASR_MC
};

const std::string& Subscription_BillingType_Name(Subscription_BillingType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Subscription_BillingType_entries, Subscription_BillingType_entries_by_number,
          4, Subscription_BillingType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Subscription_BillingType_entries, Subscription_BillingType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : Subscription_BillingType_strings[idx].get();
}

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

constexpr Subscription_BillingType Subscription::BILLING_TYPE_UNKNOWN;
constexpr Subscription_BillingType Subscription::ASR_MRF;
constexpr Subscription_BillingType Subscription::ASR_KEY;
constexpr Subscription_BillingType Subscription::ASR_MC;
constexpr Subscription_BillingType Subscription::BillingType_MIN;
constexpr Subscription_BillingType Subscription::BillingType_MAX;
constexpr int Subscription::BillingType_ARRAYSIZE;

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

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

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SubscriptionPaging_OrderByType_entries[] =
    {
        {{&SubscriptionPaging_OrderByType_names[0], 2}, 1},
        {{&SubscriptionPaging_OrderByType_names[2], 21}, 0},
};

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

const std::string& SubscriptionPaging_OrderByType_Name(SubscriptionPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SubscriptionPaging_OrderByType_entries, SubscriptionPaging_OrderByType_entries_by_number,
          2, SubscriptionPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SubscriptionPaging_OrderByType_entries, SubscriptionPaging_OrderByType_entries_by_number, 2,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : SubscriptionPaging_OrderByType_strings[idx].get();
}

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

constexpr SubscriptionPaging_OrderByType SubscriptionPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr SubscriptionPaging_OrderByType SubscriptionPaging::ID;
constexpr SubscriptionPaging_OrderByType SubscriptionPaging::OrderByType_MIN;
constexpr SubscriptionPaging_OrderByType SubscriptionPaging::OrderByType_MAX;
constexpr int SubscriptionPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& SubscriptionPaging_DirectionType_Name(SubscriptionPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SubscriptionPaging_DirectionType_entries, SubscriptionPaging_DirectionType_entries_by_number,
          3, SubscriptionPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SubscriptionPaging_DirectionType_entries, SubscriptionPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : SubscriptionPaging_DirectionType_strings[idx].get();
}

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

constexpr SubscriptionPaging_DirectionType SubscriptionPaging::DIRECTION_TYPE_UNKNOWN;
constexpr SubscriptionPaging_DirectionType SubscriptionPaging::DESC;
constexpr SubscriptionPaging_DirectionType SubscriptionPaging::ASC;
constexpr SubscriptionPaging_DirectionType SubscriptionPaging::DirectionType_MIN;
constexpr SubscriptionPaging_DirectionType SubscriptionPaging::DirectionType_MAX;
constexpr int SubscriptionPaging::DirectionType_ARRAYSIZE;

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

class Subscription::_Internal {
 public:
  using HasBits = decltype(std::declval<Subscription>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(Subscription, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::DoubleValue& price(const Subscription* msg);
  static void set_has_price(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at(const Subscription* msg);
  static void set_has_created_at(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at(const Subscription* msg);
  static void set_has_changed_at(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& expired_at(const Subscription* msg);
  static void set_has_expired_at(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& parent_id(const Subscription* msg);
  static void set_has_parent_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Int64Value& account(const Subscription* msg);
  static void set_has_account(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::keyapis::subscription::v1::Offer& offer(const Subscription* msg);
  static void set_has_offer(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::DoubleValue& discount_price(const Subscription* msg);
  static void set_has_discount_price(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::DoubleValue&
Subscription::_Internal::price(const Subscription* msg) {
  return *msg->_impl_.price_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Subscription::_Internal::created_at(const Subscription* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Subscription::_Internal::changed_at(const Subscription* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Subscription::_Internal::expired_at(const Subscription* msg) {
  return *msg->_impl_.expired_at_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
Subscription::_Internal::parent_id(const Subscription* msg) {
  return *msg->_impl_.parent_id_;
}
const ::PROTOBUF_NAMESPACE_ID::Int64Value&
Subscription::_Internal::account(const Subscription* msg) {
  return *msg->_impl_.account_;
}
const ::keyapis::subscription::v1::Offer&
Subscription::_Internal::offer(const Subscription* msg) {
  return *msg->_impl_.offer_;
}
const ::PROTOBUF_NAMESPACE_ID::DoubleValue&
Subscription::_Internal::discount_price(const Subscription* msg) {
  return *msg->_impl_.discount_price_;
}
void Subscription::clear_price() {
  if (_impl_.price_ != nullptr) _impl_.price_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void Subscription::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void Subscription::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void Subscription::clear_expired_at() {
  if (_impl_.expired_at_ != nullptr) _impl_.expired_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
void Subscription::clear_parent_id() {
  if (_impl_.parent_id_ != nullptr) _impl_.parent_id_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
void Subscription::clear_account() {
  if (_impl_.account_ != nullptr) _impl_.account_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
void Subscription::clear_offer() {
  if (_impl_.offer_ != nullptr) _impl_.offer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
void Subscription::clear_discount_price() {
  if (_impl_.discount_price_ != nullptr) _impl_.discount_price_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
Subscription::Subscription(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.subscription.v1.Subscription)
}
Subscription::Subscription(const Subscription& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Subscription* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.flat_number_) {}

    , decltype(_impl_.price_){nullptr}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.expired_at_){nullptr}
    , decltype(_impl_.parent_id_){nullptr}
    , decltype(_impl_.account_){nullptr}
    , decltype(_impl_.offer_){nullptr}
    , decltype(_impl_.discount_price_){nullptr}
    , decltype(_impl_.orpon_) {}

    , decltype(_impl_.offer_id_) {}

    , decltype(_impl_.status_type_) {}

    , decltype(_impl_.previous_status_type_) {}

    , decltype(_impl_.is_enable_auto_subscribe_) {}

    , decltype(_impl_.billing_type_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  _impl_.flat_number_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.flat_number_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_flat_number().empty()) {
    _this->_impl_.flat_number_.Set(from._internal_flat_number(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.price_ = new ::PROTOBUF_NAMESPACE_ID::DoubleValue(*from._impl_.price_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.expired_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.expired_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
    _this->_impl_.parent_id_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.parent_id_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) {
    _this->_impl_.account_ = new ::PROTOBUF_NAMESPACE_ID::Int64Value(*from._impl_.account_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000040u) != 0) {
    _this->_impl_.offer_ = new ::keyapis::subscription::v1::Offer(*from._impl_.offer_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000080u) != 0) {
    _this->_impl_.discount_price_ = new ::PROTOBUF_NAMESPACE_ID::DoubleValue(*from._impl_.discount_price_);
  }
  ::memcpy(&_impl_.orpon_, &from._impl_.orpon_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.billing_type_) -
    reinterpret_cast<char*>(&_impl_.orpon_)) + sizeof(_impl_.billing_type_));
  // @@protoc_insertion_point(copy_constructor:keyapis.subscription.v1.Subscription)
}

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

    , decltype(_impl_.flat_number_) {}

    , decltype(_impl_.price_){nullptr}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.expired_at_){nullptr}
    , decltype(_impl_.parent_id_){nullptr}
    , decltype(_impl_.account_){nullptr}
    , decltype(_impl_.offer_){nullptr}
    , decltype(_impl_.discount_price_){nullptr}
    , decltype(_impl_.orpon_) { ::int64_t{0} }

    , decltype(_impl_.offer_id_) { 0 }

    , decltype(_impl_.status_type_) { 0 }

    , decltype(_impl_.previous_status_type_) { 0 }

    , decltype(_impl_.is_enable_auto_subscribe_) { false }

    , decltype(_impl_.billing_type_) { 0 }

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

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

inline void Subscription::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.id_.Destroy();
  _impl_.flat_number_.Destroy();
  if (this != internal_default_instance()) delete _impl_.price_;
  if (this != internal_default_instance()) delete _impl_.created_at_;
  if (this != internal_default_instance()) delete _impl_.changed_at_;
  if (this != internal_default_instance()) delete _impl_.expired_at_;
  if (this != internal_default_instance()) delete _impl_.parent_id_;
  if (this != internal_default_instance()) delete _impl_.account_;
  if (this != internal_default_instance()) delete _impl_.offer_;
  if (this != internal_default_instance()) delete _impl_.discount_price_;
}

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

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

  _impl_.id_.ClearToEmpty();
  _impl_.flat_number_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.price_ != nullptr);
      _impl_.price_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.expired_at_ != nullptr);
      _impl_.expired_at_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      ABSL_DCHECK(_impl_.parent_id_ != nullptr);
      _impl_.parent_id_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      ABSL_DCHECK(_impl_.account_ != nullptr);
      _impl_.account_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      ABSL_DCHECK(_impl_.offer_ != nullptr);
      _impl_.offer_->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      ABSL_DCHECK(_impl_.discount_price_ != nullptr);
      _impl_.discount_price_->Clear();
    }
  }
  ::memset(&_impl_.orpon_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.billing_type_) -
      reinterpret_cast<char*>(&_impl_.orpon_)) + sizeof(_impl_.billing_type_));
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Subscription::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 orpon = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.orpon_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string flat_number = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_flat_number();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 offer_id = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.offer_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.Subscription.StatusType status_type = 5 [(.google.api.field_behavior) = REQUIRED];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_status_type(static_cast<::keyapis::subscription::v1::Subscription_StatusType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.Subscription.StatusType previous_status_type = 6 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_previous_status_type(static_cast<::keyapis::subscription::v1::Subscription_StatusType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.DoubleValue price = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_price(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 8 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 9 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_enable_auto_subscribe = 10 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
          _impl_.is_enable_auto_subscribe_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.Subscription.BillingType billing_type = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_billing_type(static_cast<::keyapis::subscription::v1::Subscription_BillingType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp expired_at = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_expired_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue parent_id = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_parent_id(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Int64Value account = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 114)) {
          ptr = ctx->ParseMessage(_internal_mutable_account(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.Offer offer = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 122)) {
          ptr = ctx->ParseMessage(_internal_mutable_offer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.DoubleValue discount_price = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 130)) {
          ptr = ctx->ParseMessage(_internal_mutable_discount_price(), 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* Subscription::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.Subscription)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // int64 orpon = 2 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_orpon() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
        2, this->_internal_orpon(), target);
  }

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

  // int32 offer_id = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_offer_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        4, this->_internal_offer_id(), target);
  }

  // .keyapis.subscription.v1.Subscription.StatusType status_type = 5 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_status_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        5, this->_internal_status_type(), target);
  }

  // .keyapis.subscription.v1.Subscription.StatusType previous_status_type = 6 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_previous_status_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        6, this->_internal_previous_status_type(), target);
  }

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

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

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

  // bool is_enable_auto_subscribe = 10 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_is_enable_auto_subscribe() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        10, this->_internal_is_enable_auto_subscribe(), target);
  }

  // .keyapis.subscription.v1.Subscription.BillingType billing_type = 11;
  if (this->_internal_billing_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        11, this->_internal_billing_type(), target);
  }

  // .google.protobuf.Timestamp expired_at = 12;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(12, _Internal::expired_at(this),
        _Internal::expired_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue parent_id = 13;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(13, _Internal::parent_id(this),
        _Internal::parent_id(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.Int64Value account = 14;
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(14, _Internal::account(this),
        _Internal::account(this).GetCachedSize(), target, stream);
  }

  // .keyapis.subscription.v1.Offer offer = 15;
  if (cached_has_bits & 0x00000040u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(15, _Internal::offer(this),
        _Internal::offer(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.DoubleValue discount_price = 16;
  if (cached_has_bits & 0x00000080u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(16, _Internal::discount_price(this),
        _Internal::discount_price(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.subscription.v1.Subscription)
  return target;
}

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // .google.protobuf.DoubleValue price = 7;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.price_);
    }

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

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

    // .google.protobuf.Timestamp expired_at = 12;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.expired_at_);
    }

    // .google.protobuf.StringValue parent_id = 13;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.parent_id_);
    }

    // .google.protobuf.Int64Value account = 14;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.account_);
    }

    // .keyapis.subscription.v1.Offer offer = 15;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.offer_);
    }

    // .google.protobuf.DoubleValue discount_price = 16;
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.discount_price_);
    }

  }
  // int64 orpon = 2 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_orpon() != 0) {
    total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
        this->_internal_orpon());
  }

  // int32 offer_id = 4 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_offer_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_offer_id());
  }

  // .keyapis.subscription.v1.Subscription.StatusType status_type = 5 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_status_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_status_type());
  }

  // .keyapis.subscription.v1.Subscription.StatusType previous_status_type = 6 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_previous_status_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_previous_status_type());
  }

  // bool is_enable_auto_subscribe = 10 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_is_enable_auto_subscribe() != 0) {
    total_size += 2;
  }

  // .keyapis.subscription.v1.Subscription.BillingType billing_type = 11;
  if (this->_internal_billing_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_billing_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 Subscription::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Subscription*>(
      &from));
}

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

  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  if (!from._internal_flat_number().empty()) {
    _this->_internal_set_flat_number(from._internal_flat_number());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_price()->::PROTOBUF_NAMESPACE_ID::DoubleValue::MergeFrom(
          from._internal_price());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_expired_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_expired_at());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_internal_mutable_parent_id()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_parent_id());
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_internal_mutable_account()->::PROTOBUF_NAMESPACE_ID::Int64Value::MergeFrom(
          from._internal_account());
    }
    if (cached_has_bits & 0x00000040u) {
      _this->_internal_mutable_offer()->::keyapis::subscription::v1::Offer::MergeFrom(
          from._internal_offer());
    }
    if (cached_has_bits & 0x00000080u) {
      _this->_internal_mutable_discount_price()->::PROTOBUF_NAMESPACE_ID::DoubleValue::MergeFrom(
          from._internal_discount_price());
    }
  }
  if (from._internal_orpon() != 0) {
    _this->_internal_set_orpon(from._internal_orpon());
  }
  if (from._internal_offer_id() != 0) {
    _this->_internal_set_offer_id(from._internal_offer_id());
  }
  if (from._internal_status_type() != 0) {
    _this->_internal_set_status_type(from._internal_status_type());
  }
  if (from._internal_previous_status_type() != 0) {
    _this->_internal_set_previous_status_type(from._internal_previous_status_type());
  }
  if (from._internal_is_enable_auto_subscribe() != 0) {
    _this->_internal_set_is_enable_auto_subscribe(from._internal_is_enable_auto_subscribe());
  }
  if (from._internal_billing_type() != 0) {
    _this->_internal_set_billing_type(from._internal_billing_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void Subscription::InternalSwap(Subscription* 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_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.flat_number_, lhs_arena,
                                       &other->_impl_.flat_number_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Subscription, _impl_.billing_type_)
      + sizeof(Subscription::_impl_.billing_type_)
      - PROTOBUF_FIELD_OFFSET(Subscription, _impl_.price_)>(
          reinterpret_cast<char*>(&_impl_.price_),
          reinterpret_cast<char*>(&other->_impl_.price_));
}

std::string Subscription::GetTypeName() const {
  return "keyapis.subscription.v1.Subscription";
}

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

class SubscriptionFilter_ValidationError_OrponsInvalid::_Internal {
 public:
};

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

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

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

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

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

void SubscriptionFilter_ValidationError_OrponsInvalid::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

::uint8_t* SubscriptionFilter_ValidationError_OrponsInvalid::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

::size_t SubscriptionFilter_ValidationError_OrponsInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid)
  ::size_t total_size = 0;

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

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

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

void SubscriptionFilter_ValidationError_OrponsInvalid::MergeFrom(const SubscriptionFilter_ValidationError_OrponsInvalid& from) {
  SubscriptionFilter_ValidationError_OrponsInvalid* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

void SubscriptionFilter_ValidationError_OrponsInvalid::CopyFrom(const SubscriptionFilter_ValidationError_OrponsInvalid& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SubscriptionFilter_ValidationError_OrponsInvalid::GetTypeName() const {
  return "keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid";
}

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

class SubscriptionFilter_ValidationError_FlatNumbersInvalid::_Internal {
 public:
};

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

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

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

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

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

void SubscriptionFilter_ValidationError_FlatNumbersInvalid::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

::uint8_t* SubscriptionFilter_ValidationError_FlatNumbersInvalid::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

::size_t SubscriptionFilter_ValidationError_FlatNumbersInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid)
  ::size_t total_size = 0;

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

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

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

void SubscriptionFilter_ValidationError_FlatNumbersInvalid::MergeFrom(const SubscriptionFilter_ValidationError_FlatNumbersInvalid& from) {
  SubscriptionFilter_ValidationError_FlatNumbersInvalid* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

void SubscriptionFilter_ValidationError_FlatNumbersInvalid::CopyFrom(const SubscriptionFilter_ValidationError_FlatNumbersInvalid& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SubscriptionFilter_ValidationError_FlatNumbersInvalid::GetTypeName() const {
  return "keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid";
}

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

class SubscriptionFilter_ValidationError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::subscription::v1::SubscriptionFilter_ValidationError, _impl_._oneof_case_);
  static const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid& orpons(const SubscriptionFilter_ValidationError* msg);
  static const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid& flat_numbers(const SubscriptionFilter_ValidationError* msg);
};

const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid&
SubscriptionFilter_ValidationError::_Internal::orpons(const SubscriptionFilter_ValidationError* msg) {
  return *msg->_impl_.reason_.orpons_;
}
const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid&
SubscriptionFilter_ValidationError::_Internal::flat_numbers(const SubscriptionFilter_ValidationError* msg) {
  return *msg->_impl_.reason_.flat_numbers_;
}
void SubscriptionFilter_ValidationError::set_allocated_orpons(::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid* orpons) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (orpons) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(orpons);
    if (message_arena != submessage_arena) {
      orpons = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orpons, submessage_arena);
    }
    set_has_orpons();
    _impl_.reason_.orpons_ = orpons;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.SubscriptionFilter.ValidationError.orpons)
}
void SubscriptionFilter_ValidationError::set_allocated_flat_numbers(::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid* flat_numbers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (flat_numbers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(flat_numbers);
    if (message_arena != submessage_arena) {
      flat_numbers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flat_numbers, submessage_arena);
    }
    set_has_flat_numbers();
    _impl_.reason_.flat_numbers_ = flat_numbers;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.SubscriptionFilter.ValidationError.flat_numbers)
}
SubscriptionFilter_ValidationError::SubscriptionFilter_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.subscription.v1.SubscriptionFilter.ValidationError)
}
SubscriptionFilter_ValidationError::SubscriptionFilter_ValidationError(const SubscriptionFilter_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SubscriptionFilter_ValidationError* 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 kOrpons: {
      _this->_internal_mutable_orpons()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid::MergeFrom(
          from._internal_orpons());
      break;
    }
    case kFlatNumbers: {
      _this->_internal_mutable_flat_numbers()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid::MergeFrom(
          from._internal_flat_numbers());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.subscription.v1.SubscriptionFilter.ValidationError)
}

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

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

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

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

void SubscriptionFilter_ValidationError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError)
  switch (reason_case()) {
    case kOrpons: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.orpons_;
      }
      break;
    }
    case kFlatNumbers: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.flat_numbers_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void SubscriptionFilter_ValidationError::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError)
  ::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* SubscriptionFilter_ValidationError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid orpons = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_orpons(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid flat_numbers = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_flat_numbers(), 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* SubscriptionFilter_ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kOrpons: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::orpons(this),
          _Internal::orpons(this).GetCachedSize(), target, stream);
      break;
    }
    case kFlatNumbers: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::flat_numbers(this),
          _Internal::flat_numbers(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.subscription.v1.SubscriptionFilter.ValidationError)
  return target;
}

::size_t SubscriptionFilter_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionFilter.ValidationError)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.subscription.v1.SubscriptionFilter.ValidationError.OrponsInvalid orpons = 1;
    case kOrpons: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.orpons_);
      break;
    }
    // .keyapis.subscription.v1.SubscriptionFilter.ValidationError.FlatNumbersInvalid flat_numbers = 2;
    case kFlatNumbers: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.flat_numbers_);
      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 SubscriptionFilter_ValidationError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SubscriptionFilter_ValidationError*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kOrpons: {
      _this->_internal_mutable_orpons()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid::MergeFrom(
          from._internal_orpons());
      break;
    }
    case kFlatNumbers: {
      _this->_internal_mutable_flat_numbers()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid::MergeFrom(
          from._internal_flat_numbers());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

class SubscriptionFilter::_Internal {
 public:
};

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

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

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

inline void SubscriptionFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.orpons_) { arena }
    ,/* _impl_._orpons_cached_byte_size_ = */ { 0 }

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

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

inline void SubscriptionFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.orpons_.~RepeatedField();
  _internal_mutable_flat_numbers()->~RepeatedPtrField();
}

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

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

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

const char* SubscriptionFilter::_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 int64 orpons = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_orpons(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          _internal_add_orpons(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string flat_numbers = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_flat_numbers();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // repeated int64 orpons = 1;
  {
    int byte_size = _impl_._orpons_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt64Packed(1, _internal_orpons(),
                                                 byte_size, target);
    }
  }

  // repeated string flat_numbers = 2;
  for (int i = 0, n = this->_internal_flat_numbers_size(); i < n; ++i) {
    const auto& s = this->_internal_flat_numbers(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.subscription.v1.SubscriptionFilter.flat_numbers");
    target = stream->WriteString(2, s, target);
  }

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

::size_t SubscriptionFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionFilter)
  ::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 int64 orpons = 1;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int64Size(
        this->_internal_orpons())
    ;
    _impl_._orpons_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 string flat_numbers = 2;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_flat_numbers().size());
  for (int i = 0, n = _internal_flat_numbers().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_flat_numbers().Get(i));
  }

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

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

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

  _this->_impl_.orpons_.MergeFrom(from._impl_.orpons_);
  _this->_internal_mutable_flat_numbers()->MergeFrom(from._internal_flat_numbers());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void SubscriptionFilter::InternalSwap(SubscriptionFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.orpons_.InternalSwap(&other->_impl_.orpons_);
  _internal_mutable_flat_numbers()->InternalSwap(
      other->_internal_mutable_flat_numbers());
}

std::string SubscriptionFilter::GetTypeName() const {
  return "keyapis.subscription.v1.SubscriptionFilter";
}

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

class SubscriptionPaging_ValidationError_LimitInvalid::_Internal {
 public:
};

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

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

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

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

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

void SubscriptionPaging_ValidationError_LimitInvalid::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

::uint8_t* SubscriptionPaging_ValidationError_LimitInvalid::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

::size_t SubscriptionPaging_ValidationError_LimitInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid)
  ::size_t total_size = 0;

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

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

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

void SubscriptionPaging_ValidationError_LimitInvalid::MergeFrom(const SubscriptionPaging_ValidationError_LimitInvalid& from) {
  SubscriptionPaging_ValidationError_LimitInvalid* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

void SubscriptionPaging_ValidationError_LimitInvalid::CopyFrom(const SubscriptionPaging_ValidationError_LimitInvalid& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SubscriptionPaging_ValidationError_LimitInvalid::GetTypeName() const {
  return "keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid";
}

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

class SubscriptionPaging_ValidationError_OffsetInvalid::_Internal {
 public:
};

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

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

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

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

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

void SubscriptionPaging_ValidationError_OffsetInvalid::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

::uint8_t* SubscriptionPaging_ValidationError_OffsetInvalid::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

::size_t SubscriptionPaging_ValidationError_OffsetInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid)
  ::size_t total_size = 0;

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

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

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

void SubscriptionPaging_ValidationError_OffsetInvalid::MergeFrom(const SubscriptionPaging_ValidationError_OffsetInvalid& from) {
  SubscriptionPaging_ValidationError_OffsetInvalid* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

void SubscriptionPaging_ValidationError_OffsetInvalid::CopyFrom(const SubscriptionPaging_ValidationError_OffsetInvalid& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SubscriptionPaging_ValidationError_OffsetInvalid::GetTypeName() const {
  return "keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid";
}

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

class SubscriptionPaging_ValidationError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::subscription::v1::SubscriptionPaging_ValidationError, _impl_._oneof_case_);
  static const ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid& limit(const SubscriptionPaging_ValidationError* msg);
  static const ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid& offset(const SubscriptionPaging_ValidationError* msg);
};

const ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid&
SubscriptionPaging_ValidationError::_Internal::limit(const SubscriptionPaging_ValidationError* msg) {
  return *msg->_impl_.reason_.limit_;
}
const ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid&
SubscriptionPaging_ValidationError::_Internal::offset(const SubscriptionPaging_ValidationError* msg) {
  return *msg->_impl_.reason_.offset_;
}
void SubscriptionPaging_ValidationError::set_allocated_limit(::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid* limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit);
    if (message_arena != submessage_arena) {
      limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit, submessage_arena);
    }
    set_has_limit();
    _impl_.reason_.limit_ = limit;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.SubscriptionPaging.ValidationError.limit)
}
void SubscriptionPaging_ValidationError::set_allocated_offset(::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid* offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(offset);
    if (message_arena != submessage_arena) {
      offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, offset, submessage_arena);
    }
    set_has_offset();
    _impl_.reason_.offset_ = offset;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.SubscriptionPaging.ValidationError.offset)
}
SubscriptionPaging_ValidationError::SubscriptionPaging_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.subscription.v1.SubscriptionPaging.ValidationError)
}
SubscriptionPaging_ValidationError::SubscriptionPaging_ValidationError(const SubscriptionPaging_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SubscriptionPaging_ValidationError* 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 kLimit: {
      _this->_internal_mutable_limit()->::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid::MergeFrom(
          from._internal_limit());
      break;
    }
    case kOffset: {
      _this->_internal_mutable_offset()->::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid::MergeFrom(
          from._internal_offset());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.subscription.v1.SubscriptionPaging.ValidationError)
}

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

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

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

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

void SubscriptionPaging_ValidationError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError)
  switch (reason_case()) {
    case kLimit: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.limit_;
      }
      break;
    }
    case kOffset: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.offset_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void SubscriptionPaging_ValidationError::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError)
  ::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* SubscriptionPaging_ValidationError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid limit = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_limit(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid offset = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_offset(), 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* SubscriptionPaging_ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kLimit: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::limit(this),
          _Internal::limit(this).GetCachedSize(), target, stream);
      break;
    }
    case kOffset: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::offset(this),
          _Internal::offset(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.subscription.v1.SubscriptionPaging.ValidationError)
  return target;
}

::size_t SubscriptionPaging_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.SubscriptionPaging.ValidationError)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.subscription.v1.SubscriptionPaging.ValidationError.LimitInvalid limit = 1;
    case kLimit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.limit_);
      break;
    }
    // .keyapis.subscription.v1.SubscriptionPaging.ValidationError.OffsetInvalid offset = 2;
    case kOffset: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.offset_);
      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 SubscriptionPaging_ValidationError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SubscriptionPaging_ValidationError*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kLimit: {
      _this->_internal_mutable_limit()->::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid::MergeFrom(
          from._internal_limit());
      break;
    }
    case kOffset: {
      _this->_internal_mutable_offset()->::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid::MergeFrom(
          from._internal_offset());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

class SubscriptionPaging::_Internal {
 public:
};

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

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

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

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

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

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

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

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

  // .keyapis.subscription.v1.SubscriptionPaging.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 SubscriptionPaging::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SubscriptionPaging*>(
      &from));
}

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

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

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

std::string SubscriptionPaging::GetTypeName() const {
  return "keyapis.subscription.v1.SubscriptionPaging";
}

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

class GetSubscriptionRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string GetSubscriptionRequest::GetTypeName() const {
  return "keyapis.subscription.v1.GetSubscriptionRequest";
}

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

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

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

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

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

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

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

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


void GetSubscriptionResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.GetSubscriptionResponse)
  ::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* GetSubscriptionResponse::_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.subscription.v1.Subscription data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.subscription.v1.Subscription data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

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

::size_t GetSubscriptionResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.GetSubscriptionResponse)
  ::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.subscription.v1.Subscription data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.subscription.v1.SubscriptionFilter 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.subscription.v1.SubscriptionPaging 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.subscription.v1.GetSubscriptionListRequest)
  return target;
}

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

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

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

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

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

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

class GetSubscriptionListResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::subscription::v1::GetSubscriptionListResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError& subscription_filter_validation(const GetSubscriptionListResponse_Error* msg);
  static const ::keyapis::subscription::v1::SubscriptionPaging_ValidationError& subscription_paging_validation(const GetSubscriptionListResponse_Error* msg);
};

const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError&
GetSubscriptionListResponse_Error::_Internal::subscription_filter_validation(const GetSubscriptionListResponse_Error* msg) {
  return *msg->_impl_.reason_.subscription_filter_validation_;
}
const ::keyapis::subscription::v1::SubscriptionPaging_ValidationError&
GetSubscriptionListResponse_Error::_Internal::subscription_paging_validation(const GetSubscriptionListResponse_Error* msg) {
  return *msg->_impl_.reason_.subscription_paging_validation_;
}
void GetSubscriptionListResponse_Error::set_allocated_subscription_filter_validation(::keyapis::subscription::v1::SubscriptionFilter_ValidationError* subscription_filter_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (subscription_filter_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscription_filter_validation);
    if (message_arena != submessage_arena) {
      subscription_filter_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subscription_filter_validation, submessage_arena);
    }
    set_has_subscription_filter_validation();
    _impl_.reason_.subscription_filter_validation_ = subscription_filter_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.GetSubscriptionListResponse.Error.subscription_filter_validation)
}
void GetSubscriptionListResponse_Error::set_allocated_subscription_paging_validation(::keyapis::subscription::v1::SubscriptionPaging_ValidationError* subscription_paging_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (subscription_paging_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscription_paging_validation);
    if (message_arena != submessage_arena) {
      subscription_paging_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subscription_paging_validation, submessage_arena);
    }
    set_has_subscription_paging_validation();
    _impl_.reason_.subscription_paging_validation_ = subscription_paging_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.GetSubscriptionListResponse.Error.subscription_paging_validation)
}
GetSubscriptionListResponse_Error::GetSubscriptionListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.subscription.v1.GetSubscriptionListResponse.Error)
}
GetSubscriptionListResponse_Error::GetSubscriptionListResponse_Error(const GetSubscriptionListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSubscriptionListResponse_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 kSubscriptionFilterValidation: {
      _this->_internal_mutable_subscription_filter_validation()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError::MergeFrom(
          from._internal_subscription_filter_validation());
      break;
    }
    case kSubscriptionPagingValidation: {
      _this->_internal_mutable_subscription_paging_validation()->::keyapis::subscription::v1::SubscriptionPaging_ValidationError::MergeFrom(
          from._internal_subscription_paging_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.subscription.v1.GetSubscriptionListResponse.Error)
}

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

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

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

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

void GetSubscriptionListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.subscription.v1.GetSubscriptionListResponse.Error)
  switch (reason_case()) {
    case kSubscriptionFilterValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.subscription_filter_validation_;
      }
      break;
    }
    case kSubscriptionPagingValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.subscription_paging_validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetSubscriptionListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.GetSubscriptionListResponse.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* GetSubscriptionListResponse_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.subscription.v1.SubscriptionFilter.ValidationError subscription_filter_validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_subscription_filter_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.SubscriptionPaging.ValidationError subscription_paging_validation = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_subscription_paging_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* GetSubscriptionListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.GetSubscriptionListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kSubscriptionFilterValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::subscription_filter_validation(this),
          _Internal::subscription_filter_validation(this).GetCachedSize(), target, stream);
      break;
    }
    case kSubscriptionPagingValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::subscription_paging_validation(this),
          _Internal::subscription_paging_validation(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.subscription.v1.GetSubscriptionListResponse.Error)
  return target;
}

::size_t GetSubscriptionListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.GetSubscriptionListResponse.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.subscription.v1.SubscriptionFilter.ValidationError subscription_filter_validation = 1;
    case kSubscriptionFilterValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.subscription_filter_validation_);
      break;
    }
    // .keyapis.subscription.v1.SubscriptionPaging.ValidationError subscription_paging_validation = 2;
    case kSubscriptionPagingValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.subscription_paging_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 GetSubscriptionListResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSubscriptionListResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kSubscriptionFilterValidation: {
      _this->_internal_mutable_subscription_filter_validation()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError::MergeFrom(
          from._internal_subscription_filter_validation());
      break;
    }
    case kSubscriptionPagingValidation: {
      _this->_internal_mutable_subscription_paging_validation()->::keyapis::subscription::v1::SubscriptionPaging_ValidationError::MergeFrom(
          from._internal_subscription_paging_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetSubscriptionListResponse_Error::InternalSwap(GetSubscriptionListResponse_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 GetSubscriptionListResponse_Error::GetTypeName() const {
  return "keyapis.subscription.v1.GetSubscriptionListResponse.Error";
}

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

class GetSubscriptionListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::subscription::v1::GetSubscriptionListResponse, _impl_._oneof_case_);
  static const ::keyapis::subscription::v1::Subscription& data(const GetSubscriptionListResponse* msg);
  static const ::keyapis::subscription::v1::GetSubscriptionListResponse_Error& error(const GetSubscriptionListResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class GetSubscriptionCountResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::subscription::v1::GetSubscriptionCountResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError& subscription_filter_validation(const GetSubscriptionCountResponse_Error* msg);
};

const ::keyapis::subscription::v1::SubscriptionFilter_ValidationError&
GetSubscriptionCountResponse_Error::_Internal::subscription_filter_validation(const GetSubscriptionCountResponse_Error* msg) {
  return *msg->_impl_.reason_.subscription_filter_validation_;
}
void GetSubscriptionCountResponse_Error::set_allocated_subscription_filter_validation(::keyapis::subscription::v1::SubscriptionFilter_ValidationError* subscription_filter_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (subscription_filter_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscription_filter_validation);
    if (message_arena != submessage_arena) {
      subscription_filter_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subscription_filter_validation, submessage_arena);
    }
    set_has_subscription_filter_validation();
    _impl_.reason_.subscription_filter_validation_ = subscription_filter_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.subscription.v1.GetSubscriptionCountResponse.Error.subscription_filter_validation)
}
GetSubscriptionCountResponse_Error::GetSubscriptionCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.subscription.v1.GetSubscriptionCountResponse.Error)
}
GetSubscriptionCountResponse_Error::GetSubscriptionCountResponse_Error(const GetSubscriptionCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSubscriptionCountResponse_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 kSubscriptionFilterValidation: {
      _this->_internal_mutable_subscription_filter_validation()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError::MergeFrom(
          from._internal_subscription_filter_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.subscription.v1.GetSubscriptionCountResponse.Error)
}

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

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

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

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

void GetSubscriptionCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.subscription.v1.GetSubscriptionCountResponse.Error)
  switch (reason_case()) {
    case kSubscriptionFilterValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.subscription_filter_validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetSubscriptionCountResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.GetSubscriptionCountResponse.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* GetSubscriptionCountResponse_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.subscription.v1.SubscriptionFilter.ValidationError subscription_filter_validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_subscription_filter_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* GetSubscriptionCountResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.GetSubscriptionCountResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.subscription.v1.SubscriptionFilter.ValidationError subscription_filter_validation = 1;
  if (reason_case() == kSubscriptionFilterValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::subscription_filter_validation(this),
        _Internal::subscription_filter_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.subscription.v1.GetSubscriptionCountResponse.Error)
  return target;
}

::size_t GetSubscriptionCountResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.subscription.v1.GetSubscriptionCountResponse.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.subscription.v1.SubscriptionFilter.ValidationError subscription_filter_validation = 1;
    case kSubscriptionFilterValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.subscription_filter_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 GetSubscriptionCountResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSubscriptionCountResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kSubscriptionFilterValidation: {
      _this->_internal_mutable_subscription_filter_validation()->::keyapis::subscription::v1::SubscriptionFilter_ValidationError::MergeFrom(
          from._internal_subscription_filter_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetSubscriptionCountResponse_Error::InternalSwap(GetSubscriptionCountResponse_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 GetSubscriptionCountResponse_Error::GetTypeName() const {
  return "keyapis.subscription.v1.GetSubscriptionCountResponse.Error";
}

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

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

const ::keyapis::subscription::v1::GetSubscriptionCountResponse_Error&
GetSubscriptionCountResponse::_Internal::error(const GetSubscriptionCountResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetSubscriptionCountResponse::set_allocated_error(::keyapis::subscription::v1::GetSubscriptionCountResponse_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.subscription.v1.GetSubscriptionCountResponse.error)
}
GetSubscriptionCountResponse::GetSubscriptionCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.subscription.v1.GetSubscriptionCountResponse)
}
GetSubscriptionCountResponse::GetSubscriptionCountResponse(const GetSubscriptionCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSubscriptionCountResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::subscription::v1::GetSubscriptionCountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.subscription.v1.GetSubscriptionCountResponse)
}

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

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

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

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

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


void GetSubscriptionCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.subscription.v1.GetSubscriptionCountResponse)
  ::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* GetSubscriptionCountResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.subscription.v1.GetSubscriptionCountResponse.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* GetSubscriptionCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.subscription.v1.GetSubscriptionCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    // .keyapis.subscription.v1.GetSubscriptionCountResponse.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 GetSubscriptionCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSubscriptionCountResponse*>(
      &from));
}

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

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

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

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

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace subscription
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::Subscription*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::Subscription >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::Subscription >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_OrponsInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionFilter_ValidationError_FlatNumbersInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionFilter_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionFilter_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionFilter_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionFilter*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_LimitInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionPaging_ValidationError_OffsetInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionPaging_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionPaging_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionPaging_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::SubscriptionPaging*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::SubscriptionPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::SubscriptionPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionRequest*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionResponse*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionListRequest*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionListResponse*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionCountRequest*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::subscription::v1::GetSubscriptionCountResponse*
Arena::CreateMaybeMessage< ::keyapis::subscription::v1::GetSubscriptionCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::subscription::v1::GetSubscriptionCountResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"