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

#include "keyapis/vc/v1/keyapis_vc_camera_group_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 vc {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionCountRequest::GetCameraCollectionCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetCameraCollectionCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionCountRequestDefaultTypeInternal() {}
  union {
    GetCameraCollectionCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionCountRequestDefaultTypeInternal _GetCameraCollectionCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionCountResponse_Error::GetCameraCollectionCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetCameraCollectionCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetCameraCollectionCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionCountResponse_ErrorDefaultTypeInternal _GetCameraCollectionCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionCountResponse::GetCameraCollectionCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetCameraCollectionCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionCountResponseDefaultTypeInternal() {}
  union {
    GetCameraCollectionCountResponse _instance;
  };
};

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionRequestDefaultTypeInternal _GetCameraCollectionRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionResponse_Error::GetCameraCollectionResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetCameraCollectionResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionResponse_ErrorDefaultTypeInternal() {}
  union {
    GetCameraCollectionResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionResponse_ErrorDefaultTypeInternal _GetCameraCollectionResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionResponse::GetCameraCollectionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetCameraCollectionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionResponseDefaultTypeInternal() {}
  union {
    GetCameraCollectionResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionListRequestDefaultTypeInternal _GetCameraCollectionListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CameraCollectionFilter::CameraCollectionFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.tags_)*/{}
  , /*decltype(_impl_.company_ids_)*/ {}
  ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

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

  , /*decltype(_impl_.is_deleted_)*/nullptr} {}
struct CameraCollectionFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CameraCollectionFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CameraCollectionFilterDefaultTypeInternal() {}
  union {
    CameraCollectionFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CameraCollectionFilterDefaultTypeInternal _CameraCollectionFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CameraCollectionPaging::CameraCollectionPaging(
    ::_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 CameraCollectionPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CameraCollectionPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CameraCollectionPagingDefaultTypeInternal() {}
  union {
    CameraCollectionPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CameraCollectionPagingDefaultTypeInternal _CameraCollectionPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionListResponse_Error::GetCameraCollectionListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetCameraCollectionListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetCameraCollectionListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionListResponse_ErrorDefaultTypeInternal _GetCameraCollectionListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetCameraCollectionListResponse::GetCameraCollectionListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetCameraCollectionListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetCameraCollectionListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetCameraCollectionListResponseDefaultTypeInternal() {}
  union {
    GetCameraCollectionListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetCameraCollectionListResponseDefaultTypeInternal _GetCameraCollectionListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveCameraCollectionRequest::SaveCameraCollectionRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct SaveCameraCollectionRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveCameraCollectionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveCameraCollectionRequestDefaultTypeInternal() {}
  union {
    SaveCameraCollectionRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveCameraCollectionRequestDefaultTypeInternal _SaveCameraCollectionRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveCameraCollectionResponse_Error::SaveCameraCollectionResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SaveCameraCollectionResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveCameraCollectionResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveCameraCollectionResponse_ErrorDefaultTypeInternal() {}
  union {
    SaveCameraCollectionResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveCameraCollectionResponse_ErrorDefaultTypeInternal _SaveCameraCollectionResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveCameraCollectionResponse::SaveCameraCollectionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SaveCameraCollectionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveCameraCollectionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveCameraCollectionResponseDefaultTypeInternal() {}
  union {
    SaveCameraCollectionResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveCameraCollectionResponseDefaultTypeInternal _SaveCameraCollectionResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CameraCollection_SavingError_Conflict::CameraCollection_SavingError_Conflict(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct CameraCollection_SavingError_ConflictDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CameraCollection_SavingError_ConflictDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CameraCollection_SavingError_ConflictDefaultTypeInternal() {}
  union {
    CameraCollection_SavingError_Conflict _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CameraCollection_SavingError_ConflictDefaultTypeInternal _CameraCollection_SavingError_Conflict_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CameraCollection_SavingError_WrongCompanyId::CameraCollection_SavingError_WrongCompanyId(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct CameraCollection_SavingError_WrongCompanyIdDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CameraCollection_SavingError_WrongCompanyIdDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CameraCollection_SavingError_WrongCompanyIdDefaultTypeInternal() {}
  union {
    CameraCollection_SavingError_WrongCompanyId _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CameraCollection_SavingError_WrongCompanyIdDefaultTypeInternal _CameraCollection_SavingError_WrongCompanyId_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CameraCollection_SavingError::CameraCollection_SavingError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct CameraCollection_SavingErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CameraCollection_SavingErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CameraCollection_SavingErrorDefaultTypeInternal() {}
  union {
    CameraCollection_SavingError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CameraCollection_SavingErrorDefaultTypeInternal _CameraCollection_SavingError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR CameraCollection::CameraCollection(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.tags_)*/{}
  , /*decltype(_impl_.external_camera_ids_)*/{}
  , /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.deleted_at_)*/nullptr
  , /*decltype(_impl_.company_id_)*/ ::int64_t{0}
} {}
struct CameraCollectionDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CameraCollectionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CameraCollectionDefaultTypeInternal() {}
  union {
    CameraCollection _instance;
  };
};

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

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostCameraCollectionRestoreRequestDefaultTypeInternal _PostCameraCollectionRestoreRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteCameraCollectionResponse_Error::DeleteCameraCollectionResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct DeleteCameraCollectionResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteCameraCollectionResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteCameraCollectionResponse_ErrorDefaultTypeInternal() {}
  union {
    DeleteCameraCollectionResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteCameraCollectionResponse_ErrorDefaultTypeInternal _DeleteCameraCollectionResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteCameraCollectionResponse::DeleteCameraCollectionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct DeleteCameraCollectionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteCameraCollectionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteCameraCollectionResponseDefaultTypeInternal() {}
  union {
    DeleteCameraCollectionResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteCameraCollectionResponseDefaultTypeInternal _DeleteCameraCollectionResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostCameraCollectionRestoreResponse_Error::PostCameraCollectionRestoreResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostCameraCollectionRestoreResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostCameraCollectionRestoreResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostCameraCollectionRestoreResponse_ErrorDefaultTypeInternal() {}
  union {
    PostCameraCollectionRestoreResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostCameraCollectionRestoreResponse_ErrorDefaultTypeInternal _PostCameraCollectionRestoreResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostCameraCollectionRestoreResponse::PostCameraCollectionRestoreResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostCameraCollectionRestoreResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostCameraCollectionRestoreResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostCameraCollectionRestoreResponseDefaultTypeInternal() {}
  union {
    PostCameraCollectionRestoreResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostCameraCollectionRestoreResponseDefaultTypeInternal _PostCameraCollectionRestoreResponse_default_instance_;
}  // namespace v1
}  // namespace vc
}  // namespace keyapis
namespace keyapis {
namespace vc {
namespace v1 {
bool CameraCollectionPaging_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>
    CameraCollectionPaging_OrderByType_strings[4] = {};

static const char CameraCollectionPaging_OrderByType_names[] = {
    "CHANGED_AT"
    "ID"
    "NAME"
    "ORDER_BY_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CameraCollectionPaging_OrderByType_entries[] =
    {
        {{&CameraCollectionPaging_OrderByType_names[0], 10}, 3},
        {{&CameraCollectionPaging_OrderByType_names[10], 2}, 1},
        {{&CameraCollectionPaging_OrderByType_names[12], 4}, 2},
        {{&CameraCollectionPaging_OrderByType_names[16], 21}, 0},
};

static const int CameraCollectionPaging_OrderByType_entries_by_number[] = {
    3,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    1,  // 1 -> ID
    2,  // 2 -> NAME
    0,  // 3 -> CHANGED_AT
};

const std::string& CameraCollectionPaging_OrderByType_Name(CameraCollectionPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          CameraCollectionPaging_OrderByType_entries, CameraCollectionPaging_OrderByType_entries_by_number,
          4, CameraCollectionPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      CameraCollectionPaging_OrderByType_entries, CameraCollectionPaging_OrderByType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : CameraCollectionPaging_OrderByType_strings[idx].get();
}

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

constexpr CameraCollectionPaging_OrderByType CameraCollectionPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr CameraCollectionPaging_OrderByType CameraCollectionPaging::ID;
constexpr CameraCollectionPaging_OrderByType CameraCollectionPaging::NAME;
constexpr CameraCollectionPaging_OrderByType CameraCollectionPaging::CHANGED_AT;
constexpr CameraCollectionPaging_OrderByType CameraCollectionPaging::OrderByType_MIN;
constexpr CameraCollectionPaging_OrderByType CameraCollectionPaging::OrderByType_MAX;
constexpr int CameraCollectionPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& CameraCollectionPaging_DirectionType_Name(CameraCollectionPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          CameraCollectionPaging_DirectionType_entries, CameraCollectionPaging_DirectionType_entries_by_number,
          3, CameraCollectionPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      CameraCollectionPaging_DirectionType_entries, CameraCollectionPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : CameraCollectionPaging_DirectionType_strings[idx].get();
}

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

constexpr CameraCollectionPaging_DirectionType CameraCollectionPaging::DIRECTION_TYPE_UNKNOWN;
constexpr CameraCollectionPaging_DirectionType CameraCollectionPaging::DESC;
constexpr CameraCollectionPaging_DirectionType CameraCollectionPaging::ASC;
constexpr CameraCollectionPaging_DirectionType CameraCollectionPaging::DirectionType_MIN;
constexpr CameraCollectionPaging_DirectionType CameraCollectionPaging::DirectionType_MAX;
constexpr int CameraCollectionPaging::DirectionType_ARRAYSIZE;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::keyapis::vc::v1::ValidationError&
GetCameraCollectionCountResponse_Error::_Internal::validation(const GetCameraCollectionCountResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetCameraCollectionCountResponse_Error::set_allocated_validation(::keyapis::vc::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.GetCameraCollectionCountResponse.Error.validation)
}
void GetCameraCollectionCountResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetCameraCollectionCountResponse_Error::GetCameraCollectionCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.GetCameraCollectionCountResponse.Error)
}
GetCameraCollectionCountResponse_Error::GetCameraCollectionCountResponse_Error(const GetCameraCollectionCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetCameraCollectionCountResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.GetCameraCollectionCountResponse.Error)
}

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

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

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

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

void GetCameraCollectionCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.GetCameraCollectionCountResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* GetCameraCollectionCountResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.vc.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.vc.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(this).GetCachedSize(), target, stream);
  }

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

::size_t GetCameraCollectionCountResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.GetCameraCollectionCountResponse.Error)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetCameraCollectionCountResponse_Error::InternalSwap(GetCameraCollectionCountResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetCameraCollectionCountResponse_Error::GetTypeName() const {
  return "keyapis.vc.v1.GetCameraCollectionCountResponse.Error";
}

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

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

const ::keyapis::vc::v1::GetCameraCollectionCountResponse_Error&
GetCameraCollectionCountResponse::_Internal::error(const GetCameraCollectionCountResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetCameraCollectionCountResponse::set_allocated_error(::keyapis::vc::v1::GetCameraCollectionCountResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.GetCameraCollectionCountResponse.error)
}
GetCameraCollectionCountResponse::GetCameraCollectionCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.GetCameraCollectionCountResponse)
}
GetCameraCollectionCountResponse::GetCameraCollectionCountResponse(const GetCameraCollectionCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetCameraCollectionCountResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

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

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

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

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

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

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


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

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

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

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

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

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    // .keyapis.vc.v1.GetCameraCollectionCountResponse.Error error = 2;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

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

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

class GetCameraCollectionRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string GetCameraCollectionRequest::GetTypeName() const {
  return "keyapis.vc.v1.GetCameraCollectionRequest";
}

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

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

const ::keyapis::vc::v1::ValidationError&
GetCameraCollectionResponse_Error::_Internal::validation(const GetCameraCollectionResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetCameraCollectionResponse_Error::set_allocated_validation(::keyapis::vc::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.GetCameraCollectionResponse.Error.validation)
}
void GetCameraCollectionResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetCameraCollectionResponse_Error::GetCameraCollectionResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.GetCameraCollectionResponse.Error)
}
GetCameraCollectionResponse_Error::GetCameraCollectionResponse_Error(const GetCameraCollectionResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetCameraCollectionResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.GetCameraCollectionResponse.Error)
}

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

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

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

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

void GetCameraCollectionResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.GetCameraCollectionResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* GetCameraCollectionResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.vc.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.vc.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(this).GetCachedSize(), target, stream);
  }

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

::size_t GetCameraCollectionResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.GetCameraCollectionResponse.Error)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetCameraCollectionResponse_Error::InternalSwap(GetCameraCollectionResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetCameraCollectionResponse_Error::GetTypeName() const {
  return "keyapis.vc.v1.GetCameraCollectionResponse.Error";
}

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

class GetCameraCollectionResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::vc::v1::GetCameraCollectionResponse, _impl_._oneof_case_);
  static const ::keyapis::vc::v1::CameraCollection& data(const GetCameraCollectionResponse* msg);
  static const ::keyapis::vc::v1::GetCameraCollectionResponse_Error& error(const GetCameraCollectionResponse* msg);
};

const ::keyapis::vc::v1::CameraCollection&
GetCameraCollectionResponse::_Internal::data(const GetCameraCollectionResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::vc::v1::GetCameraCollectionResponse_Error&
GetCameraCollectionResponse::_Internal::error(const GetCameraCollectionResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetCameraCollectionResponse::set_allocated_data(::keyapis::vc::v1::CameraCollection* 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.vc.v1.GetCameraCollectionResponse.data)
}
void GetCameraCollectionResponse::set_allocated_error(::keyapis::vc::v1::GetCameraCollectionResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.GetCameraCollectionResponse.error)
}
GetCameraCollectionResponse::GetCameraCollectionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.GetCameraCollectionResponse)
}
GetCameraCollectionResponse::GetCameraCollectionResponse(const GetCameraCollectionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetCameraCollectionResponse* 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::vc::v1::CameraCollection::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::vc::v1::GetCameraCollectionResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.GetCameraCollectionResponse)
}

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.vc.v1.CameraCollectionFilter 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.vc.v1.CameraCollectionPaging 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.vc.v1.GetCameraCollectionListRequest)
  return target;
}

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

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

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

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

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

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

class CameraCollectionFilter::_Internal {
 public:
  using HasBits = decltype(std::declval<CameraCollectionFilter>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(CameraCollectionFilter, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::BoolValue& is_deleted(const CameraCollectionFilter* msg);
  static void set_has_is_deleted(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::BoolValue&
CameraCollectionFilter::_Internal::is_deleted(const CameraCollectionFilter* msg) {
  return *msg->_impl_.is_deleted_;
}
void CameraCollectionFilter::clear_is_deleted() {
  if (_impl_.is_deleted_ != nullptr) _impl_.is_deleted_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
CameraCollectionFilter::CameraCollectionFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.CameraCollectionFilter)
}
CameraCollectionFilter::CameraCollectionFilter(const CameraCollectionFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CameraCollectionFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.tags_){from._impl_.tags_}
    , decltype(_impl_.company_ids_) { from._impl_.company_ids_ }
    ,/* _impl_._company_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.text_) {}

    , decltype(_impl_.is_deleted_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.text_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.text_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_text().empty()) {
    _this->_impl_.text_.Set(from._internal_text(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.is_deleted_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.is_deleted_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.CameraCollectionFilter)
}

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

    , decltype(_impl_.text_) {}

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

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

inline void CameraCollectionFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_tags()->~RepeatedPtrField();
  _impl_.company_ids_.~RepeatedField();
  _impl_.text_.Destroy();
  if (this != internal_default_instance()) delete _impl_.is_deleted_;
}

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

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

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

const char* CameraCollectionFilter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string text = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_text();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string tags = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_tags();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int64 company_ids = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_company_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 24) {
          _internal_add_company_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.BoolValue is_deleted = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_is_deleted(), 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* CameraCollectionFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.vc.v1.CameraCollectionFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // repeated int64 company_ids = 3;
  {
    int byte_size = _impl_._company_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt64Packed(3, _internal_company_ids(),
                                                 byte_size, target);
    }
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.BoolValue is_deleted = 4;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::is_deleted(this),
        _Internal::is_deleted(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.vc.v1.CameraCollectionFilter)
  return target;
}

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

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

  // repeated string tags = 2;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_tags().size());
  for (int i = 0, n = _internal_tags().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_tags().Get(i));
  }

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

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

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

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

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

  _this->_internal_mutable_tags()->MergeFrom(from._internal_tags());
  _this->_impl_.company_ids_.MergeFrom(from._impl_.company_ids_);
  if (!from._internal_text().empty()) {
    _this->_internal_set_text(from._internal_text());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_is_deleted()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom(
        from._internal_is_deleted());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void CameraCollectionFilter::InternalSwap(CameraCollectionFilter* 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_tags()->InternalSwap(
      other->_internal_mutable_tags());
  _impl_.company_ids_.InternalSwap(&other->_impl_.company_ids_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.text_, lhs_arena,
                                       &other->_impl_.text_, rhs_arena);
  swap(_impl_.is_deleted_, other->_impl_.is_deleted_);
}

std::string CameraCollectionFilter::GetTypeName() const {
  return "keyapis.vc.v1.CameraCollectionFilter";
}

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

class CameraCollectionPaging::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

std::string CameraCollectionPaging::GetTypeName() const {
  return "keyapis.vc.v1.CameraCollectionPaging";
}

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

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

const ::keyapis::vc::v1::ValidationError&
GetCameraCollectionListResponse_Error::_Internal::validation(const GetCameraCollectionListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void GetCameraCollectionListResponse_Error::set_allocated_validation(::keyapis::vc::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.GetCameraCollectionListResponse.Error.validation)
}
void GetCameraCollectionListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
GetCameraCollectionListResponse_Error::GetCameraCollectionListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.GetCameraCollectionListResponse.Error)
}
GetCameraCollectionListResponse_Error::GetCameraCollectionListResponse_Error(const GetCameraCollectionListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetCameraCollectionListResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.GetCameraCollectionListResponse.Error)
}

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

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

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

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

void GetCameraCollectionListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.GetCameraCollectionListResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* GetCameraCollectionListResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.vc.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.vc.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(this).GetCachedSize(), target, stream);
  }

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

::size_t GetCameraCollectionListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.GetCameraCollectionListResponse.Error)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetCameraCollectionListResponse_Error::InternalSwap(GetCameraCollectionListResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetCameraCollectionListResponse_Error::GetTypeName() const {
  return "keyapis.vc.v1.GetCameraCollectionListResponse.Error";
}

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

class GetCameraCollectionListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::vc::v1::GetCameraCollectionListResponse, _impl_._oneof_case_);
  static const ::keyapis::vc::v1::CameraCollection& data(const GetCameraCollectionListResponse* msg);
  static const ::keyapis::vc::v1::GetCameraCollectionListResponse_Error& error(const GetCameraCollectionListResponse* msg);
};

const ::keyapis::vc::v1::CameraCollection&
GetCameraCollectionListResponse::_Internal::data(const GetCameraCollectionListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::vc::v1::GetCameraCollectionListResponse_Error&
GetCameraCollectionListResponse::_Internal::error(const GetCameraCollectionListResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetCameraCollectionListResponse::set_allocated_data(::keyapis::vc::v1::CameraCollection* 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.vc.v1.GetCameraCollectionListResponse.data)
}
void GetCameraCollectionListResponse::set_allocated_error(::keyapis::vc::v1::GetCameraCollectionListResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.GetCameraCollectionListResponse.error)
}
GetCameraCollectionListResponse::GetCameraCollectionListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.GetCameraCollectionListResponse)
}
GetCameraCollectionListResponse::GetCameraCollectionListResponse(const GetCameraCollectionListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetCameraCollectionListResponse* 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::vc::v1::CameraCollection::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::vc::v1::GetCameraCollectionListResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.GetCameraCollectionListResponse)
}

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::keyapis::vc::v1::ValidationError&
SaveCameraCollectionResponse_Error::_Internal::validation(const SaveCameraCollectionResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
const ::keyapis::vc::v1::CameraCollection_SavingError&
SaveCameraCollectionResponse_Error::_Internal::saving(const SaveCameraCollectionResponse_Error* msg) {
  return *msg->_impl_.reason_.saving_;
}
void SaveCameraCollectionResponse_Error::set_allocated_validation(::keyapis::vc::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.SaveCameraCollectionResponse.Error.validation)
}
void SaveCameraCollectionResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
void SaveCameraCollectionResponse_Error::set_allocated_saving(::keyapis::vc::v1::CameraCollection_SavingError* saving) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (saving) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(saving);
    if (message_arena != submessage_arena) {
      saving = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, saving, submessage_arena);
    }
    set_has_saving();
    _impl_.reason_.saving_ = saving;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.SaveCameraCollectionResponse.Error.saving)
}
SaveCameraCollectionResponse_Error::SaveCameraCollectionResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.SaveCameraCollectionResponse.Error)
}
SaveCameraCollectionResponse_Error::SaveCameraCollectionResponse_Error(const SaveCameraCollectionResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SaveCameraCollectionResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case kSaving: {
      _this->_internal_mutable_saving()->::keyapis::vc::v1::CameraCollection_SavingError::MergeFrom(
          from._internal_saving());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.SaveCameraCollectionResponse.Error)
}

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

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

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

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

void SaveCameraCollectionResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.SaveCameraCollectionResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case kSaving: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.saving_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* SaveCameraCollectionResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.vc.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.vc.v1.CameraCollection.SavingError saving = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_saving(), 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* SaveCameraCollectionResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.vc.v1.SaveCameraCollectionResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::validation(this),
          _Internal::validation(this).GetCachedSize(), target, stream);
      break;
    }
    case kSaving: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::saving(this),
          _Internal::saving(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.vc.v1.SaveCameraCollectionResponse.Error)
  return target;
}

::size_t SaveCameraCollectionResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.SaveCameraCollectionResponse.Error)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    // .keyapis.vc.v1.CameraCollection.SavingError saving = 2;
    case kSaving: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.saving_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case kSaving: {
      _this->_internal_mutable_saving()->::keyapis::vc::v1::CameraCollection_SavingError::MergeFrom(
          from._internal_saving());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void SaveCameraCollectionResponse_Error::InternalSwap(SaveCameraCollectionResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string SaveCameraCollectionResponse_Error::GetTypeName() const {
  return "keyapis.vc.v1.SaveCameraCollectionResponse.Error";
}

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

class SaveCameraCollectionResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::vc::v1::SaveCameraCollectionResponse, _impl_._oneof_case_);
  static const ::keyapis::vc::v1::CameraCollection& data(const SaveCameraCollectionResponse* msg);
  static const ::keyapis::vc::v1::SaveCameraCollectionResponse_Error& error(const SaveCameraCollectionResponse* msg);
};

const ::keyapis::vc::v1::CameraCollection&
SaveCameraCollectionResponse::_Internal::data(const SaveCameraCollectionResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::keyapis::vc::v1::SaveCameraCollectionResponse_Error&
SaveCameraCollectionResponse::_Internal::error(const SaveCameraCollectionResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void SaveCameraCollectionResponse::set_allocated_data(::keyapis::vc::v1::CameraCollection* 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.vc.v1.SaveCameraCollectionResponse.data)
}
void SaveCameraCollectionResponse::set_allocated_error(::keyapis::vc::v1::SaveCameraCollectionResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.SaveCameraCollectionResponse.error)
}
SaveCameraCollectionResponse::SaveCameraCollectionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.SaveCameraCollectionResponse)
}
SaveCameraCollectionResponse::SaveCameraCollectionResponse(const SaveCameraCollectionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SaveCameraCollectionResponse* 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::vc::v1::CameraCollection::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::keyapis::vc::v1::SaveCameraCollectionResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.SaveCameraCollectionResponse)
}

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

class CameraCollection_SavingError_Conflict::_Internal {
 public:
};

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

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

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

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

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

void CameraCollection_SavingError_Conflict::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.vc.v1.CameraCollection.SavingError.Conflict)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

::uint8_t* CameraCollection_SavingError_Conflict::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.vc.v1.CameraCollection.SavingError.Conflict)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

::size_t CameraCollection_SavingError_Conflict::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.CameraCollection.SavingError.Conflict)
  ::size_t total_size = 0;

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

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

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

void CameraCollection_SavingError_Conflict::MergeFrom(const CameraCollection_SavingError_Conflict& from) {
  CameraCollection_SavingError_Conflict* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.vc.v1.CameraCollection.SavingError.Conflict)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

void CameraCollection_SavingError_Conflict::CopyFrom(const CameraCollection_SavingError_Conflict& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.vc.v1.CameraCollection.SavingError.Conflict)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string CameraCollection_SavingError_Conflict::GetTypeName() const {
  return "keyapis.vc.v1.CameraCollection.SavingError.Conflict";
}

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

class CameraCollection_SavingError_WrongCompanyId::_Internal {
 public:
};

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

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

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

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

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

void CameraCollection_SavingError_WrongCompanyId::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

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

::uint8_t* CameraCollection_SavingError_WrongCompanyId::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

::size_t CameraCollection_SavingError_WrongCompanyId::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId)
  ::size_t total_size = 0;

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

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

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

void CameraCollection_SavingError_WrongCompanyId::MergeFrom(const CameraCollection_SavingError_WrongCompanyId& from) {
  CameraCollection_SavingError_WrongCompanyId* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

void CameraCollection_SavingError_WrongCompanyId::CopyFrom(const CameraCollection_SavingError_WrongCompanyId& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string CameraCollection_SavingError_WrongCompanyId::GetTypeName() const {
  return "keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId";
}

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

class CameraCollection_SavingError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::vc::v1::CameraCollection_SavingError, _impl_._oneof_case_);
  static const ::keyapis::vc::v1::CameraCollection_SavingError_Conflict& conflict(const CameraCollection_SavingError* msg);
  static const ::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId& wrong_company_id(const CameraCollection_SavingError* msg);
};

const ::keyapis::vc::v1::CameraCollection_SavingError_Conflict&
CameraCollection_SavingError::_Internal::conflict(const CameraCollection_SavingError* msg) {
  return *msg->_impl_.reason_.conflict_;
}
const ::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId&
CameraCollection_SavingError::_Internal::wrong_company_id(const CameraCollection_SavingError* msg) {
  return *msg->_impl_.reason_.wrong_company_id_;
}
void CameraCollection_SavingError::set_allocated_conflict(::keyapis::vc::v1::CameraCollection_SavingError_Conflict* conflict) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (conflict) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(conflict);
    if (message_arena != submessage_arena) {
      conflict = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, conflict, submessage_arena);
    }
    set_has_conflict();
    _impl_.reason_.conflict_ = conflict;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.CameraCollection.SavingError.conflict)
}
void CameraCollection_SavingError::set_allocated_wrong_company_id(::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId* wrong_company_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (wrong_company_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wrong_company_id);
    if (message_arena != submessage_arena) {
      wrong_company_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wrong_company_id, submessage_arena);
    }
    set_has_wrong_company_id();
    _impl_.reason_.wrong_company_id_ = wrong_company_id;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.CameraCollection.SavingError.wrong_company_id)
}
CameraCollection_SavingError::CameraCollection_SavingError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.CameraCollection.SavingError)
}
CameraCollection_SavingError::CameraCollection_SavingError(const CameraCollection_SavingError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CameraCollection_SavingError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kConflict: {
      _this->_internal_mutable_conflict()->::keyapis::vc::v1::CameraCollection_SavingError_Conflict::MergeFrom(
          from._internal_conflict());
      break;
    }
    case kWrongCompanyId: {
      _this->_internal_mutable_wrong_company_id()->::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId::MergeFrom(
          from._internal_wrong_company_id());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.CameraCollection.SavingError)
}

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

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

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

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

void CameraCollection_SavingError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.CameraCollection.SavingError)
  switch (reason_case()) {
    case kConflict: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.conflict_;
      }
      break;
    }
    case kWrongCompanyId: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.wrong_company_id_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* CameraCollection_SavingError::_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.vc.v1.CameraCollection.SavingError.Conflict conflict = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_conflict(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId wrong_company_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_wrong_company_id(), 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* CameraCollection_SavingError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.vc.v1.CameraCollection.SavingError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kConflict: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::conflict(this),
          _Internal::conflict(this).GetCachedSize(), target, stream);
      break;
    }
    case kWrongCompanyId: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::wrong_company_id(this),
          _Internal::wrong_company_id(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.vc.v1.CameraCollection.SavingError)
  return target;
}

::size_t CameraCollection_SavingError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.CameraCollection.SavingError)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.CameraCollection.SavingError.Conflict conflict = 1;
    case kConflict: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.conflict_);
      break;
    }
    // .keyapis.vc.v1.CameraCollection.SavingError.WrongCompanyId wrong_company_id = 2;
    case kWrongCompanyId: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.wrong_company_id_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kConflict: {
      _this->_internal_mutable_conflict()->::keyapis::vc::v1::CameraCollection_SavingError_Conflict::MergeFrom(
          from._internal_conflict());
      break;
    }
    case kWrongCompanyId: {
      _this->_internal_mutable_wrong_company_id()->::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId::MergeFrom(
          from._internal_wrong_company_id());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void CameraCollection_SavingError::InternalSwap(CameraCollection_SavingError* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string CameraCollection_SavingError::GetTypeName() const {
  return "keyapis.vc.v1.CameraCollection.SavingError";
}

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

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

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
CameraCollection::_Internal::changed_at(const CameraCollection* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
CameraCollection::_Internal::deleted_at(const CameraCollection* msg) {
  return *msg->_impl_.deleted_at_;
}
void CameraCollection::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void CameraCollection::clear_deleted_at() {
  if (_impl_.deleted_at_ != nullptr) _impl_.deleted_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
CameraCollection::CameraCollection(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.CameraCollection)
}
CameraCollection::CameraCollection(const CameraCollection& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  CameraCollection* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.tags_){from._impl_.tags_}
    , decltype(_impl_.external_camera_ids_){from._impl_.external_camera_ids_}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.name_) {}

    , decltype(_impl_.description_) {}

    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.deleted_at_){nullptr}
    , decltype(_impl_.company_id_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  _impl_.name_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.name_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_name().empty()) {
    _this->_impl_.name_.Set(from._internal_name(), _this->GetArenaForAllocation());
  }
  _impl_.description_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.description_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_description().empty()) {
    _this->_impl_.description_.Set(from._internal_description(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.deleted_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.deleted_at_);
  }
  _this->_impl_.company_id_ = from._impl_.company_id_;
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.CameraCollection)
}

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

    , decltype(_impl_.name_) {}

    , decltype(_impl_.description_) {}

    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.deleted_at_){nullptr}
    , decltype(_impl_.company_id_) { ::int64_t{0} }

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

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

inline void CameraCollection::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_tags()->~RepeatedPtrField();
  _internal_mutable_external_camera_ids()->~RepeatedPtrField();
  _impl_.id_.Destroy();
  _impl_.name_.Destroy();
  _impl_.description_.Destroy();
  if (this != internal_default_instance()) delete _impl_.changed_at_;
  if (this != internal_default_instance()) delete _impl_.deleted_at_;
}

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

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

  _internal_mutable_tags()->Clear();
  _internal_mutable_external_camera_ids()->Clear();
  _impl_.id_.ClearToEmpty();
  _impl_.name_.ClearToEmpty();
  _impl_.description_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.deleted_at_ != nullptr);
      _impl_.deleted_at_->Clear();
    }
  }
  _impl_.company_id_ = ::int64_t{0};
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* CameraCollection::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string name = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_name();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int64 company_id = 4 [(.google.api.field_behavior) = REQUIRED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.company_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp deleted_at = 5 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_deleted_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string description = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          auto str = _internal_mutable_description();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string tags = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_tags();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string external_camera_ids = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_external_camera_ids();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(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* CameraCollection::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.vc.v1.CameraCollection)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

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

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

  // string description = 6;
  if (!this->_internal_description().empty()) {
    const std::string& _s = this->_internal_description();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.vc.v1.CameraCollection.description");
    target = stream->WriteStringMaybeAliased(6, _s, target);
  }

  // repeated string tags = 7;
  for (int i = 0, n = this->_internal_tags_size(); i < n; ++i) {
    const auto& s = this->_internal_tags(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.vc.v1.CameraCollection.tags");
    target = stream->WriteString(7, s, target);
  }

  // repeated string external_camera_ids = 8;
  for (int i = 0, n = this->_internal_external_camera_ids_size(); i < n; ++i) {
    const auto& s = this->_internal_external_camera_ids(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.vc.v1.CameraCollection.external_camera_ids");
    target = stream->WriteString(8, 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.vc.v1.CameraCollection)
  return target;
}

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

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

  // repeated string tags = 7;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_tags().size());
  for (int i = 0, n = _internal_tags().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_tags().Get(i));
  }

  // repeated string external_camera_ids = 8;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_external_camera_ids().size());
  for (int i = 0, n = _internal_external_camera_ids().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_external_camera_ids().Get(i));
  }

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

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

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

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

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

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

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

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

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

  _this->_internal_mutable_tags()->MergeFrom(from._internal_tags());
  _this->_internal_mutable_external_camera_ids()->MergeFrom(from._internal_external_camera_ids());
  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  if (!from._internal_name().empty()) {
    _this->_internal_set_name(from._internal_name());
  }
  if (!from._internal_description().empty()) {
    _this->_internal_set_description(from._internal_description());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_deleted_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_deleted_at());
    }
  }
  if (from._internal_company_id() != 0) {
    _this->_internal_set_company_id(from._internal_company_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void CameraCollection::InternalSwap(CameraCollection* 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_tags()->InternalSwap(
      other->_internal_mutable_tags());
  _internal_mutable_external_camera_ids()->InternalSwap(
      other->_internal_mutable_external_camera_ids());
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, lhs_arena,
                                       &other->_impl_.name_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.description_, lhs_arena,
                                       &other->_impl_.description_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CameraCollection, _impl_.company_id_)
      + sizeof(CameraCollection::_impl_.company_id_)
      - PROTOBUF_FIELD_OFFSET(CameraCollection, _impl_.changed_at_)>(
          reinterpret_cast<char*>(&_impl_.changed_at_),
          reinterpret_cast<char*>(&other->_impl_.changed_at_));
}

std::string CameraCollection::GetTypeName() const {
  return "keyapis.vc.v1.CameraCollection";
}

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

class DeleteCameraCollectionRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string DeleteCameraCollectionRequest::GetTypeName() const {
  return "keyapis.vc.v1.DeleteCameraCollectionRequest";
}

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

class PostCameraCollectionRestoreRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string PostCameraCollectionRestoreRequest::GetTypeName() const {
  return "keyapis.vc.v1.PostCameraCollectionRestoreRequest";
}

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

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

const ::keyapis::vc::v1::ValidationError&
DeleteCameraCollectionResponse_Error::_Internal::validation(const DeleteCameraCollectionResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void DeleteCameraCollectionResponse_Error::set_allocated_validation(::keyapis::vc::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.DeleteCameraCollectionResponse.Error.validation)
}
void DeleteCameraCollectionResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
DeleteCameraCollectionResponse_Error::DeleteCameraCollectionResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.DeleteCameraCollectionResponse.Error)
}
DeleteCameraCollectionResponse_Error::DeleteCameraCollectionResponse_Error(const DeleteCameraCollectionResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteCameraCollectionResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.DeleteCameraCollectionResponse.Error)
}

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

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

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

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

void DeleteCameraCollectionResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.DeleteCameraCollectionResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* DeleteCameraCollectionResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.vc.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.vc.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(this).GetCachedSize(), target, stream);
  }

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

::size_t DeleteCameraCollectionResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.DeleteCameraCollectionResponse.Error)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void DeleteCameraCollectionResponse_Error::InternalSwap(DeleteCameraCollectionResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string DeleteCameraCollectionResponse_Error::GetTypeName() const {
  return "keyapis.vc.v1.DeleteCameraCollectionResponse.Error";
}

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

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

const ::keyapis::vc::v1::DeleteCameraCollectionResponse_Error&
DeleteCameraCollectionResponse::_Internal::error(const DeleteCameraCollectionResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void DeleteCameraCollectionResponse::set_allocated_error(::keyapis::vc::v1::DeleteCameraCollectionResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.DeleteCameraCollectionResponse.error)
}
DeleteCameraCollectionResponse::DeleteCameraCollectionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.DeleteCameraCollectionResponse)
}
DeleteCameraCollectionResponse::DeleteCameraCollectionResponse(const DeleteCameraCollectionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteCameraCollectionResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::vc::v1::DeleteCameraCollectionResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.DeleteCameraCollectionResponse)
}

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

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

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

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

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


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

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

  // .keyapis.vc.v1.DeleteCameraCollectionResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(this).GetCachedSize(), target, stream);
  }

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

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

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

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

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

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

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

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

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

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

const ::keyapis::vc::v1::ValidationError&
PostCameraCollectionRestoreResponse_Error::_Internal::validation(const PostCameraCollectionRestoreResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PostCameraCollectionRestoreResponse_Error::set_allocated_validation(::keyapis::vc::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error.validation)
}
void PostCameraCollectionRestoreResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
PostCameraCollectionRestoreResponse_Error::PostCameraCollectionRestoreResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error)
}
PostCameraCollectionRestoreResponse_Error::PostCameraCollectionRestoreResponse_Error(const PostCameraCollectionRestoreResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostCameraCollectionRestoreResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error)
}

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

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

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

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

void PostCameraCollectionRestoreResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* PostCameraCollectionRestoreResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.vc.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.vc.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(this).GetCachedSize(), target, stream);
  }

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

::size_t PostCameraCollectionRestoreResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.vc.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::keyapis::vc::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostCameraCollectionRestoreResponse_Error::InternalSwap(PostCameraCollectionRestoreResponse_Error* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostCameraCollectionRestoreResponse_Error::GetTypeName() const {
  return "keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error";
}

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

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

const ::keyapis::vc::v1::PostCameraCollectionRestoreResponse_Error&
PostCameraCollectionRestoreResponse::_Internal::error(const PostCameraCollectionRestoreResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void PostCameraCollectionRestoreResponse::set_allocated_error(::keyapis::vc::v1::PostCameraCollectionRestoreResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.vc.v1.PostCameraCollectionRestoreResponse.error)
}
PostCameraCollectionRestoreResponse::PostCameraCollectionRestoreResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.vc.v1.PostCameraCollectionRestoreResponse)
}
PostCameraCollectionRestoreResponse::PostCameraCollectionRestoreResponse(const PostCameraCollectionRestoreResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostCameraCollectionRestoreResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::vc::v1::PostCameraCollectionRestoreResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.vc.v1.PostCameraCollectionRestoreResponse)
}

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

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

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

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

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


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

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

  // .keyapis.vc.v1.PostCameraCollectionRestoreResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(this).GetCachedSize(), target, stream);
  }

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

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

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

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

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

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

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

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace vc
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionCountRequest*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionCountResponse*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionRequest*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionResponse*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionListRequest*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::CameraCollectionFilter*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::CameraCollectionFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::CameraCollectionFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::CameraCollectionPaging*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::CameraCollectionPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::CameraCollectionPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::GetCameraCollectionListResponse*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::GetCameraCollectionListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::GetCameraCollectionListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::SaveCameraCollectionRequest*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::SaveCameraCollectionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::SaveCameraCollectionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::SaveCameraCollectionResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::SaveCameraCollectionResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::SaveCameraCollectionResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::SaveCameraCollectionResponse*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::SaveCameraCollectionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::SaveCameraCollectionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::CameraCollection_SavingError_Conflict*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::CameraCollection_SavingError_Conflict >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::CameraCollection_SavingError_Conflict >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::CameraCollection_SavingError_WrongCompanyId >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::CameraCollection_SavingError*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::CameraCollection_SavingError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::CameraCollection_SavingError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::CameraCollection*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::CameraCollection >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::CameraCollection >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::DeleteCameraCollectionRequest*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::DeleteCameraCollectionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::DeleteCameraCollectionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::PostCameraCollectionRestoreRequest*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::PostCameraCollectionRestoreRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::PostCameraCollectionRestoreRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::DeleteCameraCollectionResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::DeleteCameraCollectionResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::DeleteCameraCollectionResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::DeleteCameraCollectionResponse*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::DeleteCameraCollectionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::DeleteCameraCollectionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::PostCameraCollectionRestoreResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::PostCameraCollectionRestoreResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::PostCameraCollectionRestoreResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::vc::v1::PostCameraCollectionRestoreResponse*
Arena::CreateMaybeMessage< ::keyapis::vc::v1::PostCameraCollectionRestoreResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::vc::v1::PostCameraCollectionRestoreResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
