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

#ifndef GOOGLE_PROTOBUF_INCLUDED_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4023000
#error "This file was generated by a newer version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please update"
#error "your headers."
#endif  // PROTOBUF_VERSION

#if 4023001 < PROTOBUF_MIN_PROTOC_VERSION
#error "This file was generated by an older version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please"
#error "regenerate this file with a newer version of protoc."
#endif  // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_util.h"
#include "google/protobuf/timestamp.pb.h"
#include "google/api/annotations.pb.h"
#include "google/api/field_behavior.pb.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/wrappers.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto

PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto {
  static const ::uint32_t offsets[];
};
namespace keyapis {
namespace ad {
namespace v1 {
class GetMarketplaceCountRequest;
struct GetMarketplaceCountRequestDefaultTypeInternal;
extern GetMarketplaceCountRequestDefaultTypeInternal _GetMarketplaceCountRequest_default_instance_;
class GetMarketplaceCountResponse;
struct GetMarketplaceCountResponseDefaultTypeInternal;
extern GetMarketplaceCountResponseDefaultTypeInternal _GetMarketplaceCountResponse_default_instance_;
class GetMarketplaceListRequest;
struct GetMarketplaceListRequestDefaultTypeInternal;
extern GetMarketplaceListRequestDefaultTypeInternal _GetMarketplaceListRequest_default_instance_;
class GetMarketplaceListResponse;
struct GetMarketplaceListResponseDefaultTypeInternal;
extern GetMarketplaceListResponseDefaultTypeInternal _GetMarketplaceListResponse_default_instance_;
class GetMarketplaceRequest;
struct GetMarketplaceRequestDefaultTypeInternal;
extern GetMarketplaceRequestDefaultTypeInternal _GetMarketplaceRequest_default_instance_;
class GetMarketplaceResponse;
struct GetMarketplaceResponseDefaultTypeInternal;
extern GetMarketplaceResponseDefaultTypeInternal _GetMarketplaceResponse_default_instance_;
class Marketplace;
struct MarketplaceDefaultTypeInternal;
extern MarketplaceDefaultTypeInternal _Marketplace_default_instance_;
class PostMarketplaceRequest;
struct PostMarketplaceRequestDefaultTypeInternal;
extern PostMarketplaceRequestDefaultTypeInternal _PostMarketplaceRequest_default_instance_;
class PostMarketplaceResponse;
struct PostMarketplaceResponseDefaultTypeInternal;
extern PostMarketplaceResponseDefaultTypeInternal _PostMarketplaceResponse_default_instance_;
}  // namespace v1
}  // namespace ad
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template <>
::keyapis::ad::v1::GetMarketplaceCountRequest* Arena::CreateMaybeMessage<::keyapis::ad::v1::GetMarketplaceCountRequest>(Arena*);
template <>
::keyapis::ad::v1::GetMarketplaceCountResponse* Arena::CreateMaybeMessage<::keyapis::ad::v1::GetMarketplaceCountResponse>(Arena*);
template <>
::keyapis::ad::v1::GetMarketplaceListRequest* Arena::CreateMaybeMessage<::keyapis::ad::v1::GetMarketplaceListRequest>(Arena*);
template <>
::keyapis::ad::v1::GetMarketplaceListResponse* Arena::CreateMaybeMessage<::keyapis::ad::v1::GetMarketplaceListResponse>(Arena*);
template <>
::keyapis::ad::v1::GetMarketplaceRequest* Arena::CreateMaybeMessage<::keyapis::ad::v1::GetMarketplaceRequest>(Arena*);
template <>
::keyapis::ad::v1::GetMarketplaceResponse* Arena::CreateMaybeMessage<::keyapis::ad::v1::GetMarketplaceResponse>(Arena*);
template <>
::keyapis::ad::v1::Marketplace* Arena::CreateMaybeMessage<::keyapis::ad::v1::Marketplace>(Arena*);
template <>
::keyapis::ad::v1::PostMarketplaceRequest* Arena::CreateMaybeMessage<::keyapis::ad::v1::PostMarketplaceRequest>(Arena*);
template <>
::keyapis::ad::v1::PostMarketplaceResponse* Arena::CreateMaybeMessage<::keyapis::ad::v1::PostMarketplaceResponse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace keyapis {
namespace ad {
namespace v1 {
enum Marketplace_Type : int {
  Marketplace_Type_TYPE_UNKNOWN = 0,
  Marketplace_Type_OZON = 1,
  Marketplace_Type_WILDBERRIES = 2,
  Marketplace_Type_YANDEX_MARKET = 3,
  Marketplace_Type_SBER_MARKET = 4,
  Marketplace_Type_Marketplace_Type_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  Marketplace_Type_Marketplace_Type_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool Marketplace_Type_IsValid(int value);
constexpr Marketplace_Type Marketplace_Type_Type_MIN = static_cast<Marketplace_Type>(0);
constexpr Marketplace_Type Marketplace_Type_Type_MAX = static_cast<Marketplace_Type>(4);
constexpr int Marketplace_Type_Type_ARRAYSIZE = 4 + 1;
const std::string& Marketplace_Type_Name(Marketplace_Type value);
template <typename T>
const std::string& Marketplace_Type_Name(T value) {
  static_assert(std::is_same<T, Marketplace_Type>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to Type_Name().");
  return Marketplace_Type_Name(static_cast<Marketplace_Type>(value));
}
const std::string& Marketplace_Type_Name(Marketplace_Type value);
bool Marketplace_Type_Parse(absl::string_view name, Marketplace_Type* value);

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


// -------------------------------------------------------------------

class Marketplace final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.Marketplace) */ {
 public:
  inline Marketplace() : Marketplace(nullptr) {}
  ~Marketplace() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Marketplace(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Marketplace(const Marketplace& from);
  Marketplace(Marketplace&& from) noexcept
    : Marketplace() {
    *this = ::std::move(from);
  }

  inline Marketplace& operator=(const Marketplace& from) {
    CopyFrom(from);
    return *this;
  }
  inline Marketplace& operator=(Marketplace&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Marketplace& default_instance() {
    return *internal_default_instance();
  }
  static inline const Marketplace* internal_default_instance() {
    return reinterpret_cast<const Marketplace*>(
               &_Marketplace_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Marketplace& a, Marketplace& b) {
    a.Swap(&b);
  }
  inline void Swap(Marketplace* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Marketplace* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Marketplace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Marketplace>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Marketplace& from);
  void MergeFrom(const Marketplace& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Marketplace* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.Marketplace";
  }
  protected:
  explicit Marketplace(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  using Type = Marketplace_Type;
  static constexpr Type TYPE_UNKNOWN = Marketplace_Type_TYPE_UNKNOWN;
  static constexpr Type OZON = Marketplace_Type_OZON;
  static constexpr Type WILDBERRIES = Marketplace_Type_WILDBERRIES;
  static constexpr Type YANDEX_MARKET = Marketplace_Type_YANDEX_MARKET;
  static constexpr Type SBER_MARKET = Marketplace_Type_SBER_MARKET;
  static inline bool Type_IsValid(int value) {
    return Marketplace_Type_IsValid(value);
  }
  static constexpr Type Type_MIN = Marketplace_Type_Type_MIN;
  static constexpr Type Type_MAX = Marketplace_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE = Marketplace_Type_Type_ARRAYSIZE;
  template <typename T>
  static inline const std::string& Type_Name(T value) {
    return Marketplace_Type_Name(value);
  }
  static inline bool Type_Parse(absl::string_view name, Type* value) {
    return Marketplace_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTitleFieldNumber = 2,
    kCardUrlFieldNumber = 5,
    kCreatedAtFieldNumber = 6,
    kChangedAtFieldNumber = 7,
    kIdFieldNumber = 1,
    kTypeFieldNumber = 3,
    kIsDisabledFieldNumber = 4,
  };
  // string title = 2 [(.google.api.field_behavior) = REQUIRED];
  void clear_title() ;
  const std::string& title() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_title(Arg_&& arg, Args_... args);
  std::string* mutable_title();
  PROTOBUF_NODISCARD std::string* release_title();
  void set_allocated_title(std::string* ptr);

  private:
  const std::string& _internal_title() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_title(
      const std::string& value);
  std::string* _internal_mutable_title();

  public:
  // .google.protobuf.StringValue card_url = 5;
  bool has_card_url() const;
  void clear_card_url() ;
  const ::PROTOBUF_NAMESPACE_ID::StringValue& card_url() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::StringValue* release_card_url();
  ::PROTOBUF_NAMESPACE_ID::StringValue* mutable_card_url();
  void set_allocated_card_url(::PROTOBUF_NAMESPACE_ID::StringValue* card_url);
  private:
  const ::PROTOBUF_NAMESPACE_ID::StringValue& _internal_card_url() const;
  ::PROTOBUF_NAMESPACE_ID::StringValue* _internal_mutable_card_url();
  public:
  void unsafe_arena_set_allocated_card_url(
      ::PROTOBUF_NAMESPACE_ID::StringValue* card_url);
  ::PROTOBUF_NAMESPACE_ID::StringValue* unsafe_arena_release_card_url();
  // .google.protobuf.Timestamp created_at = 6 [(.google.api.field_behavior) = OUTPUT_ONLY];
  bool has_created_at() const;
  void clear_created_at() ;
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_created_at();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_created_at();
  void set_allocated_created_at(::PROTOBUF_NAMESPACE_ID::Timestamp* created_at);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_created_at() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_created_at();
  public:
  void unsafe_arena_set_allocated_created_at(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* created_at);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_created_at();
  // .google.protobuf.Timestamp changed_at = 7 [(.google.api.field_behavior) = OUTPUT_ONLY];
  bool has_changed_at() const;
  void clear_changed_at() ;
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_changed_at();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_changed_at();
  void set_allocated_changed_at(::PROTOBUF_NAMESPACE_ID::Timestamp* changed_at);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_changed_at() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_changed_at();
  public:
  void unsafe_arena_set_allocated_changed_at(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* changed_at);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_changed_at();
  // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
  void clear_id() ;
  ::int32_t id() const;
  void set_id(::int32_t value);

  private:
  ::int32_t _internal_id() const;
  void _internal_set_id(::int32_t value);

  public:
  // .keyapis.ad.v1.Marketplace.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
  void clear_type() ;
  ::keyapis::ad::v1::Marketplace_Type type() const;
  void set_type(::keyapis::ad::v1::Marketplace_Type value);

  private:
  ::keyapis::ad::v1::Marketplace_Type _internal_type() const;
  void _internal_set_type(::keyapis::ad::v1::Marketplace_Type value);

  public:
  // bool is_disabled = 4;
  void clear_is_disabled() ;
  bool is_disabled() const;
  void set_is_disabled(bool value);

  private:
  bool _internal_is_disabled() const;
  void _internal_set_is_disabled(bool value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.Marketplace)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::PROTOBUF_NAMESPACE_ID::StringValue* card_url_;
    ::PROTOBUF_NAMESPACE_ID::Timestamp* created_at_;
    ::PROTOBUF_NAMESPACE_ID::Timestamp* changed_at_;
    ::int32_t id_;
    int type_;
    bool is_disabled_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class PostMarketplaceRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.PostMarketplaceRequest) */ {
 public:
  inline PostMarketplaceRequest() : PostMarketplaceRequest(nullptr) {}
  ~PostMarketplaceRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PostMarketplaceRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PostMarketplaceRequest(const PostMarketplaceRequest& from);
  PostMarketplaceRequest(PostMarketplaceRequest&& from) noexcept
    : PostMarketplaceRequest() {
    *this = ::std::move(from);
  }

  inline PostMarketplaceRequest& operator=(const PostMarketplaceRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline PostMarketplaceRequest& operator=(PostMarketplaceRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PostMarketplaceRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const PostMarketplaceRequest* internal_default_instance() {
    return reinterpret_cast<const PostMarketplaceRequest*>(
               &_PostMarketplaceRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(PostMarketplaceRequest& a, PostMarketplaceRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PostMarketplaceRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PostMarketplaceRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PostMarketplaceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PostMarketplaceRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PostMarketplaceRequest& from);
  void MergeFrom(const PostMarketplaceRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PostMarketplaceRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.PostMarketplaceRequest";
  }
  protected:
  explicit PostMarketplaceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // .keyapis.ad.v1.Marketplace data = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_data() const;
  void clear_data() ;
  const ::keyapis::ad::v1::Marketplace& data() const;
  PROTOBUF_NODISCARD ::keyapis::ad::v1::Marketplace* release_data();
  ::keyapis::ad::v1::Marketplace* mutable_data();
  void set_allocated_data(::keyapis::ad::v1::Marketplace* data);
  private:
  const ::keyapis::ad::v1::Marketplace& _internal_data() const;
  ::keyapis::ad::v1::Marketplace* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::ad::v1::Marketplace* data);
  ::keyapis::ad::v1::Marketplace* unsafe_arena_release_data();
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.PostMarketplaceRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::ad::v1::Marketplace* data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class PostMarketplaceResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.PostMarketplaceResponse) */ {
 public:
  inline PostMarketplaceResponse() : PostMarketplaceResponse(nullptr) {}
  ~PostMarketplaceResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PostMarketplaceResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PostMarketplaceResponse(const PostMarketplaceResponse& from);
  PostMarketplaceResponse(PostMarketplaceResponse&& from) noexcept
    : PostMarketplaceResponse() {
    *this = ::std::move(from);
  }

  inline PostMarketplaceResponse& operator=(const PostMarketplaceResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline PostMarketplaceResponse& operator=(PostMarketplaceResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PostMarketplaceResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const PostMarketplaceResponse* internal_default_instance() {
    return reinterpret_cast<const PostMarketplaceResponse*>(
               &_PostMarketplaceResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(PostMarketplaceResponse& a, PostMarketplaceResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PostMarketplaceResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PostMarketplaceResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PostMarketplaceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PostMarketplaceResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const PostMarketplaceResponse& from);
  void MergeFrom(const PostMarketplaceResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PostMarketplaceResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.PostMarketplaceResponse";
  }
  protected:
  explicit PostMarketplaceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // .keyapis.ad.v1.Marketplace data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::keyapis::ad::v1::Marketplace& data() const;
  PROTOBUF_NODISCARD ::keyapis::ad::v1::Marketplace* release_data();
  ::keyapis::ad::v1::Marketplace* mutable_data();
  void set_allocated_data(::keyapis::ad::v1::Marketplace* data);
  private:
  const ::keyapis::ad::v1::Marketplace& _internal_data() const;
  ::keyapis::ad::v1::Marketplace* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::ad::v1::Marketplace* data);
  ::keyapis::ad::v1::Marketplace* unsafe_arena_release_data();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.PostMarketplaceResponse)
 private:
  class _Internal;
  void set_has_data();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::ad::v1::Marketplace* data_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetMarketplaceRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.GetMarketplaceRequest) */ {
 public:
  inline GetMarketplaceRequest() : GetMarketplaceRequest(nullptr) {}
  ~GetMarketplaceRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetMarketplaceRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetMarketplaceRequest(const GetMarketplaceRequest& from);
  GetMarketplaceRequest(GetMarketplaceRequest&& from) noexcept
    : GetMarketplaceRequest() {
    *this = ::std::move(from);
  }

  inline GetMarketplaceRequest& operator=(const GetMarketplaceRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetMarketplaceRequest& operator=(GetMarketplaceRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetMarketplaceRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetMarketplaceRequest* internal_default_instance() {
    return reinterpret_cast<const GetMarketplaceRequest*>(
               &_GetMarketplaceRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(GetMarketplaceRequest& a, GetMarketplaceRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetMarketplaceRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetMarketplaceRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetMarketplaceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetMarketplaceRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetMarketplaceRequest& from);
  void MergeFrom(const GetMarketplaceRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetMarketplaceRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.GetMarketplaceRequest";
  }
  protected:
  explicit GetMarketplaceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIdFieldNumber = 1,
  };
  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  void clear_id() ;
  ::int32_t id() const;
  void set_id(::int32_t value);

  private:
  ::int32_t _internal_id() const;
  void _internal_set_id(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.GetMarketplaceRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int32_t id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetMarketplaceResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.GetMarketplaceResponse) */ {
 public:
  inline GetMarketplaceResponse() : GetMarketplaceResponse(nullptr) {}
  ~GetMarketplaceResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetMarketplaceResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetMarketplaceResponse(const GetMarketplaceResponse& from);
  GetMarketplaceResponse(GetMarketplaceResponse&& from) noexcept
    : GetMarketplaceResponse() {
    *this = ::std::move(from);
  }

  inline GetMarketplaceResponse& operator=(const GetMarketplaceResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetMarketplaceResponse& operator=(GetMarketplaceResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetMarketplaceResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const GetMarketplaceResponse* internal_default_instance() {
    return reinterpret_cast<const GetMarketplaceResponse*>(
               &_GetMarketplaceResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(GetMarketplaceResponse& a, GetMarketplaceResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetMarketplaceResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetMarketplaceResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetMarketplaceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetMarketplaceResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetMarketplaceResponse& from);
  void MergeFrom(const GetMarketplaceResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetMarketplaceResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.GetMarketplaceResponse";
  }
  protected:
  explicit GetMarketplaceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // .keyapis.ad.v1.Marketplace data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::keyapis::ad::v1::Marketplace& data() const;
  PROTOBUF_NODISCARD ::keyapis::ad::v1::Marketplace* release_data();
  ::keyapis::ad::v1::Marketplace* mutable_data();
  void set_allocated_data(::keyapis::ad::v1::Marketplace* data);
  private:
  const ::keyapis::ad::v1::Marketplace& _internal_data() const;
  ::keyapis::ad::v1::Marketplace* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::ad::v1::Marketplace* data);
  ::keyapis::ad::v1::Marketplace* unsafe_arena_release_data();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.GetMarketplaceResponse)
 private:
  class _Internal;
  void set_has_data();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::ad::v1::Marketplace* data_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetMarketplaceListRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.GetMarketplaceListRequest) */ {
 public:
  inline GetMarketplaceListRequest() : GetMarketplaceListRequest(nullptr) {}
  ~GetMarketplaceListRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetMarketplaceListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetMarketplaceListRequest(const GetMarketplaceListRequest& from);
  GetMarketplaceListRequest(GetMarketplaceListRequest&& from) noexcept
    : GetMarketplaceListRequest() {
    *this = ::std::move(from);
  }

  inline GetMarketplaceListRequest& operator=(const GetMarketplaceListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetMarketplaceListRequest& operator=(GetMarketplaceListRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetMarketplaceListRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetMarketplaceListRequest* internal_default_instance() {
    return reinterpret_cast<const GetMarketplaceListRequest*>(
               &_GetMarketplaceListRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(GetMarketplaceListRequest& a, GetMarketplaceListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetMarketplaceListRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetMarketplaceListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetMarketplaceListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetMarketplaceListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetMarketplaceListRequest& from);
  void MergeFrom(const GetMarketplaceListRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetMarketplaceListRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.GetMarketplaceListRequest";
  }
  protected:
  explicit GetMarketplaceListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.GetMarketplaceListRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetMarketplaceListResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.GetMarketplaceListResponse) */ {
 public:
  inline GetMarketplaceListResponse() : GetMarketplaceListResponse(nullptr) {}
  ~GetMarketplaceListResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetMarketplaceListResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetMarketplaceListResponse(const GetMarketplaceListResponse& from);
  GetMarketplaceListResponse(GetMarketplaceListResponse&& from) noexcept
    : GetMarketplaceListResponse() {
    *this = ::std::move(from);
  }

  inline GetMarketplaceListResponse& operator=(const GetMarketplaceListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetMarketplaceListResponse& operator=(GetMarketplaceListResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetMarketplaceListResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const GetMarketplaceListResponse* internal_default_instance() {
    return reinterpret_cast<const GetMarketplaceListResponse*>(
               &_GetMarketplaceListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(GetMarketplaceListResponse& a, GetMarketplaceListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetMarketplaceListResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetMarketplaceListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetMarketplaceListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetMarketplaceListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetMarketplaceListResponse& from);
  void MergeFrom(const GetMarketplaceListResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetMarketplaceListResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.GetMarketplaceListResponse";
  }
  protected:
  explicit GetMarketplaceListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // .keyapis.ad.v1.Marketplace data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::keyapis::ad::v1::Marketplace& data() const;
  PROTOBUF_NODISCARD ::keyapis::ad::v1::Marketplace* release_data();
  ::keyapis::ad::v1::Marketplace* mutable_data();
  void set_allocated_data(::keyapis::ad::v1::Marketplace* data);
  private:
  const ::keyapis::ad::v1::Marketplace& _internal_data() const;
  ::keyapis::ad::v1::Marketplace* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::keyapis::ad::v1::Marketplace* data);
  ::keyapis::ad::v1::Marketplace* unsafe_arena_release_data();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.GetMarketplaceListResponse)
 private:
  class _Internal;
  void set_has_data();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::keyapis::ad::v1::Marketplace* data_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetMarketplaceCountRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.GetMarketplaceCountRequest) */ {
 public:
  inline GetMarketplaceCountRequest() : GetMarketplaceCountRequest(nullptr) {}
  ~GetMarketplaceCountRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetMarketplaceCountRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetMarketplaceCountRequest(const GetMarketplaceCountRequest& from);
  GetMarketplaceCountRequest(GetMarketplaceCountRequest&& from) noexcept
    : GetMarketplaceCountRequest() {
    *this = ::std::move(from);
  }

  inline GetMarketplaceCountRequest& operator=(const GetMarketplaceCountRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetMarketplaceCountRequest& operator=(GetMarketplaceCountRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetMarketplaceCountRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetMarketplaceCountRequest* internal_default_instance() {
    return reinterpret_cast<const GetMarketplaceCountRequest*>(
               &_GetMarketplaceCountRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(GetMarketplaceCountRequest& a, GetMarketplaceCountRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetMarketplaceCountRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetMarketplaceCountRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetMarketplaceCountRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetMarketplaceCountRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetMarketplaceCountRequest& from);
  void MergeFrom(const GetMarketplaceCountRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetMarketplaceCountRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.GetMarketplaceCountRequest";
  }
  protected:
  explicit GetMarketplaceCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.GetMarketplaceCountRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetMarketplaceCountResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.ad.v1.GetMarketplaceCountResponse) */ {
 public:
  inline GetMarketplaceCountResponse() : GetMarketplaceCountResponse(nullptr) {}
  ~GetMarketplaceCountResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetMarketplaceCountResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GetMarketplaceCountResponse(const GetMarketplaceCountResponse& from);
  GetMarketplaceCountResponse(GetMarketplaceCountResponse&& from) noexcept
    : GetMarketplaceCountResponse() {
    *this = ::std::move(from);
  }

  inline GetMarketplaceCountResponse& operator=(const GetMarketplaceCountResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetMarketplaceCountResponse& operator=(GetMarketplaceCountResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetMarketplaceCountResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const GetMarketplaceCountResponse* internal_default_instance() {
    return reinterpret_cast<const GetMarketplaceCountResponse*>(
               &_GetMarketplaceCountResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(GetMarketplaceCountResponse& a, GetMarketplaceCountResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetMarketplaceCountResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetMarketplaceCountResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GetMarketplaceCountResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetMarketplaceCountResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetMarketplaceCountResponse& from);
  void MergeFrom(const GetMarketplaceCountResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GetMarketplaceCountResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.ad.v1.GetMarketplaceCountResponse";
  }
  protected:
  explicit GetMarketplaceCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // int32 data = 1;
  bool has_data() const;
  void clear_data() ;
  ::int32_t data() const;
  void set_data(::int32_t value);

  private:
  ::int32_t _internal_data() const;
  void _internal_set_data(::int32_t value);

  public:
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:keyapis.ad.v1.GetMarketplaceCountResponse)
 private:
  class _Internal;
  void set_has_data();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::int32_t data_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto;
};

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




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


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// Marketplace

// int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
inline void Marketplace::clear_id() {
  _impl_.id_ = 0;
}
inline ::int32_t Marketplace::id() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.id)
  return _internal_id();
}
inline void Marketplace::set_id(::int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:keyapis.ad.v1.Marketplace.id)
}
inline ::int32_t Marketplace::_internal_id() const {
  return _impl_.id_;
}
inline void Marketplace::_internal_set_id(::int32_t value) {
  ;
  _impl_.id_ = value;
}

// string title = 2 [(.google.api.field_behavior) = REQUIRED];
inline void Marketplace::clear_title() {
  _impl_.title_.ClearToEmpty();
}
inline const std::string& Marketplace::title() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.title)
  return _internal_title();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Marketplace::set_title(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.title_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:keyapis.ad.v1.Marketplace.title)
}
inline std::string* Marketplace::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.Marketplace.title)
  return _s;
}
inline const std::string& Marketplace::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Marketplace::_internal_set_title(const std::string& value) {
  ;


  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Marketplace::_internal_mutable_title() {
  ;
  return _impl_.title_.Mutable( GetArenaForAllocation());
}
inline std::string* Marketplace::release_title() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.Marketplace.title)
  return _impl_.title_.Release();
}
inline void Marketplace::set_allocated_title(std::string* value) {
  _impl_.title_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.title_.IsDefault()) {
          _impl_.title_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:keyapis.ad.v1.Marketplace.title)
}

// .keyapis.ad.v1.Marketplace.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
inline void Marketplace::clear_type() {
  _impl_.type_ = 0;
}
inline ::keyapis::ad::v1::Marketplace_Type Marketplace::type() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.type)
  return _internal_type();
}
inline void Marketplace::set_type(::keyapis::ad::v1::Marketplace_Type value) {
   _internal_set_type(value);
  // @@protoc_insertion_point(field_set:keyapis.ad.v1.Marketplace.type)
}
inline ::keyapis::ad::v1::Marketplace_Type Marketplace::_internal_type() const {
  return static_cast<::keyapis::ad::v1::Marketplace_Type>(_impl_.type_);
}
inline void Marketplace::_internal_set_type(::keyapis::ad::v1::Marketplace_Type value) {
  ;
  _impl_.type_ = value;
}

// bool is_disabled = 4;
inline void Marketplace::clear_is_disabled() {
  _impl_.is_disabled_ = false;
}
inline bool Marketplace::is_disabled() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.is_disabled)
  return _internal_is_disabled();
}
inline void Marketplace::set_is_disabled(bool value) {
  _internal_set_is_disabled(value);
  // @@protoc_insertion_point(field_set:keyapis.ad.v1.Marketplace.is_disabled)
}
inline bool Marketplace::_internal_is_disabled() const {
  return _impl_.is_disabled_;
}
inline void Marketplace::_internal_set_is_disabled(bool value) {
  ;
  _impl_.is_disabled_ = value;
}

// .google.protobuf.StringValue card_url = 5;
inline bool Marketplace::has_card_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.card_url_ != nullptr);
  return value;
}
inline const ::PROTOBUF_NAMESPACE_ID::StringValue& Marketplace::_internal_card_url() const {
  const ::PROTOBUF_NAMESPACE_ID::StringValue* p = _impl_.card_url_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::StringValue&>(
      ::PROTOBUF_NAMESPACE_ID::_StringValue_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::StringValue& Marketplace::card_url() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.card_url)
  return _internal_card_url();
}
inline void Marketplace::unsafe_arena_set_allocated_card_url(
    ::PROTOBUF_NAMESPACE_ID::StringValue* card_url) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.card_url_);
  }
  _impl_.card_url_ = card_url;
  if (card_url) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.Marketplace.card_url)
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Marketplace::release_card_url() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::PROTOBUF_NAMESPACE_ID::StringValue* temp = _impl_.card_url_;
  _impl_.card_url_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Marketplace::unsafe_arena_release_card_url() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.Marketplace.card_url)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::PROTOBUF_NAMESPACE_ID::StringValue* temp = _impl_.card_url_;
  _impl_.card_url_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Marketplace::_internal_mutable_card_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.card_url_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(GetArenaForAllocation());
    _impl_.card_url_ = p;
  }
  return _impl_.card_url_;
}
inline ::PROTOBUF_NAMESPACE_ID::StringValue* Marketplace::mutable_card_url() {
  ::PROTOBUF_NAMESPACE_ID::StringValue* _msg = _internal_mutable_card_url();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.Marketplace.card_url)
  return _msg;
}
inline void Marketplace::set_allocated_card_url(::PROTOBUF_NAMESPACE_ID::StringValue* card_url) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.card_url_);
  }
  if (card_url) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(card_url));
    if (message_arena != submessage_arena) {
      card_url = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, card_url, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.card_url_ = card_url;
  // @@protoc_insertion_point(field_set_allocated:keyapis.ad.v1.Marketplace.card_url)
}

// .google.protobuf.Timestamp created_at = 6 [(.google.api.field_behavior) = OUTPUT_ONLY];
inline bool Marketplace::has_created_at() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.created_at_ != nullptr);
  return value;
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& Marketplace::_internal_created_at() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.created_at_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& Marketplace::created_at() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.created_at)
  return _internal_created_at();
}
inline void Marketplace::unsafe_arena_set_allocated_created_at(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* created_at) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.created_at_);
  }
  _impl_.created_at_ = created_at;
  if (created_at) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.Marketplace.created_at)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::release_created_at() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.created_at_;
  _impl_.created_at_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::unsafe_arena_release_created_at() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.Marketplace.created_at)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.created_at_;
  _impl_.created_at_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::_internal_mutable_created_at() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.created_at_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    _impl_.created_at_ = p;
  }
  return _impl_.created_at_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::mutable_created_at() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_created_at();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.Marketplace.created_at)
  return _msg;
}
inline void Marketplace::set_allocated_created_at(::PROTOBUF_NAMESPACE_ID::Timestamp* created_at) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.created_at_);
  }
  if (created_at) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(created_at));
    if (message_arena != submessage_arena) {
      created_at = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, created_at, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.created_at_ = created_at;
  // @@protoc_insertion_point(field_set_allocated:keyapis.ad.v1.Marketplace.created_at)
}

// .google.protobuf.Timestamp changed_at = 7 [(.google.api.field_behavior) = OUTPUT_ONLY];
inline bool Marketplace::has_changed_at() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.changed_at_ != nullptr);
  return value;
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& Marketplace::_internal_changed_at() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.changed_at_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& Marketplace::changed_at() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.Marketplace.changed_at)
  return _internal_changed_at();
}
inline void Marketplace::unsafe_arena_set_allocated_changed_at(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* changed_at) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.changed_at_);
  }
  _impl_.changed_at_ = changed_at;
  if (changed_at) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.Marketplace.changed_at)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::release_changed_at() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.changed_at_;
  _impl_.changed_at_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::unsafe_arena_release_changed_at() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.Marketplace.changed_at)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.changed_at_;
  _impl_.changed_at_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::_internal_mutable_changed_at() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.changed_at_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    _impl_.changed_at_ = p;
  }
  return _impl_.changed_at_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Marketplace::mutable_changed_at() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_changed_at();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.Marketplace.changed_at)
  return _msg;
}
inline void Marketplace::set_allocated_changed_at(::PROTOBUF_NAMESPACE_ID::Timestamp* changed_at) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.changed_at_);
  }
  if (changed_at) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(changed_at));
    if (message_arena != submessage_arena) {
      changed_at = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, changed_at, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.changed_at_ = changed_at;
  // @@protoc_insertion_point(field_set_allocated:keyapis.ad.v1.Marketplace.changed_at)
}

// -------------------------------------------------------------------

// PostMarketplaceRequest

// .keyapis.ad.v1.Marketplace data = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool PostMarketplaceRequest::has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr);
  return value;
}
inline void PostMarketplaceRequest::clear_data() {
  if (_impl_.data_ != nullptr) _impl_.data_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::ad::v1::Marketplace& PostMarketplaceRequest::_internal_data() const {
  const ::keyapis::ad::v1::Marketplace* p = _impl_.data_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::ad::v1::Marketplace&>(
      ::keyapis::ad::v1::_Marketplace_default_instance_);
}
inline const ::keyapis::ad::v1::Marketplace& PostMarketplaceRequest::data() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.PostMarketplaceRequest.data)
  return _internal_data();
}
inline void PostMarketplaceRequest::unsafe_arena_set_allocated_data(
    ::keyapis::ad::v1::Marketplace* data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.data_);
  }
  _impl_.data_ = data;
  if (data) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.PostMarketplaceRequest.data)
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceRequest::release_data() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::ad::v1::Marketplace* temp = _impl_.data_;
  _impl_.data_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceRequest::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.PostMarketplaceRequest.data)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::ad::v1::Marketplace* temp = _impl_.data_;
  _impl_.data_ = nullptr;
  return temp;
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceRequest::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.data_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::ad::v1::Marketplace>(GetArenaForAllocation());
    _impl_.data_ = p;
  }
  return _impl_.data_;
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceRequest::mutable_data() {
  ::keyapis::ad::v1::Marketplace* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.PostMarketplaceRequest.data)
  return _msg;
}
inline void PostMarketplaceRequest::set_allocated_data(::keyapis::ad::v1::Marketplace* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.data_;
  }
  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);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_ = data;
  // @@protoc_insertion_point(field_set_allocated:keyapis.ad.v1.PostMarketplaceRequest.data)
}

// -------------------------------------------------------------------

// PostMarketplaceResponse

// .keyapis.ad.v1.Marketplace data = 1;
inline bool PostMarketplaceResponse::has_data() const {
  return type_case() == kData;
}
inline bool PostMarketplaceResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void PostMarketplaceResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void PostMarketplaceResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceResponse::release_data() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.PostMarketplaceResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::ad::v1::Marketplace* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::ad::v1::Marketplace& PostMarketplaceResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::keyapis::ad::v1::Marketplace&>(::keyapis::ad::v1::_Marketplace_default_instance_);
}
inline const ::keyapis::ad::v1::Marketplace& PostMarketplaceResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.PostMarketplaceResponse.data)
  return _internal_data();
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.ad.v1.PostMarketplaceResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::ad::v1::Marketplace* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void PostMarketplaceResponse::unsafe_arena_set_allocated_data(::keyapis::ad::v1::Marketplace* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.PostMarketplaceResponse.data)
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::ad::v1::Marketplace >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::keyapis::ad::v1::Marketplace* PostMarketplaceResponse::mutable_data() {
  ::keyapis::ad::v1::Marketplace* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.PostMarketplaceResponse.data)
  return _msg;
}

inline bool PostMarketplaceResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void PostMarketplaceResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline PostMarketplaceResponse::TypeCase PostMarketplaceResponse::type_case() const {
  return PostMarketplaceResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetMarketplaceRequest

// int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
inline void GetMarketplaceRequest::clear_id() {
  _impl_.id_ = 0;
}
inline ::int32_t GetMarketplaceRequest::id() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.GetMarketplaceRequest.id)
  return _internal_id();
}
inline void GetMarketplaceRequest::set_id(::int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:keyapis.ad.v1.GetMarketplaceRequest.id)
}
inline ::int32_t GetMarketplaceRequest::_internal_id() const {
  return _impl_.id_;
}
inline void GetMarketplaceRequest::_internal_set_id(::int32_t value) {
  ;
  _impl_.id_ = value;
}

// -------------------------------------------------------------------

// GetMarketplaceResponse

// .keyapis.ad.v1.Marketplace data = 1;
inline bool GetMarketplaceResponse::has_data() const {
  return type_case() == kData;
}
inline bool GetMarketplaceResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void GetMarketplaceResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetMarketplaceResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceResponse::release_data() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.GetMarketplaceResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::ad::v1::Marketplace* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::ad::v1::Marketplace& GetMarketplaceResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::keyapis::ad::v1::Marketplace&>(::keyapis::ad::v1::_Marketplace_default_instance_);
}
inline const ::keyapis::ad::v1::Marketplace& GetMarketplaceResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.GetMarketplaceResponse.data)
  return _internal_data();
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.ad.v1.GetMarketplaceResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::ad::v1::Marketplace* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetMarketplaceResponse::unsafe_arena_set_allocated_data(::keyapis::ad::v1::Marketplace* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.GetMarketplaceResponse.data)
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::ad::v1::Marketplace >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceResponse::mutable_data() {
  ::keyapis::ad::v1::Marketplace* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.GetMarketplaceResponse.data)
  return _msg;
}

inline bool GetMarketplaceResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void GetMarketplaceResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline GetMarketplaceResponse::TypeCase GetMarketplaceResponse::type_case() const {
  return GetMarketplaceResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetMarketplaceListRequest

// -------------------------------------------------------------------

// GetMarketplaceListResponse

// .keyapis.ad.v1.Marketplace data = 1;
inline bool GetMarketplaceListResponse::has_data() const {
  return type_case() == kData;
}
inline bool GetMarketplaceListResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void GetMarketplaceListResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetMarketplaceListResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceListResponse::release_data() {
  // @@protoc_insertion_point(field_release:keyapis.ad.v1.GetMarketplaceListResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::ad::v1::Marketplace* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::keyapis::ad::v1::Marketplace& GetMarketplaceListResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::keyapis::ad::v1::Marketplace&>(::keyapis::ad::v1::_Marketplace_default_instance_);
}
inline const ::keyapis::ad::v1::Marketplace& GetMarketplaceListResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.GetMarketplaceListResponse.data)
  return _internal_data();
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceListResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:keyapis.ad.v1.GetMarketplaceListResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::keyapis::ad::v1::Marketplace* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GetMarketplaceListResponse::unsafe_arena_set_allocated_data(::keyapis::ad::v1::Marketplace* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.ad.v1.GetMarketplaceListResponse.data)
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceListResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::keyapis::ad::v1::Marketplace >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::keyapis::ad::v1::Marketplace* GetMarketplaceListResponse::mutable_data() {
  ::keyapis::ad::v1::Marketplace* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:keyapis.ad.v1.GetMarketplaceListResponse.data)
  return _msg;
}

inline bool GetMarketplaceListResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void GetMarketplaceListResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline GetMarketplaceListResponse::TypeCase GetMarketplaceListResponse::type_case() const {
  return GetMarketplaceListResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetMarketplaceCountRequest

// -------------------------------------------------------------------

// GetMarketplaceCountResponse

// int32 data = 1;
inline bool GetMarketplaceCountResponse::has_data() const {
  return type_case() == kData;
}
inline void GetMarketplaceCountResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void GetMarketplaceCountResponse::clear_data() {
  if (type_case() == kData) {
    _impl_.type_.data_ = 0;
    clear_has_type();
  }
}
inline ::int32_t GetMarketplaceCountResponse::data() const {
  // @@protoc_insertion_point(field_get:keyapis.ad.v1.GetMarketplaceCountResponse.data)
  return _internal_data();
}
inline void GetMarketplaceCountResponse::set_data(::int32_t value) {
  _internal_set_data(value);
  // @@protoc_insertion_point(field_set:keyapis.ad.v1.GetMarketplaceCountResponse.data)
}
inline ::int32_t GetMarketplaceCountResponse::_internal_data() const {
  if (type_case() == kData) {
    return _impl_.type_.data_;
  }
  return 0;
}
inline void GetMarketplaceCountResponse::_internal_set_data(::int32_t value) {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
  }
  _impl_.type_.data_ = value;
}

inline bool GetMarketplaceCountResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void GetMarketplaceCountResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline GetMarketplaceCountResponse::TypeCase GetMarketplaceCountResponse::type_case() const {
  return GetMarketplaceCountResponse::TypeCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace ad
}  // namespace keyapis


PROTOBUF_NAMESPACE_OPEN

template <>
struct is_proto_enum<::keyapis::ad::v1::Marketplace_Type> : std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_keyapis_2fad_2fv1_2fkeyapis_5fad_5fmarketplace_5fv1_2eproto_2epb_2eh