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

#include "keyapis/ad/v1/keyapis_ad_salepoint_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 ad {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR Salepoint_Location::Salepoint_Location(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.latitude_)*/ 0

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Salepoint_LocationDefaultTypeInternal _Salepoint_Location_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR Salepoint_Worktime::Salepoint_Worktime(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.opened_at_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Salepoint_WorktimeDefaultTypeInternal _Salepoint_Worktime_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR Salepoint::Salepoint(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.worktimes_)*/{}
  , /*decltype(_impl_.title_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

  , /*decltype(_impl_.description_)*/nullptr
  , /*decltype(_impl_.location_)*/nullptr
  , /*decltype(_impl_.phone_number_)*/nullptr
  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.archieved_at_)*/nullptr
  , /*decltype(_impl_.id_)*/ 0

  , /*decltype(_impl_.type_)*/ 0
} {}
struct SalepointDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SalepointDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SalepointDefaultTypeInternal() {}
  union {
    Salepoint _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SalepointDefaultTypeInternal _Salepoint_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SalepointFilter_Location::SalepointFilter_Location(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.latitude_)*/ 0

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SalepointFilter_LocationDefaultTypeInternal _SalepointFilter_Location_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SalepointFilter::SalepointFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.text_)*/nullptr
  , /*decltype(_impl_.location_)*/nullptr
  , /*decltype(_impl_.distance_)*/nullptr
  , /*decltype(_impl_.is_archieved_)*/nullptr} {}
struct SalepointFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SalepointFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SalepointFilterDefaultTypeInternal() {}
  union {
    SalepointFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SalepointFilterDefaultTypeInternal _SalepointFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SalepointPaging::SalepointPaging(
    ::_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 SalepointPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SalepointPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SalepointPagingDefaultTypeInternal() {}
  union {
    SalepointPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SalepointPagingDefaultTypeInternal _SalepointPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostSalepointRequest::PostSalepointRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostSalepointRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostSalepointRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostSalepointRequestDefaultTypeInternal() {}
  union {
    PostSalepointRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostSalepointRequestDefaultTypeInternal _PostSalepointRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostSalepointResponse::PostSalepointResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostSalepointResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostSalepointResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostSalepointResponseDefaultTypeInternal() {}
  union {
    PostSalepointResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostSalepointResponseDefaultTypeInternal _PostSalepointResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSalepointRequest::GetSalepointRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSalepointRequestDefaultTypeInternal _GetSalepointRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSalepointResponse::GetSalepointResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSalepointResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSalepointResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSalepointResponseDefaultTypeInternal() {}
  union {
    GetSalepointResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSalepointListRequestDefaultTypeInternal _GetSalepointListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSalepointListResponse::GetSalepointListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSalepointListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSalepointListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSalepointListResponseDefaultTypeInternal() {}
  union {
    GetSalepointListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSalepointListResponseDefaultTypeInternal _GetSalepointListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSalepointCountRequest::GetSalepointCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetSalepointCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSalepointCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSalepointCountRequestDefaultTypeInternal() {}
  union {
    GetSalepointCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSalepointCountRequestDefaultTypeInternal _GetSalepointCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSalepointCountResponse::GetSalepointCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSalepointCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSalepointCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSalepointCountResponseDefaultTypeInternal() {}
  union {
    GetSalepointCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSalepointCountResponseDefaultTypeInternal _GetSalepointCountResponse_default_instance_;
}  // namespace v1
}  // namespace ad
}  // namespace keyapis
namespace keyapis {
namespace ad {
namespace v1 {
bool Salepoint_Worktime_DayType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    Salepoint_Worktime_DayType_strings[8] = {};

static const char Salepoint_Worktime_DayType_names[] = {
    "DAY_TYPE_UNKNOWN"
    "FRIDAY"
    "MONDAY"
    "SATURDAY"
    "SUNDAY"
    "THURSDAY"
    "TUESDAY"
    "WEDNESDAY"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Salepoint_Worktime_DayType_entries[] =
    {
        {{&Salepoint_Worktime_DayType_names[0], 16}, 0},
        {{&Salepoint_Worktime_DayType_names[16], 6}, 5},
        {{&Salepoint_Worktime_DayType_names[22], 6}, 1},
        {{&Salepoint_Worktime_DayType_names[28], 8}, 6},
        {{&Salepoint_Worktime_DayType_names[36], 6}, 7},
        {{&Salepoint_Worktime_DayType_names[42], 8}, 4},
        {{&Salepoint_Worktime_DayType_names[50], 7}, 2},
        {{&Salepoint_Worktime_DayType_names[57], 9}, 3},
};

static const int Salepoint_Worktime_DayType_entries_by_number[] = {
    0,  // 0 -> DAY_TYPE_UNKNOWN
    2,  // 1 -> MONDAY
    6,  // 2 -> TUESDAY
    7,  // 3 -> WEDNESDAY
    5,  // 4 -> THURSDAY
    1,  // 5 -> FRIDAY
    3,  // 6 -> SATURDAY
    4,  // 7 -> SUNDAY
};

const std::string& Salepoint_Worktime_DayType_Name(Salepoint_Worktime_DayType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Salepoint_Worktime_DayType_entries, Salepoint_Worktime_DayType_entries_by_number,
          8, Salepoint_Worktime_DayType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Salepoint_Worktime_DayType_entries, Salepoint_Worktime_DayType_entries_by_number, 8,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : Salepoint_Worktime_DayType_strings[idx].get();
}

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

constexpr Salepoint_Worktime_DayType Salepoint_Worktime::DAY_TYPE_UNKNOWN;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::MONDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::TUESDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::WEDNESDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::THURSDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::FRIDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::SATURDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::SUNDAY;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::DayType_MIN;
constexpr Salepoint_Worktime_DayType Salepoint_Worktime::DayType_MAX;
constexpr int Salepoint_Worktime::DayType_ARRAYSIZE;

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

static const char Salepoint_Type_names[] = {
    "ANOTHER"
    "MEGAFON"
    "PEREKRESTOK"
    "POCHTA_ROSSII"
    "PYATEROCHKA"
    "TELE2"
    "TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Salepoint_Type_entries[] =
    {
        {{&Salepoint_Type_names[0], 7}, 5},
        {{&Salepoint_Type_names[7], 7}, 6},
        {{&Salepoint_Type_names[14], 11}, 3},
        {{&Salepoint_Type_names[25], 13}, 2},
        {{&Salepoint_Type_names[38], 11}, 4},
        {{&Salepoint_Type_names[49], 5}, 1},
        {{&Salepoint_Type_names[54], 12}, 0},
};

static const int Salepoint_Type_entries_by_number[] = {
    6,  // 0 -> TYPE_UNKNOWN
    5,  // 1 -> TELE2
    3,  // 2 -> POCHTA_ROSSII
    2,  // 3 -> PEREKRESTOK
    4,  // 4 -> PYATEROCHKA
    0,  // 5 -> ANOTHER
    1,  // 6 -> MEGAFON
};

const std::string& Salepoint_Type_Name(Salepoint_Type value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Salepoint_Type_entries, Salepoint_Type_entries_by_number,
          7, Salepoint_Type_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Salepoint_Type_entries, Salepoint_Type_entries_by_number, 7,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : Salepoint_Type_strings[idx].get();
}

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

constexpr Salepoint_Type Salepoint::TYPE_UNKNOWN;
constexpr Salepoint_Type Salepoint::TELE2;
constexpr Salepoint_Type Salepoint::POCHTA_ROSSII;
constexpr Salepoint_Type Salepoint::PEREKRESTOK;
constexpr Salepoint_Type Salepoint::PYATEROCHKA;
constexpr Salepoint_Type Salepoint::ANOTHER;
constexpr Salepoint_Type Salepoint::MEGAFON;
constexpr Salepoint_Type Salepoint::Type_MIN;
constexpr Salepoint_Type Salepoint::Type_MAX;
constexpr int Salepoint::Type_ARRAYSIZE;

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

static const char SalepointPaging_OrderByType_names[] = {
    "DISTANCE"
    "ID"
    "ORDER_BY_TYPE_UNKNOWN"
    "RANK_CD"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SalepointPaging_OrderByType_entries[] =
    {
        {{&SalepointPaging_OrderByType_names[0], 8}, 2},
        {{&SalepointPaging_OrderByType_names[8], 2}, 1},
        {{&SalepointPaging_OrderByType_names[10], 21}, 0},
        {{&SalepointPaging_OrderByType_names[31], 7}, 3},
};

static const int SalepointPaging_OrderByType_entries_by_number[] = {
    2,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    1,  // 1 -> ID
    0,  // 2 -> DISTANCE
    3,  // 3 -> RANK_CD
};

const std::string& SalepointPaging_OrderByType_Name(SalepointPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SalepointPaging_OrderByType_entries, SalepointPaging_OrderByType_entries_by_number,
          4, SalepointPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SalepointPaging_OrderByType_entries, SalepointPaging_OrderByType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : SalepointPaging_OrderByType_strings[idx].get();
}

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

constexpr SalepointPaging_OrderByType SalepointPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr SalepointPaging_OrderByType SalepointPaging::ID;
constexpr SalepointPaging_OrderByType SalepointPaging::DISTANCE;
constexpr SalepointPaging_OrderByType SalepointPaging::RANK_CD;
constexpr SalepointPaging_OrderByType SalepointPaging::OrderByType_MIN;
constexpr SalepointPaging_OrderByType SalepointPaging::OrderByType_MAX;
constexpr int SalepointPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& SalepointPaging_DirectionType_Name(SalepointPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          SalepointPaging_DirectionType_entries, SalepointPaging_DirectionType_entries_by_number,
          3, SalepointPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      SalepointPaging_DirectionType_entries, SalepointPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : SalepointPaging_DirectionType_strings[idx].get();
}

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

constexpr SalepointPaging_DirectionType SalepointPaging::DIRECTION_TYPE_UNKNOWN;
constexpr SalepointPaging_DirectionType SalepointPaging::DESC;
constexpr SalepointPaging_DirectionType SalepointPaging::ASC;
constexpr SalepointPaging_DirectionType SalepointPaging::DirectionType_MIN;
constexpr SalepointPaging_DirectionType SalepointPaging::DirectionType_MAX;
constexpr int SalepointPaging::DirectionType_ARRAYSIZE;

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

class Salepoint_Location::_Internal {
 public:
};

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

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

    , decltype(_impl_.longitude_) { 0 }

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

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

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

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

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

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

const char* Salepoint_Location::_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) {
      // float latitude = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) {
          _impl_.latitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else {
          goto handle_unusual;
        }
        continue;
      // float longitude = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 21)) {
          _impl_.longitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } 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* Salepoint_Location::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.ad.v1.Salepoint.Location)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // float latitude = 1 [(.google.api.field_behavior) = REQUIRED];
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_latitude = this->_internal_latitude();
  ::uint32_t raw_latitude;
  memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude));
  if (raw_latitude != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        1, this->_internal_latitude(), target);
  }

  // float longitude = 2 [(.google.api.field_behavior) = REQUIRED];
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_longitude = this->_internal_longitude();
  ::uint32_t raw_longitude;
  memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude));
  if (raw_longitude != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        2, this->_internal_longitude(), 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.ad.v1.Salepoint.Location)
  return target;
}

::size_t Salepoint_Location::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.ad.v1.Salepoint.Location)
  ::size_t total_size = 0;

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

  // float latitude = 1 [(.google.api.field_behavior) = REQUIRED];
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_latitude = this->_internal_latitude();
  ::uint32_t raw_latitude;
  memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude));
  if (raw_latitude != 0) {
    total_size += 5;
  }

  // float longitude = 2 [(.google.api.field_behavior) = REQUIRED];
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_longitude = this->_internal_longitude();
  ::uint32_t raw_longitude;
  memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude));
  if (raw_longitude != 0) {
    total_size += 5;
  }

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

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

  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_latitude = from._internal_latitude();
  ::uint32_t raw_latitude;
  memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude));
  if (raw_latitude != 0) {
    _this->_internal_set_latitude(from._internal_latitude());
  }
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_longitude = from._internal_longitude();
  ::uint32_t raw_longitude;
  memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude));
  if (raw_longitude != 0) {
    _this->_internal_set_longitude(from._internal_longitude());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string Salepoint_Location::GetTypeName() const {
  return "keyapis.ad.v1.Salepoint.Location";
}

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

class Salepoint_Worktime::_Internal {
 public:
};

Salepoint_Worktime::Salepoint_Worktime(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.ad.v1.Salepoint.Worktime)
}
Salepoint_Worktime::Salepoint_Worktime(const Salepoint_Worktime& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Salepoint_Worktime* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.opened_at_) {}

    , decltype(_impl_.closed_at_) {}

    , decltype(_impl_.day_type_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.opened_at_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.opened_at_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_opened_at().empty()) {
    _this->_impl_.opened_at_.Set(from._internal_opened_at(), _this->GetArenaForAllocation());
  }
  _impl_.closed_at_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.closed_at_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_closed_at().empty()) {
    _this->_impl_.closed_at_.Set(from._internal_closed_at(), _this->GetArenaForAllocation());
  }
  _this->_impl_.day_type_ = from._impl_.day_type_;
  // @@protoc_insertion_point(copy_constructor:keyapis.ad.v1.Salepoint.Worktime)
}

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

    , decltype(_impl_.closed_at_) {}

    , decltype(_impl_.day_type_) { 0 }

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

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

inline void Salepoint_Worktime::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.opened_at_.Destroy();
  _impl_.closed_at_.Destroy();
}

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

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

  _impl_.opened_at_.ClearToEmpty();
  _impl_.closed_at_.ClearToEmpty();
  _impl_.day_type_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* Salepoint_Worktime::_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.ad.v1.Salepoint.Worktime.DayType day_type = 1 [(.google.api.field_behavior) = REQUIRED];
      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_day_type(static_cast<::keyapis::ad::v1::Salepoint_Worktime_DayType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // string opened_at = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_opened_at();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string closed_at = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_closed_at();
          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* Salepoint_Worktime::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.ad.v1.Salepoint.Worktime)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.ad.v1.Salepoint.Worktime.DayType day_type = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_day_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_day_type(), target);
  }

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

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

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

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

  // .keyapis.ad.v1.Salepoint.Worktime.DayType day_type = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_day_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_day_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 Salepoint_Worktime::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Salepoint_Worktime*>(
      &from));
}

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

  if (!from._internal_opened_at().empty()) {
    _this->_internal_set_opened_at(from._internal_opened_at());
  }
  if (!from._internal_closed_at().empty()) {
    _this->_internal_set_closed_at(from._internal_closed_at());
  }
  if (from._internal_day_type() != 0) {
    _this->_internal_set_day_type(from._internal_day_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string Salepoint_Worktime::GetTypeName() const {
  return "keyapis.ad.v1.Salepoint.Worktime";
}

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

class Salepoint::_Internal {
 public:
  using HasBits = decltype(std::declval<Salepoint>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(Salepoint, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& description(const Salepoint* msg);
  static void set_has_description(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::ad::v1::Salepoint_Location& location(const Salepoint* msg);
  static void set_has_location(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& phone_number(const Salepoint* msg);
  static void set_has_phone_number(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at(const Salepoint* msg);
  static void set_has_created_at(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at(const Salepoint* msg);
  static void set_has_changed_at(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& archieved_at(const Salepoint* msg);
  static void set_has_archieved_at(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::StringValue&
Salepoint::_Internal::description(const Salepoint* msg) {
  return *msg->_impl_.description_;
}
const ::keyapis::ad::v1::Salepoint_Location&
Salepoint::_Internal::location(const Salepoint* msg) {
  return *msg->_impl_.location_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
Salepoint::_Internal::phone_number(const Salepoint* msg) {
  return *msg->_impl_.phone_number_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Salepoint::_Internal::created_at(const Salepoint* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Salepoint::_Internal::changed_at(const Salepoint* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
Salepoint::_Internal::archieved_at(const Salepoint* msg) {
  return *msg->_impl_.archieved_at_;
}
void Salepoint::clear_description() {
  if (_impl_.description_ != nullptr) _impl_.description_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void Salepoint::clear_phone_number() {
  if (_impl_.phone_number_ != nullptr) _impl_.phone_number_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void Salepoint::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
void Salepoint::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
void Salepoint::clear_archieved_at() {
  if (_impl_.archieved_at_ != nullptr) _impl_.archieved_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
Salepoint::Salepoint(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.ad.v1.Salepoint)
}
Salepoint::Salepoint(const Salepoint& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  Salepoint* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.worktimes_){from._impl_.worktimes_}
    , decltype(_impl_.title_) {}

    , decltype(_impl_.address_) {}

    , decltype(_impl_.site_url_) {}

    , decltype(_impl_.description_){nullptr}
    , decltype(_impl_.location_){nullptr}
    , decltype(_impl_.phone_number_){nullptr}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.archieved_at_){nullptr}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.type_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_title().empty()) {
    _this->_impl_.title_.Set(from._internal_title(), _this->GetArenaForAllocation());
  }
  _impl_.address_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.address_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_address().empty()) {
    _this->_impl_.address_.Set(from._internal_address(), _this->GetArenaForAllocation());
  }
  _impl_.site_url_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.site_url_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_site_url().empty()) {
    _this->_impl_.site_url_.Set(from._internal_site_url(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.description_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.description_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.location_ = new ::keyapis::ad::v1::Salepoint_Location(*from._impl_.location_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.phone_number_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.phone_number_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) {
    _this->_impl_.archieved_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.archieved_at_);
  }
  ::memcpy(&_impl_.id_, &from._impl_.id_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.type_) -
    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.type_));
  // @@protoc_insertion_point(copy_constructor:keyapis.ad.v1.Salepoint)
}

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

    , decltype(_impl_.address_) {}

    , decltype(_impl_.site_url_) {}

    , decltype(_impl_.description_){nullptr}
    , decltype(_impl_.location_){nullptr}
    , decltype(_impl_.phone_number_){nullptr}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.archieved_at_){nullptr}
    , decltype(_impl_.id_) { 0 }

    , decltype(_impl_.type_) { 0 }

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

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

inline void Salepoint::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_worktimes()->~RepeatedPtrField();
  _impl_.title_.Destroy();
  _impl_.address_.Destroy();
  _impl_.site_url_.Destroy();
  if (this != internal_default_instance()) delete _impl_.description_;
  if (this != internal_default_instance()) delete _impl_.location_;
  if (this != internal_default_instance()) delete _impl_.phone_number_;
  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_.archieved_at_;
}

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

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

  _internal_mutable_worktimes()->Clear();
  _impl_.title_.ClearToEmpty();
  _impl_.address_.ClearToEmpty();
  _impl_.site_url_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.description_ != nullptr);
      _impl_.description_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.location_ != nullptr);
      _impl_.location_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.phone_number_ != nullptr);
      _impl_.phone_number_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      ABSL_DCHECK(_impl_.archieved_at_ != nullptr);
      _impl_.archieved_at_->Clear();
    }
  }
  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.type_) -
      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.type_));
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* Salepoint::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string title = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_title();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.ad.v1.Salepoint.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::keyapis::ad::v1::Salepoint_Type>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue description = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string address = 5 [(.google.api.field_behavior) = REQUIRED];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          auto str = _internal_mutable_address();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.ad.v1.Salepoint.Location location = 6 [(.google.api.field_behavior) = REQUIRED];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_location(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.ad.v1.Salepoint.Worktime worktimes = 7 [(.google.api.field_behavior) = REQUIRED];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_worktimes(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue phone_number = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_phone_number(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string site_url = 9 [(.google.api.field_behavior) = REQUIRED];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
          auto str = _internal_mutable_site_url();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 10 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 11 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp archieved_at = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_archieved_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // int32 id = 1;
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), target);
  }

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

  // .keyapis.ad.v1.Salepoint.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        3, this->_internal_type(), target);
  }

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

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

  // .keyapis.ad.v1.Salepoint.Location location = 6 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::location(this),
        _Internal::location(this).GetCachedSize(), target, stream);
  }

  // repeated .keyapis.ad.v1.Salepoint.Worktime worktimes = 7 [(.google.api.field_behavior) = REQUIRED];
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_worktimes_size()); i < n; i++) {
    const auto& repfield = this->_internal_worktimes(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(7, repfield, repfield.GetCachedSize(), target, stream);
  }

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

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

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

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

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

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

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

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

  // repeated .keyapis.ad.v1.Salepoint.Worktime worktimes = 7 [(.google.api.field_behavior) = REQUIRED];
  total_size += 1UL * this->_internal_worktimes_size();
  for (const auto& msg : this->_internal_worktimes()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // .google.protobuf.StringValue description = 4;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.description_);
    }

    // .keyapis.ad.v1.Salepoint.Location location = 6 [(.google.api.field_behavior) = REQUIRED];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.location_);
    }

    // .google.protobuf.StringValue phone_number = 8;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.phone_number_);
    }

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

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

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

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

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

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

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

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

  _this->_internal_mutable_worktimes()->MergeFrom(from._internal_worktimes());
  if (!from._internal_title().empty()) {
    _this->_internal_set_title(from._internal_title());
  }
  if (!from._internal_address().empty()) {
    _this->_internal_set_address(from._internal_address());
  }
  if (!from._internal_site_url().empty()) {
    _this->_internal_set_site_url(from._internal_site_url());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_description()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_description());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_location()->::keyapis::ad::v1::Salepoint_Location::MergeFrom(
          from._internal_location());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_phone_number()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_phone_number());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_internal_mutable_archieved_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_archieved_at());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  if (from._internal_type() != 0) {
    _this->_internal_set_type(from._internal_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string Salepoint::GetTypeName() const {
  return "keyapis.ad.v1.Salepoint";
}

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

class SalepointFilter_Location::_Internal {
 public:
};

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

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

    , decltype(_impl_.longitude_) { 0 }

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

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

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

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

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

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

const char* SalepointFilter_Location::_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) {
      // float latitude = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) {
          _impl_.latitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else {
          goto handle_unusual;
        }
        continue;
      // float longitude = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 21)) {
          _impl_.longitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } 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* SalepointFilter_Location::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.ad.v1.SalepointFilter.Location)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // float latitude = 1;
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_latitude = this->_internal_latitude();
  ::uint32_t raw_latitude;
  memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude));
  if (raw_latitude != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        1, this->_internal_latitude(), target);
  }

  // float longitude = 2;
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_longitude = this->_internal_longitude();
  ::uint32_t raw_longitude;
  memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude));
  if (raw_longitude != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        2, this->_internal_longitude(), 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.ad.v1.SalepointFilter.Location)
  return target;
}

::size_t SalepointFilter_Location::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.ad.v1.SalepointFilter.Location)
  ::size_t total_size = 0;

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

  // float latitude = 1;
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_latitude = this->_internal_latitude();
  ::uint32_t raw_latitude;
  memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude));
  if (raw_latitude != 0) {
    total_size += 5;
  }

  // float longitude = 2;
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_longitude = this->_internal_longitude();
  ::uint32_t raw_longitude;
  memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude));
  if (raw_longitude != 0) {
    total_size += 5;
  }

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

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

  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_latitude = from._internal_latitude();
  ::uint32_t raw_latitude;
  memcpy(&raw_latitude, &tmp_latitude, sizeof(tmp_latitude));
  if (raw_latitude != 0) {
    _this->_internal_set_latitude(from._internal_latitude());
  }
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_longitude = from._internal_longitude();
  ::uint32_t raw_longitude;
  memcpy(&raw_longitude, &tmp_longitude, sizeof(tmp_longitude));
  if (raw_longitude != 0) {
    _this->_internal_set_longitude(from._internal_longitude());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string SalepointFilter_Location::GetTypeName() const {
  return "keyapis.ad.v1.SalepointFilter.Location";
}

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

class SalepointFilter::_Internal {
 public:
  using HasBits = decltype(std::declval<SalepointFilter>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(SalepointFilter, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& text(const SalepointFilter* msg);
  static void set_has_text(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::ad::v1::SalepointFilter_Location& location(const SalepointFilter* msg);
  static void set_has_location(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::FloatValue& distance(const SalepointFilter* msg);
  static void set_has_distance(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::BoolValue& is_archieved(const SalepointFilter* msg);
  static void set_has_is_archieved(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::StringValue&
SalepointFilter::_Internal::text(const SalepointFilter* msg) {
  return *msg->_impl_.text_;
}
const ::keyapis::ad::v1::SalepointFilter_Location&
SalepointFilter::_Internal::location(const SalepointFilter* msg) {
  return *msg->_impl_.location_;
}
const ::PROTOBUF_NAMESPACE_ID::FloatValue&
SalepointFilter::_Internal::distance(const SalepointFilter* msg) {
  return *msg->_impl_.distance_;
}
const ::PROTOBUF_NAMESPACE_ID::BoolValue&
SalepointFilter::_Internal::is_archieved(const SalepointFilter* msg) {
  return *msg->_impl_.is_archieved_;
}
void SalepointFilter::clear_text() {
  if (_impl_.text_ != nullptr) _impl_.text_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void SalepointFilter::clear_distance() {
  if (_impl_.distance_ != nullptr) _impl_.distance_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void SalepointFilter::clear_is_archieved() {
  if (_impl_.is_archieved_ != nullptr) _impl_.is_archieved_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
SalepointFilter::SalepointFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.ad.v1.SalepointFilter)
}
SalepointFilter::SalepointFilter(const SalepointFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SalepointFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.text_){nullptr}
    , decltype(_impl_.location_){nullptr}
    , decltype(_impl_.distance_){nullptr}
    , decltype(_impl_.is_archieved_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.text_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.text_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.location_ = new ::keyapis::ad::v1::SalepointFilter_Location(*from._impl_.location_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.distance_ = new ::PROTOBUF_NAMESPACE_ID::FloatValue(*from._impl_.distance_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.is_archieved_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.is_archieved_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.ad.v1.SalepointFilter)
}

inline void SalepointFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.text_){nullptr}
    , decltype(_impl_.location_){nullptr}
    , decltype(_impl_.distance_){nullptr}
    , decltype(_impl_.is_archieved_){nullptr}
  };
}

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

inline void SalepointFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.text_;
  if (this != internal_default_instance()) delete _impl_.location_;
  if (this != internal_default_instance()) delete _impl_.distance_;
  if (this != internal_default_instance()) delete _impl_.is_archieved_;
}

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

void SalepointFilter::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.ad.v1.SalepointFilter)
  ::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 & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.text_ != nullptr);
      _impl_.text_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.location_ != nullptr);
      _impl_.location_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.distance_ != nullptr);
      _impl_.distance_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.is_archieved_ != nullptr);
      _impl_.is_archieved_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* SalepointFilter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .google.protobuf.StringValue text = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_text(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.ad.v1.SalepointFilter.Location location = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_location(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.FloatValue distance = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_distance(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.BoolValue is_archieved = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_is_archieved(), 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* SalepointFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.ad.v1.SalepointFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

  // .keyapis.ad.v1.SalepointFilter.Location location = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::location(this),
        _Internal::location(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.FloatValue distance = 3;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::distance(this),
        _Internal::distance(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.BoolValue is_archieved = 4;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::is_archieved(this),
        _Internal::is_archieved(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.ad.v1.SalepointFilter)
  return target;
}

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

  ::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 & 0x0000000fu) {
    // .google.protobuf.StringValue text = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.text_);
    }

    // .keyapis.ad.v1.SalepointFilter.Location location = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.location_);
    }

    // .google.protobuf.FloatValue distance = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.distance_);
    }

    // .google.protobuf.BoolValue is_archieved = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.is_archieved_);
    }

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

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

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_text()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_text());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_location()->::keyapis::ad::v1::SalepointFilter_Location::MergeFrom(
          from._internal_location());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_distance()->::PROTOBUF_NAMESPACE_ID::FloatValue::MergeFrom(
          from._internal_distance());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_is_archieved()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom(
          from._internal_is_archieved());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void SalepointFilter::InternalSwap(SalepointFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SalepointFilter, _impl_.is_archieved_)
      + sizeof(SalepointFilter::_impl_.is_archieved_)
      - PROTOBUF_FIELD_OFFSET(SalepointFilter, _impl_.text_)>(
          reinterpret_cast<char*>(&_impl_.text_),
          reinterpret_cast<char*>(&other->_impl_.text_));
}

std::string SalepointFilter::GetTypeName() const {
  return "keyapis.ad.v1.SalepointFilter";
}

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

class SalepointPaging::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

std::string SalepointPaging::GetTypeName() const {
  return "keyapis.ad.v1.SalepointPaging";
}

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

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

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

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

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

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

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

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

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

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

const char* PostSalepointRequest::_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.ad.v1.Salepoint data = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

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

::size_t PostSalepointRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.ad.v1.PostSalepointRequest)
  ::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.ad.v1.Salepoint data = 1 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.data_);
  }

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

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

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

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_data()->::keyapis::ad::v1::Salepoint::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PostSalepointRequest::GetTypeName() const {
  return "keyapis.ad.v1.PostSalepointRequest";
}

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

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

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

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

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

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

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

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

  // .keyapis.ad.v1.Salepoint 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.ad.v1.PostSalepointResponse)
  return target;
}

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

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

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

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

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

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

class GetSalepointRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string GetSalepointRequest::GetTypeName() const {
  return "keyapis.ad.v1.GetSalepointRequest";
}

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

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

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

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

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

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

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

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

  // .keyapis.ad.v1.Salepoint 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.ad.v1.GetSalepointResponse)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.ad.v1.SalepointFilter 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.ad.v1.SalepointPaging 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.ad.v1.GetSalepointListRequest)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  // .keyapis.ad.v1.Salepoint 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.ad.v1.GetSalepointListResponse)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.ad.v1.GetSalepointCountResponse)
}

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

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

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

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

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


void GetSalepointCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.ad.v1.GetSalepointCountResponse)
  ::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* GetSalepointCountResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), target);
  }

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

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

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

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace ad
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::Salepoint_Location*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::Salepoint_Location >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::Salepoint_Location >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::Salepoint_Worktime*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::Salepoint_Worktime >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::Salepoint_Worktime >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::Salepoint*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::Salepoint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::Salepoint >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::SalepointFilter_Location*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::SalepointFilter_Location >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::SalepointFilter_Location >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::SalepointFilter*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::SalepointFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::SalepointFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::SalepointPaging*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::SalepointPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::SalepointPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::PostSalepointRequest*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::PostSalepointRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::PostSalepointRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::PostSalepointResponse*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::PostSalepointResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::PostSalepointResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::GetSalepointRequest*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::GetSalepointRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::GetSalepointRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::GetSalepointResponse*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::GetSalepointResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::GetSalepointResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::GetSalepointListRequest*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::GetSalepointListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::GetSalepointListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::GetSalepointListResponse*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::GetSalepointListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::GetSalepointListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::GetSalepointCountRequest*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::GetSalepointCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::GetSalepointCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::ad::v1::GetSalepointCountResponse*
Arena::CreateMaybeMessage< ::keyapis::ad::v1::GetSalepointCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::ad::v1::GetSalepointCountResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
