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

#include "keyapis/telemetry_control/v1/keyapis_telemetry_control_template_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 telemetry_control {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR PostTemplateDeviceRequest::PostTemplateDeviceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostTemplateDeviceRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostTemplateDeviceRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostTemplateDeviceRequestDefaultTypeInternal() {}
  union {
    PostTemplateDeviceRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostTemplateDeviceRequestDefaultTypeInternal _PostTemplateDeviceRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostTemplateDeviceResponse_Error::PostTemplateDeviceResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostTemplateDeviceResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostTemplateDeviceResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostTemplateDeviceResponse_ErrorDefaultTypeInternal() {}
  union {
    PostTemplateDeviceResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostTemplateDeviceResponse_ErrorDefaultTypeInternal _PostTemplateDeviceResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostTemplateDeviceResponse::PostTemplateDeviceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostTemplateDeviceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostTemplateDeviceResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostTemplateDeviceResponseDefaultTypeInternal() {}
  union {
    PostTemplateDeviceResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostTemplateDeviceResponseDefaultTypeInternal _PostTemplateDeviceResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteTemplateDeviceRequest::DeleteTemplateDeviceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteTemplateDeviceRequestDefaultTypeInternal _DeleteTemplateDeviceRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteTemplateDeviceResponse::DeleteTemplateDeviceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteTemplateDeviceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteTemplateDeviceResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteTemplateDeviceResponseDefaultTypeInternal() {}
  union {
    DeleteTemplateDeviceResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteTemplateDeviceResponseDefaultTypeInternal _DeleteTemplateDeviceResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceRequest::GetTemplateDeviceRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceRequestDefaultTypeInternal _GetTemplateDeviceRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceResponse::GetTemplateDeviceResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateDeviceResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateDeviceResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateDeviceResponseDefaultTypeInternal() {}
  union {
    GetTemplateDeviceResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceListRequestDefaultTypeInternal _GetTemplateDeviceListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDevicePaging_ValidationError_LimitInvalid::TemplateDevicePaging_ValidationError_LimitInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct TemplateDevicePaging_ValidationError_LimitInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateDevicePaging_ValidationError_LimitInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateDevicePaging_ValidationError_LimitInvalidDefaultTypeInternal() {}
  union {
    TemplateDevicePaging_ValidationError_LimitInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDevicePaging_ValidationError_LimitInvalidDefaultTypeInternal _TemplateDevicePaging_ValidationError_LimitInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDevicePaging_ValidationError_OffsetInvalid::TemplateDevicePaging_ValidationError_OffsetInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct TemplateDevicePaging_ValidationError_OffsetInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateDevicePaging_ValidationError_OffsetInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateDevicePaging_ValidationError_OffsetInvalidDefaultTypeInternal() {}
  union {
    TemplateDevicePaging_ValidationError_OffsetInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDevicePaging_ValidationError_OffsetInvalidDefaultTypeInternal _TemplateDevicePaging_ValidationError_OffsetInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDevicePaging_ValidationError::TemplateDevicePaging_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct TemplateDevicePaging_ValidationErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateDevicePaging_ValidationErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateDevicePaging_ValidationErrorDefaultTypeInternal() {}
  union {
    TemplateDevicePaging_ValidationError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDevicePaging_ValidationErrorDefaultTypeInternal _TemplateDevicePaging_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDevicePaging::TemplateDevicePaging(
    ::_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 TemplateDevicePagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateDevicePagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateDevicePagingDefaultTypeInternal() {}
  union {
    TemplateDevicePaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDevicePagingDefaultTypeInternal _TemplateDevicePaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDeviceFilter_ValidationError::TemplateDeviceFilter_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.path_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDeviceFilter_ValidationErrorDefaultTypeInternal _TemplateDeviceFilter_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDeviceFilter::TemplateDeviceFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.metric_types_)*/ {}
  , /*decltype(_impl_._metric_types_cached_byte_size_)*/ { 0 }

  , /*decltype(_impl_.model_ids_)*/ {}
  ,/* _impl_._model_ids_cached_byte_size_ = */ { 0 }

  , /*decltype(_impl_.plan_types_)*/ {}
  , /*decltype(_impl_._plan_types_cached_byte_size_)*/ { 0 }

  , /*decltype(_impl_.indicator_vendor_types_)*/ {}
  , /*decltype(_impl_._indicator_vendor_types_cached_byte_size_)*/ { 0 }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDeviceFilterDefaultTypeInternal _TemplateDeviceFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceListResponse_Error::GetTemplateDeviceListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateDeviceListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateDeviceListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateDeviceListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetTemplateDeviceListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceListResponse_ErrorDefaultTypeInternal _GetTemplateDeviceListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceListResponse::GetTemplateDeviceListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateDeviceListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateDeviceListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateDeviceListResponseDefaultTypeInternal() {}
  union {
    GetTemplateDeviceListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceListResponseDefaultTypeInternal _GetTemplateDeviceListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceCountRequest::GetTemplateDeviceCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetTemplateDeviceCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateDeviceCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateDeviceCountRequestDefaultTypeInternal() {}
  union {
    GetTemplateDeviceCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceCountRequestDefaultTypeInternal _GetTemplateDeviceCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceCountResponse_Error::GetTemplateDeviceCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateDeviceCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateDeviceCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateDeviceCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetTemplateDeviceCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceCountResponse_ErrorDefaultTypeInternal _GetTemplateDeviceCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateDeviceCountResponse::GetTemplateDeviceCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateDeviceCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateDeviceCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateDeviceCountResponseDefaultTypeInternal() {}
  union {
    GetTemplateDeviceCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateDeviceCountResponseDefaultTypeInternal _GetTemplateDeviceCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDevice_ValidationError::TemplateDevice_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.path_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDevice_ValidationErrorDefaultTypeInternal _TemplateDevice_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateDevice::TemplateDevice(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.indicator_template_ids_)*/ {}
  ,/* _impl_._indicator_template_ids_cached_byte_size_ = */ { 0 }

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

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

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

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

  , /*decltype(_impl_.indicator_vendor_type_)*/ 0
} {}
struct TemplateDeviceDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateDeviceDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateDeviceDefaultTypeInternal() {}
  union {
    TemplateDevice _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateDeviceDefaultTypeInternal _TemplateDevice_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorRequest::GetTemplateIndicatorRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorRequestDefaultTypeInternal _GetTemplateIndicatorRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorResponse::GetTemplateIndicatorResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateIndicatorResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateIndicatorResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateIndicatorResponseDefaultTypeInternal() {}
  union {
    GetTemplateIndicatorResponse _instance;
  };
};

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorListRequestDefaultTypeInternal _GetTemplateIndicatorListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicatorPaging_ValidationError_LimitInvalid::TemplateIndicatorPaging_ValidationError_LimitInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct TemplateIndicatorPaging_ValidationError_LimitInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateIndicatorPaging_ValidationError_LimitInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateIndicatorPaging_ValidationError_LimitInvalidDefaultTypeInternal() {}
  union {
    TemplateIndicatorPaging_ValidationError_LimitInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorPaging_ValidationError_LimitInvalidDefaultTypeInternal _TemplateIndicatorPaging_ValidationError_LimitInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicatorPaging_ValidationError_OffsetInvalid::TemplateIndicatorPaging_ValidationError_OffsetInvalid(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct TemplateIndicatorPaging_ValidationError_OffsetInvalidDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateIndicatorPaging_ValidationError_OffsetInvalidDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateIndicatorPaging_ValidationError_OffsetInvalidDefaultTypeInternal() {}
  union {
    TemplateIndicatorPaging_ValidationError_OffsetInvalid _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorPaging_ValidationError_OffsetInvalidDefaultTypeInternal _TemplateIndicatorPaging_ValidationError_OffsetInvalid_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicatorPaging_ValidationError::TemplateIndicatorPaging_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct TemplateIndicatorPaging_ValidationErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateIndicatorPaging_ValidationErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateIndicatorPaging_ValidationErrorDefaultTypeInternal() {}
  union {
    TemplateIndicatorPaging_ValidationError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorPaging_ValidationErrorDefaultTypeInternal _TemplateIndicatorPaging_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicatorPaging::TemplateIndicatorPaging(
    ::_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 TemplateIndicatorPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateIndicatorPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateIndicatorPagingDefaultTypeInternal() {}
  union {
    TemplateIndicatorPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorPagingDefaultTypeInternal _TemplateIndicatorPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicatorFilter_ValidationError::TemplateIndicatorFilter_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.path_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorFilter_ValidationErrorDefaultTypeInternal _TemplateIndicatorFilter_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicatorFilter::TemplateIndicatorFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.sign_types_)*/ {}
  , /*decltype(_impl_._sign_types_cached_byte_size_)*/ { 0 }

  , /*decltype(_impl_.archive_types_)*/ {}
  , /*decltype(_impl_._archive_types_cached_byte_size_)*/ { 0 }

  , /*decltype(_impl_.indicator_vendor_types_)*/ {}
  , /*decltype(_impl_._indicator_vendor_types_cached_byte_size_)*/ { 0 }

  , /*decltype(_impl_.is_individual_)*/nullptr
  , /*decltype(_impl_.title_)*/nullptr} {}
struct TemplateIndicatorFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateIndicatorFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateIndicatorFilterDefaultTypeInternal() {}
  union {
    TemplateIndicatorFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorFilterDefaultTypeInternal _TemplateIndicatorFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorListResponse_Error::GetTemplateIndicatorListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateIndicatorListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateIndicatorListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateIndicatorListResponse_ErrorDefaultTypeInternal() {}
  union {
    GetTemplateIndicatorListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorListResponse_ErrorDefaultTypeInternal _GetTemplateIndicatorListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorListResponse::GetTemplateIndicatorListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateIndicatorListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateIndicatorListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateIndicatorListResponseDefaultTypeInternal() {}
  union {
    GetTemplateIndicatorListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorListResponseDefaultTypeInternal _GetTemplateIndicatorListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorCountRequest::GetTemplateIndicatorCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetTemplateIndicatorCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateIndicatorCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateIndicatorCountRequestDefaultTypeInternal() {}
  union {
    GetTemplateIndicatorCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorCountRequestDefaultTypeInternal _GetTemplateIndicatorCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorCountResponse_Error::GetTemplateIndicatorCountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateIndicatorCountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateIndicatorCountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateIndicatorCountResponse_ErrorDefaultTypeInternal() {}
  union {
    GetTemplateIndicatorCountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorCountResponse_ErrorDefaultTypeInternal _GetTemplateIndicatorCountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetTemplateIndicatorCountResponse::GetTemplateIndicatorCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetTemplateIndicatorCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetTemplateIndicatorCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetTemplateIndicatorCountResponseDefaultTypeInternal() {}
  union {
    GetTemplateIndicatorCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetTemplateIndicatorCountResponseDefaultTypeInternal _GetTemplateIndicatorCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostTemplateIndicatorRequest::PostTemplateIndicatorRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostTemplateIndicatorRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostTemplateIndicatorRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostTemplateIndicatorRequestDefaultTypeInternal() {}
  union {
    PostTemplateIndicatorRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostTemplateIndicatorRequestDefaultTypeInternal _PostTemplateIndicatorRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostTemplateIndicatorResponse_Error::PostTemplateIndicatorResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostTemplateIndicatorResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostTemplateIndicatorResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostTemplateIndicatorResponse_ErrorDefaultTypeInternal() {}
  union {
    PostTemplateIndicatorResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostTemplateIndicatorResponse_ErrorDefaultTypeInternal _PostTemplateIndicatorResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostTemplateIndicatorResponse::PostTemplateIndicatorResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostTemplateIndicatorResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostTemplateIndicatorResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostTemplateIndicatorResponseDefaultTypeInternal() {}
  union {
    PostTemplateIndicatorResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostTemplateIndicatorResponseDefaultTypeInternal _PostTemplateIndicatorResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteTemplateIndicatorRequest::DeleteTemplateIndicatorRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteTemplateIndicatorRequestDefaultTypeInternal _DeleteTemplateIndicatorRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteTemplateIndicatorResponse::DeleteTemplateIndicatorResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteTemplateIndicatorResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteTemplateIndicatorResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteTemplateIndicatorResponseDefaultTypeInternal() {}
  union {
    DeleteTemplateIndicatorResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteTemplateIndicatorResponseDefaultTypeInternal _DeleteTemplateIndicatorResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicator_ValidationError::TemplateIndicator_ValidationError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.path_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicator_ValidationErrorDefaultTypeInternal _TemplateIndicator_ValidationError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR TemplateIndicator::TemplateIndicator(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.title_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.compatibility_code_)*/nullptr
  , /*decltype(_impl_.coefficient_)*/nullptr
  , /*decltype(_impl_.shift_)*/nullptr
  , /*decltype(_impl_.round_decimal_digits_)*/nullptr
  , /*decltype(_impl_.id_)*/ 0

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

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

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

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

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

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

  , /*decltype(_impl_.indicator_vendor_type_)*/ 0
} {}
struct TemplateIndicatorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemplateIndicatorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemplateIndicatorDefaultTypeInternal() {}
  union {
    TemplateIndicator _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemplateIndicatorDefaultTypeInternal _TemplateIndicator_default_instance_;
}  // namespace v1
}  // namespace telemetry_control
}  // namespace keyapis
namespace keyapis {
namespace telemetry_control {
namespace v1 {
bool TemplateDevicePaging_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>
    TemplateDevicePaging_OrderByType_strings[4] = {};

static const char TemplateDevicePaging_OrderByType_names[] = {
    "ID"
    "METRIC_TYPE"
    "MODEL"
    "ORDER_BY_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateDevicePaging_OrderByType_entries[] =
    {
        {{&TemplateDevicePaging_OrderByType_names[0], 2}, 1},
        {{&TemplateDevicePaging_OrderByType_names[2], 11}, 2},
        {{&TemplateDevicePaging_OrderByType_names[13], 5}, 3},
        {{&TemplateDevicePaging_OrderByType_names[18], 21}, 0},
};

static const int TemplateDevicePaging_OrderByType_entries_by_number[] = {
    3,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> ID
    1,  // 2 -> METRIC_TYPE
    2,  // 3 -> MODEL
};

const std::string& TemplateDevicePaging_OrderByType_Name(TemplateDevicePaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateDevicePaging_OrderByType_entries, TemplateDevicePaging_OrderByType_entries_by_number,
          4, TemplateDevicePaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateDevicePaging_OrderByType_entries, TemplateDevicePaging_OrderByType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateDevicePaging_OrderByType_strings[idx].get();
}

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

constexpr TemplateDevicePaging_OrderByType TemplateDevicePaging::ORDER_BY_TYPE_UNKNOWN;
constexpr TemplateDevicePaging_OrderByType TemplateDevicePaging::ID;
constexpr TemplateDevicePaging_OrderByType TemplateDevicePaging::METRIC_TYPE;
constexpr TemplateDevicePaging_OrderByType TemplateDevicePaging::MODEL;
constexpr TemplateDevicePaging_OrderByType TemplateDevicePaging::OrderByType_MIN;
constexpr TemplateDevicePaging_OrderByType TemplateDevicePaging::OrderByType_MAX;
constexpr int TemplateDevicePaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& TemplateDevicePaging_DirectionType_Name(TemplateDevicePaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateDevicePaging_DirectionType_entries, TemplateDevicePaging_DirectionType_entries_by_number,
          3, TemplateDevicePaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateDevicePaging_DirectionType_entries, TemplateDevicePaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateDevicePaging_DirectionType_strings[idx].get();
}

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

constexpr TemplateDevicePaging_DirectionType TemplateDevicePaging::DIRECTION_TYPE_UNKNOWN;
constexpr TemplateDevicePaging_DirectionType TemplateDevicePaging::DESC;
constexpr TemplateDevicePaging_DirectionType TemplateDevicePaging::ASC;
constexpr TemplateDevicePaging_DirectionType TemplateDevicePaging::DirectionType_MIN;
constexpr TemplateDevicePaging_DirectionType TemplateDevicePaging::DirectionType_MAX;
constexpr int TemplateDevicePaging::DirectionType_ARRAYSIZE;

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

static const char TemplateDevice_MetricType_names[] = {
    "COLD_WATER"
    "ELECTRICITY"
    "GAS"
    "HEAT"
    "HOT_WATER"
    "METRIC_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateDevice_MetricType_entries[] =
    {
        {{&TemplateDevice_MetricType_names[0], 10}, 2},
        {{&TemplateDevice_MetricType_names[10], 11}, 5},
        {{&TemplateDevice_MetricType_names[21], 3}, 4},
        {{&TemplateDevice_MetricType_names[24], 4}, 3},
        {{&TemplateDevice_MetricType_names[28], 9}, 1},
        {{&TemplateDevice_MetricType_names[37], 19}, 0},
};

static const int TemplateDevice_MetricType_entries_by_number[] = {
    5,  // 0 -> METRIC_TYPE_UNKNOWN
    4,  // 1 -> HOT_WATER
    0,  // 2 -> COLD_WATER
    3,  // 3 -> HEAT
    2,  // 4 -> GAS
    1,  // 5 -> ELECTRICITY
};

const std::string& TemplateDevice_MetricType_Name(TemplateDevice_MetricType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateDevice_MetricType_entries, TemplateDevice_MetricType_entries_by_number,
          6, TemplateDevice_MetricType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateDevice_MetricType_entries, TemplateDevice_MetricType_entries_by_number, 6,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateDevice_MetricType_strings[idx].get();
}

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

constexpr TemplateDevice_MetricType TemplateDevice::METRIC_TYPE_UNKNOWN;
constexpr TemplateDevice_MetricType TemplateDevice::HOT_WATER;
constexpr TemplateDevice_MetricType TemplateDevice::COLD_WATER;
constexpr TemplateDevice_MetricType TemplateDevice::HEAT;
constexpr TemplateDevice_MetricType TemplateDevice::GAS;
constexpr TemplateDevice_MetricType TemplateDevice::ELECTRICITY;
constexpr TemplateDevice_MetricType TemplateDevice::MetricType_MIN;
constexpr TemplateDevice_MetricType TemplateDevice::MetricType_MAX;
constexpr int TemplateDevice::MetricType_ARRAYSIZE;

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

static const char TemplateDevice_PlanType_names[] = {
    "DOUBLE"
    "PLAN_TYPE_UNKNOWN"
    "SINGLE"
    "TRIPLE"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateDevice_PlanType_entries[] =
    {
        {{&TemplateDevice_PlanType_names[0], 6}, 2},
        {{&TemplateDevice_PlanType_names[6], 17}, 0},
        {{&TemplateDevice_PlanType_names[23], 6}, 1},
        {{&TemplateDevice_PlanType_names[29], 6}, 3},
};

static const int TemplateDevice_PlanType_entries_by_number[] = {
    1,  // 0 -> PLAN_TYPE_UNKNOWN
    2,  // 1 -> SINGLE
    0,  // 2 -> DOUBLE
    3,  // 3 -> TRIPLE
};

const std::string& TemplateDevice_PlanType_Name(TemplateDevice_PlanType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateDevice_PlanType_entries, TemplateDevice_PlanType_entries_by_number,
          4, TemplateDevice_PlanType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateDevice_PlanType_entries, TemplateDevice_PlanType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateDevice_PlanType_strings[idx].get();
}

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

constexpr TemplateDevice_PlanType TemplateDevice::PLAN_TYPE_UNKNOWN;
constexpr TemplateDevice_PlanType TemplateDevice::SINGLE;
constexpr TemplateDevice_PlanType TemplateDevice::DOUBLE;
constexpr TemplateDevice_PlanType TemplateDevice::TRIPLE;
constexpr TemplateDevice_PlanType TemplateDevice::PlanType_MIN;
constexpr TemplateDevice_PlanType TemplateDevice::PlanType_MAX;
constexpr int TemplateDevice::PlanType_ARRAYSIZE;

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

static const char TemplateIndicatorPaging_OrderByType_names[] = {
    "ARCHIVE_TYPE"
    "ID"
    "ORDER_BY_TYPE_UNKNOWN"
    "SIGN_TYPE"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateIndicatorPaging_OrderByType_entries[] =
    {
        {{&TemplateIndicatorPaging_OrderByType_names[0], 12}, 3},
        {{&TemplateIndicatorPaging_OrderByType_names[12], 2}, 1},
        {{&TemplateIndicatorPaging_OrderByType_names[14], 21}, 0},
        {{&TemplateIndicatorPaging_OrderByType_names[35], 9}, 2},
};

static const int TemplateIndicatorPaging_OrderByType_entries_by_number[] = {
    2,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    1,  // 1 -> ID
    3,  // 2 -> SIGN_TYPE
    0,  // 3 -> ARCHIVE_TYPE
};

const std::string& TemplateIndicatorPaging_OrderByType_Name(TemplateIndicatorPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateIndicatorPaging_OrderByType_entries, TemplateIndicatorPaging_OrderByType_entries_by_number,
          4, TemplateIndicatorPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateIndicatorPaging_OrderByType_entries, TemplateIndicatorPaging_OrderByType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateIndicatorPaging_OrderByType_strings[idx].get();
}

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

constexpr TemplateIndicatorPaging_OrderByType TemplateIndicatorPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr TemplateIndicatorPaging_OrderByType TemplateIndicatorPaging::ID;
constexpr TemplateIndicatorPaging_OrderByType TemplateIndicatorPaging::SIGN_TYPE;
constexpr TemplateIndicatorPaging_OrderByType TemplateIndicatorPaging::ARCHIVE_TYPE;
constexpr TemplateIndicatorPaging_OrderByType TemplateIndicatorPaging::OrderByType_MIN;
constexpr TemplateIndicatorPaging_OrderByType TemplateIndicatorPaging::OrderByType_MAX;
constexpr int TemplateIndicatorPaging::OrderByType_ARRAYSIZE;

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

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

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

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

const std::string& TemplateIndicatorPaging_DirectionType_Name(TemplateIndicatorPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateIndicatorPaging_DirectionType_entries, TemplateIndicatorPaging_DirectionType_entries_by_number,
          3, TemplateIndicatorPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateIndicatorPaging_DirectionType_entries, TemplateIndicatorPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateIndicatorPaging_DirectionType_strings[idx].get();
}

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

constexpr TemplateIndicatorPaging_DirectionType TemplateIndicatorPaging::DIRECTION_TYPE_UNKNOWN;
constexpr TemplateIndicatorPaging_DirectionType TemplateIndicatorPaging::DESC;
constexpr TemplateIndicatorPaging_DirectionType TemplateIndicatorPaging::ASC;
constexpr TemplateIndicatorPaging_DirectionType TemplateIndicatorPaging::DirectionType_MIN;
constexpr TemplateIndicatorPaging_DirectionType TemplateIndicatorPaging::DirectionType_MAX;
constexpr int TemplateIndicatorPaging::DirectionType_ARRAYSIZE;

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

static const char TemplateIndicator_VendorType_names[] = {
    "ENVIRO"
    "LARTECH"
    "RTK"
    "VENDOR_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateIndicator_VendorType_entries[] =
    {
        {{&TemplateIndicator_VendorType_names[0], 6}, 1},
        {{&TemplateIndicator_VendorType_names[6], 7}, 2},
        {{&TemplateIndicator_VendorType_names[13], 3}, 3},
        {{&TemplateIndicator_VendorType_names[16], 19}, 0},
};

static const int TemplateIndicator_VendorType_entries_by_number[] = {
    3,  // 0 -> VENDOR_TYPE_UNKNOWN
    0,  // 1 -> ENVIRO
    1,  // 2 -> LARTECH
    2,  // 3 -> RTK
};

const std::string& TemplateIndicator_VendorType_Name(TemplateIndicator_VendorType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateIndicator_VendorType_entries, TemplateIndicator_VendorType_entries_by_number,
          4, TemplateIndicator_VendorType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateIndicator_VendorType_entries, TemplateIndicator_VendorType_entries_by_number, 4,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateIndicator_VendorType_strings[idx].get();
}

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

constexpr TemplateIndicator_VendorType TemplateIndicator::VENDOR_TYPE_UNKNOWN;
constexpr TemplateIndicator_VendorType TemplateIndicator::ENVIRO;
constexpr TemplateIndicator_VendorType TemplateIndicator::LARTECH;
constexpr TemplateIndicator_VendorType TemplateIndicator::RTK;
constexpr TemplateIndicator_VendorType TemplateIndicator::VendorType_MIN;
constexpr TemplateIndicator_VendorType TemplateIndicator::VendorType_MAX;
constexpr int TemplateIndicator::VendorType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool TemplateIndicator_UnitType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    TemplateIndicator_UnitType_strings[26] = {};

static const char TemplateIndicator_UnitType_names[] = {
    "BOOLEAN"
    "C"
    "GJ"
    "GKAL"
    "H"
    "IMP"
    "J"
    "KGF_CM2"
    "KG_CM2"
    "KJ"
    "KWH"
    "KWT"
    "M3"
    "M3_H"
    "MIN"
    "MPA"
    "MS"
    "NON_MEASURABLE"
    "PERCENT"
    "S"
    "T"
    "T_H"
    "UNIT_TYPE_UNKNOWN"
    "VALUE"
    "WT"
    "WTH"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateIndicator_UnitType_entries[] =
    {
        {{&TemplateIndicator_UnitType_names[0], 7}, 13},
        {{&TemplateIndicator_UnitType_names[7], 1}, 2},
        {{&TemplateIndicator_UnitType_names[8], 2}, 21},
        {{&TemplateIndicator_UnitType_names[10], 4}, 4},
        {{&TemplateIndicator_UnitType_names[14], 1}, 16},
        {{&TemplateIndicator_UnitType_names[15], 3}, 18},
        {{&TemplateIndicator_UnitType_names[18], 1}, 19},
        {{&TemplateIndicator_UnitType_names[19], 7}, 8},
        {{&TemplateIndicator_UnitType_names[26], 6}, 7},
        {{&TemplateIndicator_UnitType_names[32], 2}, 20},
        {{&TemplateIndicator_UnitType_names[34], 3}, 6},
        {{&TemplateIndicator_UnitType_names[37], 3}, 23},
        {{&TemplateIndicator_UnitType_names[40], 2}, 9},
        {{&TemplateIndicator_UnitType_names[42], 4}, 10},
        {{&TemplateIndicator_UnitType_names[46], 3}, 24},
        {{&TemplateIndicator_UnitType_names[49], 3}, 11},
        {{&TemplateIndicator_UnitType_names[52], 2}, 12},
        {{&TemplateIndicator_UnitType_names[54], 14}, 17},
        {{&TemplateIndicator_UnitType_names[68], 7}, 1},
        {{&TemplateIndicator_UnitType_names[75], 1}, 25},
        {{&TemplateIndicator_UnitType_names[76], 1}, 14},
        {{&TemplateIndicator_UnitType_names[77], 3}, 15},
        {{&TemplateIndicator_UnitType_names[80], 17}, 0},
        {{&TemplateIndicator_UnitType_names[97], 5}, 5},
        {{&TemplateIndicator_UnitType_names[102], 2}, 3},
        {{&TemplateIndicator_UnitType_names[104], 3}, 22},
};

static const int TemplateIndicator_UnitType_entries_by_number[] = {
    22,  // 0 -> UNIT_TYPE_UNKNOWN
    18,  // 1 -> PERCENT
    1,  // 2 -> C
    24,  // 3 -> WT
    3,  // 4 -> GKAL
    23,  // 5 -> VALUE
    10,  // 6 -> KWH
    8,  // 7 -> KG_CM2
    7,  // 8 -> KGF_CM2
    12,  // 9 -> M3
    13,  // 10 -> M3_H
    15,  // 11 -> MPA
    16,  // 12 -> MS
    0,  // 13 -> BOOLEAN
    20,  // 14 -> T
    21,  // 15 -> T_H
    4,  // 16 -> H
    17,  // 17 -> NON_MEASURABLE
    5,  // 18 -> IMP
    6,  // 19 -> J
    9,  // 20 -> KJ
    2,  // 21 -> GJ
    25,  // 22 -> WTH
    11,  // 23 -> KWT
    14,  // 24 -> MIN
    19,  // 25 -> S
};

const std::string& TemplateIndicator_UnitType_Name(TemplateIndicator_UnitType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateIndicator_UnitType_entries, TemplateIndicator_UnitType_entries_by_number,
          26, TemplateIndicator_UnitType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateIndicator_UnitType_entries, TemplateIndicator_UnitType_entries_by_number, 26,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateIndicator_UnitType_strings[idx].get();
}

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

constexpr TemplateIndicator_UnitType TemplateIndicator::UNIT_TYPE_UNKNOWN;
constexpr TemplateIndicator_UnitType TemplateIndicator::PERCENT;
constexpr TemplateIndicator_UnitType TemplateIndicator::C;
constexpr TemplateIndicator_UnitType TemplateIndicator::WT;
constexpr TemplateIndicator_UnitType TemplateIndicator::GKAL;
constexpr TemplateIndicator_UnitType TemplateIndicator::VALUE;
constexpr TemplateIndicator_UnitType TemplateIndicator::KWH;
constexpr TemplateIndicator_UnitType TemplateIndicator::KG_CM2;
constexpr TemplateIndicator_UnitType TemplateIndicator::KGF_CM2;
constexpr TemplateIndicator_UnitType TemplateIndicator::M3;
constexpr TemplateIndicator_UnitType TemplateIndicator::M3_H;
constexpr TemplateIndicator_UnitType TemplateIndicator::MPA;
constexpr TemplateIndicator_UnitType TemplateIndicator::MS;
constexpr TemplateIndicator_UnitType TemplateIndicator::BOOLEAN;
constexpr TemplateIndicator_UnitType TemplateIndicator::T;
constexpr TemplateIndicator_UnitType TemplateIndicator::T_H;
constexpr TemplateIndicator_UnitType TemplateIndicator::H;
constexpr TemplateIndicator_UnitType TemplateIndicator::NON_MEASURABLE;
constexpr TemplateIndicator_UnitType TemplateIndicator::IMP;
constexpr TemplateIndicator_UnitType TemplateIndicator::J;
constexpr TemplateIndicator_UnitType TemplateIndicator::KJ;
constexpr TemplateIndicator_UnitType TemplateIndicator::GJ;
constexpr TemplateIndicator_UnitType TemplateIndicator::WTH;
constexpr TemplateIndicator_UnitType TemplateIndicator::KWT;
constexpr TemplateIndicator_UnitType TemplateIndicator::MIN;
constexpr TemplateIndicator_UnitType TemplateIndicator::S;
constexpr TemplateIndicator_UnitType TemplateIndicator::UnitType_MIN;
constexpr TemplateIndicator_UnitType TemplateIndicator::UnitType_MAX;
constexpr int TemplateIndicator::UnitType_ARRAYSIZE;

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

static const char TemplateIndicator_SignType_names[] = {
    "ABSOLUTE_DS"
    "ABSOLUTE_RC"
    "CURRENT_DS"
    "CURRENT_RS"
    "FLAG"
    "INTERVAL_DS"
    "INTERVAL_RC"
    "PARAMETER"
    "SIGN_TYPE_UNKNOWN"
    "VOLUME"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateIndicator_SignType_entries[] =
    {
        {{&TemplateIndicator_SignType_names[0], 11}, 1},
        {{&TemplateIndicator_SignType_names[11], 11}, 2},
        {{&TemplateIndicator_SignType_names[22], 10}, 5},
        {{&TemplateIndicator_SignType_names[32], 10}, 6},
        {{&TemplateIndicator_SignType_names[42], 4}, 9},
        {{&TemplateIndicator_SignType_names[46], 11}, 3},
        {{&TemplateIndicator_SignType_names[57], 11}, 4},
        {{&TemplateIndicator_SignType_names[68], 9}, 8},
        {{&TemplateIndicator_SignType_names[77], 17}, 0},
        {{&TemplateIndicator_SignType_names[94], 6}, 7},
};

static const int TemplateIndicator_SignType_entries_by_number[] = {
    8,  // 0 -> SIGN_TYPE_UNKNOWN
    0,  // 1 -> ABSOLUTE_DS
    1,  // 2 -> ABSOLUTE_RC
    5,  // 3 -> INTERVAL_DS
    6,  // 4 -> INTERVAL_RC
    2,  // 5 -> CURRENT_DS
    3,  // 6 -> CURRENT_RS
    9,  // 7 -> VOLUME
    7,  // 8 -> PARAMETER
    4,  // 9 -> FLAG
};

const std::string& TemplateIndicator_SignType_Name(TemplateIndicator_SignType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateIndicator_SignType_entries, TemplateIndicator_SignType_entries_by_number,
          10, TemplateIndicator_SignType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateIndicator_SignType_entries, TemplateIndicator_SignType_entries_by_number, 10,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateIndicator_SignType_strings[idx].get();
}

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

constexpr TemplateIndicator_SignType TemplateIndicator::SIGN_TYPE_UNKNOWN;
constexpr TemplateIndicator_SignType TemplateIndicator::ABSOLUTE_DS;
constexpr TemplateIndicator_SignType TemplateIndicator::ABSOLUTE_RC;
constexpr TemplateIndicator_SignType TemplateIndicator::INTERVAL_DS;
constexpr TemplateIndicator_SignType TemplateIndicator::INTERVAL_RC;
constexpr TemplateIndicator_SignType TemplateIndicator::CURRENT_DS;
constexpr TemplateIndicator_SignType TemplateIndicator::CURRENT_RS;
constexpr TemplateIndicator_SignType TemplateIndicator::VOLUME;
constexpr TemplateIndicator_SignType TemplateIndicator::PARAMETER;
constexpr TemplateIndicator_SignType TemplateIndicator::FLAG;
constexpr TemplateIndicator_SignType TemplateIndicator::SignType_MIN;
constexpr TemplateIndicator_SignType TemplateIndicator::SignType_MAX;
constexpr int TemplateIndicator::SignType_ARRAYSIZE;

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

static const char TemplateIndicator_ArchiveType_names[] = {
    "ARCHIVE_TYPE_UNKNOWN"
    "CURRENT"
    "DAY"
    "HALFHOUR"
    "HOUR"
    "MONTH"
    "YEAR"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry TemplateIndicator_ArchiveType_entries[] =
    {
        {{&TemplateIndicator_ArchiveType_names[0], 20}, 0},
        {{&TemplateIndicator_ArchiveType_names[20], 7}, 1},
        {{&TemplateIndicator_ArchiveType_names[27], 3}, 4},
        {{&TemplateIndicator_ArchiveType_names[30], 8}, 2},
        {{&TemplateIndicator_ArchiveType_names[38], 4}, 3},
        {{&TemplateIndicator_ArchiveType_names[42], 5}, 5},
        {{&TemplateIndicator_ArchiveType_names[47], 4}, 6},
};

static const int TemplateIndicator_ArchiveType_entries_by_number[] = {
    0,  // 0 -> ARCHIVE_TYPE_UNKNOWN
    1,  // 1 -> CURRENT
    3,  // 2 -> HALFHOUR
    4,  // 3 -> HOUR
    2,  // 4 -> DAY
    5,  // 5 -> MONTH
    6,  // 6 -> YEAR
};

const std::string& TemplateIndicator_ArchiveType_Name(TemplateIndicator_ArchiveType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          TemplateIndicator_ArchiveType_entries, TemplateIndicator_ArchiveType_entries_by_number,
          7, TemplateIndicator_ArchiveType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      TemplateIndicator_ArchiveType_entries, TemplateIndicator_ArchiveType_entries_by_number, 7,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : TemplateIndicator_ArchiveType_strings[idx].get();
}

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

constexpr TemplateIndicator_ArchiveType TemplateIndicator::ARCHIVE_TYPE_UNKNOWN;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::CURRENT;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::HALFHOUR;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::HOUR;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::DAY;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::MONTH;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::YEAR;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::ArchiveType_MIN;
constexpr TemplateIndicator_ArchiveType TemplateIndicator::ArchiveType_MAX;
constexpr int TemplateIndicator::ArchiveType_ARRAYSIZE;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::keyapis::telemetry_control::v1::TemplateDevice_ValidationError&
PostTemplateDeviceResponse_Error::_Internal::validation(const PostTemplateDeviceResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PostTemplateDeviceResponse_Error::set_allocated_validation(::keyapis::telemetry_control::v1::TemplateDevice_ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(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.telemetry_control.v1.PostTemplateDeviceResponse.Error.validation)
}
PostTemplateDeviceResponse_Error::PostTemplateDeviceResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.PostTemplateDeviceResponse.Error)
}
PostTemplateDeviceResponse_Error::PostTemplateDeviceResponse_Error(const PostTemplateDeviceResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostTemplateDeviceResponse_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::telemetry_control::v1::TemplateDevice_ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.PostTemplateDeviceResponse.Error)
}

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

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

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

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

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

  // .keyapis.telemetry_control.v1.TemplateDevice.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.telemetry_control.v1.PostTemplateDeviceResponse.Error)
  return target;
}

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

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

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

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

void PostTemplateDeviceResponse_Error::InternalSwap(PostTemplateDeviceResponse_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 PostTemplateDeviceResponse_Error::GetTypeName() const {
  return "keyapis.telemetry_control.v1.PostTemplateDeviceResponse.Error";
}

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

class PostTemplateDeviceResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::PostTemplateDeviceResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateDevice& data(const PostTemplateDeviceResponse* msg);
  static const ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse_Error& error(const PostTemplateDeviceResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

class DeleteTemplateDeviceRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string DeleteTemplateDeviceRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DeleteTemplateDeviceRequest";
}

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

class DeleteTemplateDeviceResponse::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

std::string DeleteTemplateDeviceResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DeleteTemplateDeviceResponse";
}

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

class GetTemplateDeviceRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string GetTemplateDeviceRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetTemplateDeviceRequest";
}

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.telemetry_control.v1.TemplateDeviceFilter 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.telemetry_control.v1.TemplateDevicePaging 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.telemetry_control.v1.GetTemplateDeviceListRequest)
  return target;
}

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

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

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

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

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

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

class TemplateDevicePaging_ValidationError_LimitInvalid::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

::size_t TemplateDevicePaging_ValidationError_LimitInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.LimitInvalid)
  ::size_t total_size = 0;

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

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

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

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

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

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

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

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

std::string TemplateDevicePaging_ValidationError_LimitInvalid::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.LimitInvalid";
}

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

class TemplateDevicePaging_ValidationError_OffsetInvalid::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

::size_t TemplateDevicePaging_ValidationError_OffsetInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.OffsetInvalid)
  ::size_t total_size = 0;

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

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

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

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

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

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

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

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

std::string TemplateDevicePaging_ValidationError_OffsetInvalid::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.OffsetInvalid";
}

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

class TemplateDevicePaging_ValidationError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid& limit(const TemplateDevicePaging_ValidationError* msg);
  static const ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid& offset(const TemplateDevicePaging_ValidationError* msg);
};

const ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid&
TemplateDevicePaging_ValidationError::_Internal::limit(const TemplateDevicePaging_ValidationError* msg) {
  return *msg->_impl_.reason_.limit_;
}
const ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid&
TemplateDevicePaging_ValidationError::_Internal::offset(const TemplateDevicePaging_ValidationError* msg) {
  return *msg->_impl_.reason_.offset_;
}
void TemplateDevicePaging_ValidationError::set_allocated_limit(::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid* limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit);
    if (message_arena != submessage_arena) {
      limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit, submessage_arena);
    }
    set_has_limit();
    _impl_.reason_.limit_ = limit;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.limit)
}
void TemplateDevicePaging_ValidationError::set_allocated_offset(::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid* offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(offset);
    if (message_arena != submessage_arena) {
      offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, offset, submessage_arena);
    }
    set_has_offset();
    _impl_.reason_.offset_ = offset;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.offset)
}
TemplateDevicePaging_ValidationError::TemplateDevicePaging_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError)
}
TemplateDevicePaging_ValidationError::TemplateDevicePaging_ValidationError(const TemplateDevicePaging_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateDevicePaging_ValidationError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kLimit: {
      _this->_internal_mutable_limit()->::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid::MergeFrom(
          from._internal_limit());
      break;
    }
    case kOffset: {
      _this->_internal_mutable_offset()->::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid::MergeFrom(
          from._internal_offset());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError)
}

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

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

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

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

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


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

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

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

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

  switch (reason_case()) {
    case kLimit: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::limit(this),
          _Internal::limit(this).GetCachedSize(), target, stream);
      break;
    }
    case kOffset: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::offset(this),
          _Internal::offset(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError)
  return target;
}

::size_t TemplateDevicePaging_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.LimitInvalid limit = 1;
    case kLimit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.limit_);
      break;
    }
    // .keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError.OffsetInvalid offset = 2;
    case kOffset: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.offset_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

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

std::string TemplateDevicePaging_ValidationError::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError";
}

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

class TemplateDevicePaging::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

std::string TemplateDevicePaging::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDevicePaging";
}

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

class TemplateDeviceFilter_ValidationError::_Internal {
 public:
};

TemplateDeviceFilter_ValidationError::TemplateDeviceFilter_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateDeviceFilter.ValidationError)
}
TemplateDeviceFilter_ValidationError::TemplateDeviceFilter_ValidationError(const TemplateDeviceFilter_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateDeviceFilter_ValidationError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.path_) {}

    , decltype(_impl_.message_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.path_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.path_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_path().empty()) {
    _this->_impl_.path_.Set(from._internal_path(), _this->GetArenaForAllocation());
  }
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateDeviceFilter.ValidationError)
}

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

    , decltype(_impl_.message_) {}

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

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

inline void TemplateDeviceFilter_ValidationError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.path_.Destroy();
  _impl_.message_.Destroy();
}

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

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

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

const char* TemplateDeviceFilter_ValidationError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string path = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_path();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          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* TemplateDeviceFilter_ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.TemplateDeviceFilter.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

::size_t TemplateDeviceFilter_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateDeviceFilter.ValidationError)
  ::size_t total_size = 0;

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

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

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

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

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

  if (!from._internal_path().empty()) {
    _this->_internal_set_path(from._internal_path());
  }
  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string TemplateDeviceFilter_ValidationError::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDeviceFilter.ValidationError";
}

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

class TemplateDeviceFilter::_Internal {
 public:
};

TemplateDeviceFilter::TemplateDeviceFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateDeviceFilter)
}
TemplateDeviceFilter::TemplateDeviceFilter(const TemplateDeviceFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateDeviceFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.metric_types_) { from._internal_metric_types() }
    , /*decltype(_impl_._metric_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.model_ids_) { from._impl_.model_ids_ }
    ,/* _impl_._model_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.plan_types_) { from._internal_plan_types() }
    , /*decltype(_impl_._plan_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.indicator_vendor_types_) { from._internal_indicator_vendor_types() }
    , /*decltype(_impl_._indicator_vendor_types_cached_byte_size_)*/ { 0 }

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

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

inline void TemplateDeviceFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.metric_types_) { arena }
    , /*decltype(_impl_._metric_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.model_ids_) { arena }
    ,/* _impl_._model_ids_cached_byte_size_ = */ { 0 }

    , decltype(_impl_.plan_types_) { arena }
    , /*decltype(_impl_._plan_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.indicator_vendor_types_) { arena }
    , /*decltype(_impl_._indicator_vendor_types_cached_byte_size_)*/ { 0 }

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

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

inline void TemplateDeviceFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_metric_types()->~RepeatedField();
  _impl_.model_ids_.~RepeatedField();
  _internal_mutable_plan_types()->~RepeatedField();
  _internal_mutable_indicator_vendor_types()->~RepeatedField();
}

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

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

  _internal_mutable_metric_types()->Clear();
  _internal_mutable_model_ids()->Clear();
  _internal_mutable_plan_types()->Clear();
  _internal_mutable_indicator_vendor_types()->Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* TemplateDeviceFilter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .keyapis.telemetry_control.v1.TemplateDevice.MetricType metric_types = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_metric_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_metric_types(static_cast<::keyapis::telemetry_control::v1::TemplateDevice_MetricType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 model_ids = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_model_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 16) {
          _internal_add_model_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.telemetry_control.v1.TemplateDevice.PlanType plan_types = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_plan_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 24) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_plan_types(static_cast<::keyapis::telemetry_control::v1::TemplateDevice_PlanType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_types = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_indicator_vendor_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 32) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_indicator_vendor_types(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_VendorType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // repeated .keyapis.telemetry_control.v1.TemplateDevice.MetricType metric_types = 1;
  {
    int byte_size = _impl_._metric_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(1, _internal_metric_types(),
                                       byte_size, target);
    }
  }

  // repeated int32 model_ids = 2;
  {
    int byte_size = _impl_._model_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(2, _internal_model_ids(),
                                                 byte_size, target);
    }
  }

  // repeated .keyapis.telemetry_control.v1.TemplateDevice.PlanType plan_types = 3;
  {
    int byte_size = _impl_._plan_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(3, _internal_plan_types(),
                                       byte_size, target);
    }
  }

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_types = 4;
  {
    int byte_size = _impl_._indicator_vendor_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(4, _internal_indicator_vendor_types(),
                                       byte_size, target);
    }
  }

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

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

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

  // repeated .keyapis.telemetry_control.v1.TemplateDevice.MetricType metric_types = 1;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_metric_types_size());

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

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

  // repeated .keyapis.telemetry_control.v1.TemplateDevice.PlanType plan_types = 3;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_plan_types_size());

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

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_types = 4;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_indicator_vendor_types_size());

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

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

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

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

  _this->_internal_mutable_metric_types()->MergeFrom(from._internal_metric_types());
  _this->_impl_.model_ids_.MergeFrom(from._impl_.model_ids_);
  _this->_internal_mutable_plan_types()->MergeFrom(from._internal_plan_types());
  _this->_internal_mutable_indicator_vendor_types()->MergeFrom(from._internal_indicator_vendor_types());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void TemplateDeviceFilter::InternalSwap(TemplateDeviceFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _internal_mutable_metric_types()->InternalSwap(
      other->_internal_mutable_metric_types());
  _impl_.model_ids_.InternalSwap(&other->_impl_.model_ids_);
  _internal_mutable_plan_types()->InternalSwap(
      other->_internal_mutable_plan_types());
  _internal_mutable_indicator_vendor_types()->InternalSwap(
      other->_internal_mutable_indicator_vendor_types());
}

std::string TemplateDeviceFilter::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDeviceFilter";
}

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

class GetTemplateDeviceListResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError& template_device_filter_validation(const GetTemplateDeviceListResponse_Error* msg);
  static const ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError& template_device_paging_validation(const GetTemplateDeviceListResponse_Error* msg);
};

const ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError&
GetTemplateDeviceListResponse_Error::_Internal::template_device_filter_validation(const GetTemplateDeviceListResponse_Error* msg) {
  return *msg->_impl_.reason_.template_device_filter_validation_;
}
const ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError&
GetTemplateDeviceListResponse_Error::_Internal::template_device_paging_validation(const GetTemplateDeviceListResponse_Error* msg) {
  return *msg->_impl_.reason_.template_device_paging_validation_;
}
void GetTemplateDeviceListResponse_Error::set_allocated_template_device_filter_validation(::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError* template_device_filter_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (template_device_filter_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(template_device_filter_validation);
    if (message_arena != submessage_arena) {
      template_device_filter_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, template_device_filter_validation, submessage_arena);
    }
    set_has_template_device_filter_validation();
    _impl_.reason_.template_device_filter_validation_ = template_device_filter_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.Error.template_device_filter_validation)
}
void GetTemplateDeviceListResponse_Error::set_allocated_template_device_paging_validation(::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError* template_device_paging_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (template_device_paging_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(template_device_paging_validation);
    if (message_arena != submessage_arena) {
      template_device_paging_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, template_device_paging_validation, submessage_arena);
    }
    set_has_template_device_paging_validation();
    _impl_.reason_.template_device_paging_validation_ = template_device_paging_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.Error.template_device_paging_validation)
}
GetTemplateDeviceListResponse_Error::GetTemplateDeviceListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.Error)
}
GetTemplateDeviceListResponse_Error::GetTemplateDeviceListResponse_Error(const GetTemplateDeviceListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetTemplateDeviceListResponse_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 kTemplateDeviceFilterValidation: {
      _this->_internal_mutable_template_device_filter_validation()->::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError::MergeFrom(
          from._internal_template_device_filter_validation());
      break;
    }
    case kTemplateDevicePagingValidation: {
      _this->_internal_mutable_template_device_paging_validation()->::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError::MergeFrom(
          from._internal_template_device_paging_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.Error)
}

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

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

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

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

void GetTemplateDeviceListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.Error)
  switch (reason_case()) {
    case kTemplateDeviceFilterValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.template_device_filter_validation_;
      }
      break;
    }
    case kTemplateDevicePagingValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.template_device_paging_validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetTemplateDeviceListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.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* GetTemplateDeviceListResponse_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.telemetry_control.v1.TemplateDeviceFilter.ValidationError template_device_filter_validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_template_device_filter_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError template_device_paging_validation = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_template_device_paging_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t GetTemplateDeviceListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.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.telemetry_control.v1.TemplateDeviceFilter.ValidationError template_device_filter_validation = 1;
    case kTemplateDeviceFilterValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.template_device_filter_validation_);
      break;
    }
    // .keyapis.telemetry_control.v1.TemplateDevicePaging.ValidationError template_device_paging_validation = 2;
    case kTemplateDevicePagingValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.template_device_paging_validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kTemplateDeviceFilterValidation: {
      _this->_internal_mutable_template_device_filter_validation()->::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError::MergeFrom(
          from._internal_template_device_filter_validation());
      break;
    }
    case kTemplateDevicePagingValidation: {
      _this->_internal_mutable_template_device_paging_validation()->::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError::MergeFrom(
          from._internal_template_device_paging_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetTemplateDeviceListResponse_Error::InternalSwap(GetTemplateDeviceListResponse_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 GetTemplateDeviceListResponse_Error::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetTemplateDeviceListResponse.Error";
}

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

class GetTemplateDeviceListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateDevice& data(const GetTemplateDeviceListResponse* msg);
  static const ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse_Error& error(const GetTemplateDeviceListResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class GetTemplateDeviceCountResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError& template_device_filter_validation(const GetTemplateDeviceCountResponse_Error* msg);
};

const ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError&
GetTemplateDeviceCountResponse_Error::_Internal::template_device_filter_validation(const GetTemplateDeviceCountResponse_Error* msg) {
  return *msg->_impl_.reason_.template_device_filter_validation_;
}
void GetTemplateDeviceCountResponse_Error::set_allocated_template_device_filter_validation(::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError* template_device_filter_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (template_device_filter_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(template_device_filter_validation);
    if (message_arena != submessage_arena) {
      template_device_filter_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, template_device_filter_validation, submessage_arena);
    }
    set_has_template_device_filter_validation();
    _impl_.reason_.template_device_filter_validation_ = template_device_filter_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse.Error.template_device_filter_validation)
}
GetTemplateDeviceCountResponse_Error::GetTemplateDeviceCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse.Error)
}
GetTemplateDeviceCountResponse_Error::GetTemplateDeviceCountResponse_Error(const GetTemplateDeviceCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetTemplateDeviceCountResponse_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 kTemplateDeviceFilterValidation: {
      _this->_internal_mutable_template_device_filter_validation()->::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError::MergeFrom(
          from._internal_template_device_filter_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse.Error)
}

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

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

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

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

void GetTemplateDeviceCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse.Error)
  switch (reason_case()) {
    case kTemplateDeviceFilterValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.template_device_filter_validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

  // .keyapis.telemetry_control.v1.TemplateDeviceFilter.ValidationError template_device_filter_validation = 1;
  if (reason_case() == kTemplateDeviceFilterValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::template_device_filter_validation(this),
        _Internal::template_device_filter_validation(this).GetCachedSize(), target, stream);
  }

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

::size_t GetTemplateDeviceCountResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse.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.telemetry_control.v1.TemplateDeviceFilter.ValidationError template_device_filter_validation = 1;
    case kTemplateDeviceFilterValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.template_device_filter_validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kTemplateDeviceFilterValidation: {
      _this->_internal_mutable_template_device_filter_validation()->::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError::MergeFrom(
          from._internal_template_device_filter_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetTemplateDeviceCountResponse_Error::InternalSwap(GetTemplateDeviceCountResponse_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 GetTemplateDeviceCountResponse_Error::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse.Error";
}

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

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

const ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse_Error&
GetTemplateDeviceCountResponse::_Internal::error(const GetTemplateDeviceCountResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetTemplateDeviceCountResponse::set_allocated_error(::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse_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.telemetry_control.v1.GetTemplateDeviceCountResponse.error)
}
GetTemplateDeviceCountResponse::GetTemplateDeviceCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse)
}
GetTemplateDeviceCountResponse::GetTemplateDeviceCountResponse(const GetTemplateDeviceCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetTemplateDeviceCountResponse* 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::telemetry_control::v1::GetTemplateDeviceCountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetTemplateDeviceCountResponse)
}

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

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

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

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

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

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

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

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

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

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

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

class TemplateDevice_ValidationError::_Internal {
 public:
};

TemplateDevice_ValidationError::TemplateDevice_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateDevice.ValidationError)
}
TemplateDevice_ValidationError::TemplateDevice_ValidationError(const TemplateDevice_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateDevice_ValidationError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.path_) {}

    , decltype(_impl_.message_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.path_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.path_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_path().empty()) {
    _this->_impl_.path_.Set(from._internal_path(), _this->GetArenaForAllocation());
  }
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateDevice.ValidationError)
}

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

    , decltype(_impl_.message_) {}

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

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

inline void TemplateDevice_ValidationError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.path_.Destroy();
  _impl_.message_.Destroy();
}

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

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

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

const char* TemplateDevice_ValidationError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string path = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_path();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          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* TemplateDevice_ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.TemplateDevice.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

::size_t TemplateDevice_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateDevice.ValidationError)
  ::size_t total_size = 0;

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

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

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

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

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

  if (!from._internal_path().empty()) {
    _this->_internal_set_path(from._internal_path());
  }
  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string TemplateDevice_ValidationError::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDevice.ValidationError";
}

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

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

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

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

    , decltype(_impl_.metric_type_) {}

    , decltype(_impl_.model_id_) {}

    , decltype(_impl_.plan_type_) {}

    , decltype(_impl_.indicator_vendor_type_) {}
  };

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

inline void TemplateDevice::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.indicator_template_ids_) { arena }
    ,/* _impl_._indicator_template_ids_cached_byte_size_ = */ { 0 }

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

    , decltype(_impl_.metric_type_) { 0 }

    , decltype(_impl_.model_id_) { 0 }

    , decltype(_impl_.plan_type_) { 0 }

    , decltype(_impl_.indicator_vendor_type_) { 0 }

  };
}

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

inline void TemplateDevice::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.indicator_template_ids_.~RepeatedField();
  if (this != internal_default_instance()) delete _impl_.created_at_;
  if (this != internal_default_instance()) delete _impl_.changed_at_;
}

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

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

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

const char* TemplateDevice::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
      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;
      // .keyapis.telemetry_control.v1.TemplateDevice.MetricType metric_type = 4 [(.google.api.field_behavior) = REQUIRED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_metric_type(static_cast<::keyapis::telemetry_control::v1::TemplateDevice_MetricType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 model_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.model_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated int32 indicator_template_ids = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_indicator_template_ids(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 48) {
          _internal_add_indicator_template_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateDevice.PlanType plan_type = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_plan_type(static_cast<::keyapis::telemetry_control::v1::TemplateDevice_PlanType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_type = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_indicator_vendor_type(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_VendorType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

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

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

  // .keyapis.telemetry_control.v1.TemplateDevice.MetricType metric_type = 4 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_metric_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        4, this->_internal_metric_type(), target);
  }

  // int32 model_id = 5;
  if (this->_internal_model_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        5, this->_internal_model_id(), target);
  }

  // repeated int32 indicator_template_ids = 6;
  {
    int byte_size = _impl_._indicator_template_ids_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(6, _internal_indicator_template_ids(),
                                                 byte_size, target);
    }
  }

  // .keyapis.telemetry_control.v1.TemplateDevice.PlanType plan_type = 7;
  if (this->_internal_plan_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        7, this->_internal_plan_type(), target);
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_type = 8;
  if (this->_internal_indicator_vendor_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        8, this->_internal_indicator_vendor_type(), target);
  }

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

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

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

  // repeated int32 indicator_template_ids = 6;
  {
    std::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
        this->_internal_indicator_template_ids())
    ;
    _impl_._indicator_template_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;
  }

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

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

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

  // .keyapis.telemetry_control.v1.TemplateDevice.MetricType metric_type = 4 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_metric_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_metric_type());
  }

  // int32 model_id = 5;
  if (this->_internal_model_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_model_id());
  }

  // .keyapis.telemetry_control.v1.TemplateDevice.PlanType plan_type = 7;
  if (this->_internal_plan_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_plan_type());
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_type = 8;
  if (this->_internal_indicator_vendor_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_indicator_vendor_type());
  }

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

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

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

  _this->_impl_.indicator_template_ids_.MergeFrom(from._impl_.indicator_template_ids_);
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  if (from._internal_metric_type() != 0) {
    _this->_internal_set_metric_type(from._internal_metric_type());
  }
  if (from._internal_model_id() != 0) {
    _this->_internal_set_model_id(from._internal_model_id());
  }
  if (from._internal_plan_type() != 0) {
    _this->_internal_set_plan_type(from._internal_plan_type());
  }
  if (from._internal_indicator_vendor_type() != 0) {
    _this->_internal_set_indicator_vendor_type(from._internal_indicator_vendor_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string TemplateDevice::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateDevice";
}

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

class GetTemplateIndicatorRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string GetTemplateIndicatorRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetTemplateIndicatorRequest";
}

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.telemetry_control.v1.TemplateIndicatorFilter 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.telemetry_control.v1.TemplateIndicatorPaging 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.telemetry_control.v1.GetTemplateIndicatorListRequest)
  return target;
}

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

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

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

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

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

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

class TemplateIndicatorPaging_ValidationError_LimitInvalid::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

::size_t TemplateIndicatorPaging_ValidationError_LimitInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.LimitInvalid)
  ::size_t total_size = 0;

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

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

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

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

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

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

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

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

std::string TemplateIndicatorPaging_ValidationError_LimitInvalid::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.LimitInvalid";
}

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

class TemplateIndicatorPaging_ValidationError_OffsetInvalid::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

::size_t TemplateIndicatorPaging_ValidationError_OffsetInvalid::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.OffsetInvalid)
  ::size_t total_size = 0;

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

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

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

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

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

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

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

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

std::string TemplateIndicatorPaging_ValidationError_OffsetInvalid::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.OffsetInvalid";
}

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

class TemplateIndicatorPaging_ValidationError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid& limit(const TemplateIndicatorPaging_ValidationError* msg);
  static const ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid& offset(const TemplateIndicatorPaging_ValidationError* msg);
};

const ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid&
TemplateIndicatorPaging_ValidationError::_Internal::limit(const TemplateIndicatorPaging_ValidationError* msg) {
  return *msg->_impl_.reason_.limit_;
}
const ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid&
TemplateIndicatorPaging_ValidationError::_Internal::offset(const TemplateIndicatorPaging_ValidationError* msg) {
  return *msg->_impl_.reason_.offset_;
}
void TemplateIndicatorPaging_ValidationError::set_allocated_limit(::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid* limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(limit);
    if (message_arena != submessage_arena) {
      limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, limit, submessage_arena);
    }
    set_has_limit();
    _impl_.reason_.limit_ = limit;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.limit)
}
void TemplateIndicatorPaging_ValidationError::set_allocated_offset(::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid* offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(offset);
    if (message_arena != submessage_arena) {
      offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, offset, submessage_arena);
    }
    set_has_offset();
    _impl_.reason_.offset_ = offset;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.offset)
}
TemplateIndicatorPaging_ValidationError::TemplateIndicatorPaging_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError)
}
TemplateIndicatorPaging_ValidationError::TemplateIndicatorPaging_ValidationError(const TemplateIndicatorPaging_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateIndicatorPaging_ValidationError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kLimit: {
      _this->_internal_mutable_limit()->::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid::MergeFrom(
          from._internal_limit());
      break;
    }
    case kOffset: {
      _this->_internal_mutable_offset()->::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid::MergeFrom(
          from._internal_offset());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError)
}

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

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

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

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

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


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

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

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

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

  switch (reason_case()) {
    case kLimit: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::limit(this),
          _Internal::limit(this).GetCachedSize(), target, stream);
      break;
    }
    case kOffset: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::offset(this),
          _Internal::offset(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError)
  return target;
}

::size_t TemplateIndicatorPaging_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError)
  ::size_t total_size = 0;

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

  switch (reason_case()) {
    // .keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.LimitInvalid limit = 1;
    case kLimit: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.limit_);
      break;
    }
    // .keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError.OffsetInvalid offset = 2;
    case kOffset: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.offset_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

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

std::string TemplateIndicatorPaging_ValidationError::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError";
}

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

class TemplateIndicatorPaging::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

std::string TemplateIndicatorPaging::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicatorPaging";
}

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

class TemplateIndicatorFilter_ValidationError::_Internal {
 public:
};

TemplateIndicatorFilter_ValidationError::TemplateIndicatorFilter_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateIndicatorFilter.ValidationError)
}
TemplateIndicatorFilter_ValidationError::TemplateIndicatorFilter_ValidationError(const TemplateIndicatorFilter_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateIndicatorFilter_ValidationError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.path_) {}

    , decltype(_impl_.message_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.path_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.path_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_path().empty()) {
    _this->_impl_.path_.Set(from._internal_path(), _this->GetArenaForAllocation());
  }
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateIndicatorFilter.ValidationError)
}

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

    , decltype(_impl_.message_) {}

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

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

inline void TemplateIndicatorFilter_ValidationError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.path_.Destroy();
  _impl_.message_.Destroy();
}

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

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

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

const char* TemplateIndicatorFilter_ValidationError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string path = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_path();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          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* TemplateIndicatorFilter_ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.TemplateIndicatorFilter.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

::size_t TemplateIndicatorFilter_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateIndicatorFilter.ValidationError)
  ::size_t total_size = 0;

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

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

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

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

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

  if (!from._internal_path().empty()) {
    _this->_internal_set_path(from._internal_path());
  }
  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string TemplateIndicatorFilter_ValidationError::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicatorFilter.ValidationError";
}

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

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

const ::PROTOBUF_NAMESPACE_ID::BoolValue&
TemplateIndicatorFilter::_Internal::is_individual(const TemplateIndicatorFilter* msg) {
  return *msg->_impl_.is_individual_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
TemplateIndicatorFilter::_Internal::title(const TemplateIndicatorFilter* msg) {
  return *msg->_impl_.title_;
}
void TemplateIndicatorFilter::clear_is_individual() {
  if (_impl_.is_individual_ != nullptr) _impl_.is_individual_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void TemplateIndicatorFilter::clear_title() {
  if (_impl_.title_ != nullptr) _impl_.title_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
TemplateIndicatorFilter::TemplateIndicatorFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateIndicatorFilter)
}
TemplateIndicatorFilter::TemplateIndicatorFilter(const TemplateIndicatorFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateIndicatorFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.sign_types_) { from._internal_sign_types() }
    , /*decltype(_impl_._sign_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.archive_types_) { from._internal_archive_types() }
    , /*decltype(_impl_._archive_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.indicator_vendor_types_) { from._internal_indicator_vendor_types() }
    , /*decltype(_impl_._indicator_vendor_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.is_individual_){nullptr}
    , decltype(_impl_.title_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.is_individual_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.is_individual_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.title_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.title_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateIndicatorFilter)
}

inline void TemplateIndicatorFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.sign_types_) { arena }
    , /*decltype(_impl_._sign_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.archive_types_) { arena }
    , /*decltype(_impl_._archive_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.indicator_vendor_types_) { arena }
    , /*decltype(_impl_._indicator_vendor_types_cached_byte_size_)*/ { 0 }

    , decltype(_impl_.is_individual_){nullptr}
    , decltype(_impl_.title_){nullptr}
  };
}

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

inline void TemplateIndicatorFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_sign_types()->~RepeatedField();
  _internal_mutable_archive_types()->~RepeatedField();
  _internal_mutable_indicator_vendor_types()->~RepeatedField();
  if (this != internal_default_instance()) delete _impl_.is_individual_;
  if (this != internal_default_instance()) delete _impl_.title_;
}

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

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

  _internal_mutable_sign_types()->Clear();
  _internal_mutable_archive_types()->Clear();
  _internal_mutable_indicator_vendor_types()->Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.is_individual_ != nullptr);
      _impl_.is_individual_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.title_ != nullptr);
      _impl_.title_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* TemplateIndicatorFilter::_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) {
      // repeated .keyapis.telemetry_control.v1.TemplateIndicator.SignType sign_types = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_sign_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 8) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_sign_types(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_SignType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.telemetry_control.v1.TemplateIndicator.ArchiveType archive_types = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_archive_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 16) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_archive_types(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_ArchiveType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.BoolValue is_individual = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_is_individual(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue title = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_title(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_types = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_indicator_vendor_types(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::uint8_t>(tag) == 40) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_add_indicator_vendor_types(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_VendorType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.SignType sign_types = 1;
  {
    int byte_size = _impl_._sign_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(1, _internal_sign_types(),
                                       byte_size, target);
    }
  }

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.ArchiveType archive_types = 2;
  {
    int byte_size = _impl_._archive_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(2, _internal_archive_types(),
                                       byte_size, target);
    }
  }

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

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

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_types = 5;
  {
    int byte_size = _impl_._indicator_vendor_types_cached_byte_size_.Get();
    if (byte_size > 0) {
      target = stream->WriteEnumPacked(5, _internal_indicator_vendor_types(),
                                       byte_size, target);
    }
  }

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

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

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

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.SignType sign_types = 1;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_sign_types_size());

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

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.ArchiveType archive_types = 2;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_archive_types_size());

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

  // repeated .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_types = 5;
  {
    std::size_t data_size = 0;
    auto count = static_cast<std::size_t>(this->_internal_indicator_vendor_types_size());

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

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

    // .google.protobuf.StringValue title = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.title_);
    }

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

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

  _this->_internal_mutable_sign_types()->MergeFrom(from._internal_sign_types());
  _this->_internal_mutable_archive_types()->MergeFrom(from._internal_archive_types());
  _this->_internal_mutable_indicator_vendor_types()->MergeFrom(from._internal_indicator_vendor_types());
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_is_individual()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom(
          from._internal_is_individual());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_title()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_title());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void TemplateIndicatorFilter::InternalSwap(TemplateIndicatorFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _internal_mutable_sign_types()->InternalSwap(
      other->_internal_mutable_sign_types());
  _internal_mutable_archive_types()->InternalSwap(
      other->_internal_mutable_archive_types());
  _internal_mutable_indicator_vendor_types()->InternalSwap(
      other->_internal_mutable_indicator_vendor_types());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TemplateIndicatorFilter, _impl_.title_)
      + sizeof(TemplateIndicatorFilter::_impl_.title_)
      - PROTOBUF_FIELD_OFFSET(TemplateIndicatorFilter, _impl_.is_individual_)>(
          reinterpret_cast<char*>(&_impl_.is_individual_),
          reinterpret_cast<char*>(&other->_impl_.is_individual_));
}

std::string TemplateIndicatorFilter::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicatorFilter";
}

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

class GetTemplateIndicatorListResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError& template_indicator_filter_validation(const GetTemplateIndicatorListResponse_Error* msg);
  static const ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError& template_indicator_paging_validation(const GetTemplateIndicatorListResponse_Error* msg);
};

const ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError&
GetTemplateIndicatorListResponse_Error::_Internal::template_indicator_filter_validation(const GetTemplateIndicatorListResponse_Error* msg) {
  return *msg->_impl_.reason_.template_indicator_filter_validation_;
}
const ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError&
GetTemplateIndicatorListResponse_Error::_Internal::template_indicator_paging_validation(const GetTemplateIndicatorListResponse_Error* msg) {
  return *msg->_impl_.reason_.template_indicator_paging_validation_;
}
void GetTemplateIndicatorListResponse_Error::set_allocated_template_indicator_filter_validation(::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError* template_indicator_filter_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (template_indicator_filter_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(template_indicator_filter_validation);
    if (message_arena != submessage_arena) {
      template_indicator_filter_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, template_indicator_filter_validation, submessage_arena);
    }
    set_has_template_indicator_filter_validation();
    _impl_.reason_.template_indicator_filter_validation_ = template_indicator_filter_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.Error.template_indicator_filter_validation)
}
void GetTemplateIndicatorListResponse_Error::set_allocated_template_indicator_paging_validation(::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError* template_indicator_paging_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (template_indicator_paging_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(template_indicator_paging_validation);
    if (message_arena != submessage_arena) {
      template_indicator_paging_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, template_indicator_paging_validation, submessage_arena);
    }
    set_has_template_indicator_paging_validation();
    _impl_.reason_.template_indicator_paging_validation_ = template_indicator_paging_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.Error.template_indicator_paging_validation)
}
GetTemplateIndicatorListResponse_Error::GetTemplateIndicatorListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.Error)
}
GetTemplateIndicatorListResponse_Error::GetTemplateIndicatorListResponse_Error(const GetTemplateIndicatorListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetTemplateIndicatorListResponse_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 kTemplateIndicatorFilterValidation: {
      _this->_internal_mutable_template_indicator_filter_validation()->::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError::MergeFrom(
          from._internal_template_indicator_filter_validation());
      break;
    }
    case kTemplateIndicatorPagingValidation: {
      _this->_internal_mutable_template_indicator_paging_validation()->::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError::MergeFrom(
          from._internal_template_indicator_paging_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.Error)
}

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

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

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

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

void GetTemplateIndicatorListResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.Error)
  switch (reason_case()) {
    case kTemplateIndicatorFilterValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.template_indicator_filter_validation_;
      }
      break;
    }
    case kTemplateIndicatorPagingValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.template_indicator_paging_validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetTemplateIndicatorListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.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* GetTemplateIndicatorListResponse_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.telemetry_control.v1.TemplateIndicatorFilter.ValidationError template_indicator_filter_validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_template_indicator_filter_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError template_indicator_paging_validation = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_template_indicator_paging_validation(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

::size_t GetTemplateIndicatorListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.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.telemetry_control.v1.TemplateIndicatorFilter.ValidationError template_indicator_filter_validation = 1;
    case kTemplateIndicatorFilterValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.template_indicator_filter_validation_);
      break;
    }
    // .keyapis.telemetry_control.v1.TemplateIndicatorPaging.ValidationError template_indicator_paging_validation = 2;
    case kTemplateIndicatorPagingValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.template_indicator_paging_validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kTemplateIndicatorFilterValidation: {
      _this->_internal_mutable_template_indicator_filter_validation()->::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError::MergeFrom(
          from._internal_template_indicator_filter_validation());
      break;
    }
    case kTemplateIndicatorPagingValidation: {
      _this->_internal_mutable_template_indicator_paging_validation()->::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError::MergeFrom(
          from._internal_template_indicator_paging_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetTemplateIndicatorListResponse_Error::InternalSwap(GetTemplateIndicatorListResponse_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 GetTemplateIndicatorListResponse_Error::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetTemplateIndicatorListResponse.Error";
}

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

class GetTemplateIndicatorListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateIndicator& data(const GetTemplateIndicatorListResponse* msg);
  static const ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse_Error& error(const GetTemplateIndicatorListResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class GetTemplateIndicatorCountResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError& template_indicator_filter_validation(const GetTemplateIndicatorCountResponse_Error* msg);
};

const ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError&
GetTemplateIndicatorCountResponse_Error::_Internal::template_indicator_filter_validation(const GetTemplateIndicatorCountResponse_Error* msg) {
  return *msg->_impl_.reason_.template_indicator_filter_validation_;
}
void GetTemplateIndicatorCountResponse_Error::set_allocated_template_indicator_filter_validation(::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError* template_indicator_filter_validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (template_indicator_filter_validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(template_indicator_filter_validation);
    if (message_arena != submessage_arena) {
      template_indicator_filter_validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, template_indicator_filter_validation, submessage_arena);
    }
    set_has_template_indicator_filter_validation();
    _impl_.reason_.template_indicator_filter_validation_ = template_indicator_filter_validation;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse.Error.template_indicator_filter_validation)
}
GetTemplateIndicatorCountResponse_Error::GetTemplateIndicatorCountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse.Error)
}
GetTemplateIndicatorCountResponse_Error::GetTemplateIndicatorCountResponse_Error(const GetTemplateIndicatorCountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetTemplateIndicatorCountResponse_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 kTemplateIndicatorFilterValidation: {
      _this->_internal_mutable_template_indicator_filter_validation()->::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError::MergeFrom(
          from._internal_template_indicator_filter_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse.Error)
}

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

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

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

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

void GetTemplateIndicatorCountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse.Error)
  switch (reason_case()) {
    case kTemplateIndicatorFilterValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.template_indicator_filter_validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

  // .keyapis.telemetry_control.v1.TemplateIndicatorFilter.ValidationError template_indicator_filter_validation = 1;
  if (reason_case() == kTemplateIndicatorFilterValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::template_indicator_filter_validation(this),
        _Internal::template_indicator_filter_validation(this).GetCachedSize(), target, stream);
  }

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

::size_t GetTemplateIndicatorCountResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse.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.telemetry_control.v1.TemplateIndicatorFilter.ValidationError template_indicator_filter_validation = 1;
    case kTemplateIndicatorFilterValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.template_indicator_filter_validation_);
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

  switch (from.reason_case()) {
    case kTemplateIndicatorFilterValidation: {
      _this->_internal_mutable_template_indicator_filter_validation()->::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError::MergeFrom(
          from._internal_template_indicator_filter_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetTemplateIndicatorCountResponse_Error::InternalSwap(GetTemplateIndicatorCountResponse_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 GetTemplateIndicatorCountResponse_Error::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse.Error";
}

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

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

const ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse_Error&
GetTemplateIndicatorCountResponse::_Internal::error(const GetTemplateIndicatorCountResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void GetTemplateIndicatorCountResponse::set_allocated_error(::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse_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.telemetry_control.v1.GetTemplateIndicatorCountResponse.error)
}
GetTemplateIndicatorCountResponse::GetTemplateIndicatorCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse)
}
GetTemplateIndicatorCountResponse::GetTemplateIndicatorCountResponse(const GetTemplateIndicatorCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetTemplateIndicatorCountResponse* 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::telemetry_control::v1::GetTemplateIndicatorCountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetTemplateIndicatorCountResponse)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::keyapis::telemetry_control::v1::TemplateIndicator_ValidationError&
PostTemplateIndicatorResponse_Error::_Internal::validation(const PostTemplateIndicatorResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void PostTemplateIndicatorResponse_Error::set_allocated_validation(::keyapis::telemetry_control::v1::TemplateIndicator_ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(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.telemetry_control.v1.PostTemplateIndicatorResponse.Error.validation)
}
PostTemplateIndicatorResponse_Error::PostTemplateIndicatorResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.PostTemplateIndicatorResponse.Error)
}
PostTemplateIndicatorResponse_Error::PostTemplateIndicatorResponse_Error(const PostTemplateIndicatorResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostTemplateIndicatorResponse_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::telemetry_control::v1::TemplateIndicator_ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.PostTemplateIndicatorResponse.Error)
}

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

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

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

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

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

  // .keyapis.telemetry_control.v1.TemplateIndicator.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.telemetry_control.v1.PostTemplateIndicatorResponse.Error)
  return target;
}

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

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

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

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

void PostTemplateIndicatorResponse_Error::InternalSwap(PostTemplateIndicatorResponse_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 PostTemplateIndicatorResponse_Error::GetTypeName() const {
  return "keyapis.telemetry_control.v1.PostTemplateIndicatorResponse.Error";
}

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

class PostTemplateIndicatorResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::TemplateIndicator& data(const PostTemplateIndicatorResponse* msg);
  static const ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse_Error& error(const PostTemplateIndicatorResponse* msg);
};

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

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

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

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

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

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

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

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

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

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

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

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

class DeleteTemplateIndicatorRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string DeleteTemplateIndicatorRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DeleteTemplateIndicatorRequest";
}

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

class DeleteTemplateIndicatorResponse::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

std::string DeleteTemplateIndicatorResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DeleteTemplateIndicatorResponse";
}

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

class TemplateIndicator_ValidationError::_Internal {
 public:
};

TemplateIndicator_ValidationError::TemplateIndicator_ValidationError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateIndicator.ValidationError)
}
TemplateIndicator_ValidationError::TemplateIndicator_ValidationError(const TemplateIndicator_ValidationError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateIndicator_ValidationError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.path_) {}

    , decltype(_impl_.message_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.path_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.path_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_path().empty()) {
    _this->_impl_.path_.Set(from._internal_path(), _this->GetArenaForAllocation());
  }
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateIndicator.ValidationError)
}

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

    , decltype(_impl_.message_) {}

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

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

inline void TemplateIndicator_ValidationError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.path_.Destroy();
  _impl_.message_.Destroy();
}

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

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

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

const char* TemplateIndicator_ValidationError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string path = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_path();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          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* TemplateIndicator_ValidationError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.TemplateIndicator.ValidationError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

::size_t TemplateIndicator_ValidationError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.TemplateIndicator.ValidationError)
  ::size_t total_size = 0;

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

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

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

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

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

  if (!from._internal_path().empty()) {
    _this->_internal_set_path(from._internal_path());
  }
  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string TemplateIndicator_ValidationError::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicator.ValidationError";
}

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

class TemplateIndicator::_Internal {
 public:
  using HasBits = decltype(std::declval<TemplateIndicator>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(TemplateIndicator, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at(const TemplateIndicator* msg);
  static void set_has_created_at(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at(const TemplateIndicator* msg);
  static void set_has_changed_at(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& compatibility_code(const TemplateIndicator* msg);
  static void set_has_compatibility_code(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::FloatValue& coefficient(const TemplateIndicator* msg);
  static void set_has_coefficient(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::FloatValue& shift(const TemplateIndicator* msg);
  static void set_has_shift(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Int32Value& round_decimal_digits(const TemplateIndicator* msg);
  static void set_has_round_decimal_digits(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
TemplateIndicator::_Internal::created_at(const TemplateIndicator* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
TemplateIndicator::_Internal::changed_at(const TemplateIndicator* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
TemplateIndicator::_Internal::compatibility_code(const TemplateIndicator* msg) {
  return *msg->_impl_.compatibility_code_;
}
const ::PROTOBUF_NAMESPACE_ID::FloatValue&
TemplateIndicator::_Internal::coefficient(const TemplateIndicator* msg) {
  return *msg->_impl_.coefficient_;
}
const ::PROTOBUF_NAMESPACE_ID::FloatValue&
TemplateIndicator::_Internal::shift(const TemplateIndicator* msg) {
  return *msg->_impl_.shift_;
}
const ::PROTOBUF_NAMESPACE_ID::Int32Value&
TemplateIndicator::_Internal::round_decimal_digits(const TemplateIndicator* msg) {
  return *msg->_impl_.round_decimal_digits_;
}
void TemplateIndicator::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void TemplateIndicator::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void TemplateIndicator::clear_compatibility_code() {
  if (_impl_.compatibility_code_ != nullptr) _impl_.compatibility_code_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void TemplateIndicator::clear_coefficient() {
  if (_impl_.coefficient_ != nullptr) _impl_.coefficient_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
void TemplateIndicator::clear_shift() {
  if (_impl_.shift_ != nullptr) _impl_.shift_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
void TemplateIndicator::clear_round_decimal_digits() {
  if (_impl_.round_decimal_digits_ != nullptr) _impl_.round_decimal_digits_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
TemplateIndicator::TemplateIndicator(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.TemplateIndicator)
}
TemplateIndicator::TemplateIndicator(const TemplateIndicator& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  TemplateIndicator* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.title_) {}

    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.compatibility_code_){nullptr}
    , decltype(_impl_.coefficient_){nullptr}
    , decltype(_impl_.shift_){nullptr}
    , decltype(_impl_.round_decimal_digits_){nullptr}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.unit_type_) {}

    , decltype(_impl_.sign_type_) {}

    , decltype(_impl_.archive_type_) {}

    , decltype(_impl_.presentation_unit_type_) {}

    , decltype(_impl_.is_individual_) {}

    , decltype(_impl_.metric_expected_freq_) {}

    , decltype(_impl_.indicator_vendor_type_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_title().empty()) {
    _this->_impl_.title_.Set(from._internal_title(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.compatibility_code_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.compatibility_code_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.coefficient_ = new ::PROTOBUF_NAMESPACE_ID::FloatValue(*from._impl_.coefficient_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
    _this->_impl_.shift_ = new ::PROTOBUF_NAMESPACE_ID::FloatValue(*from._impl_.shift_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) {
    _this->_impl_.round_decimal_digits_ = new ::PROTOBUF_NAMESPACE_ID::Int32Value(*from._impl_.round_decimal_digits_);
  }
  ::memcpy(&_impl_.id_, &from._impl_.id_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.indicator_vendor_type_) -
    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.indicator_vendor_type_));
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.TemplateIndicator)
}

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

    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.compatibility_code_){nullptr}
    , decltype(_impl_.coefficient_){nullptr}
    , decltype(_impl_.shift_){nullptr}
    , decltype(_impl_.round_decimal_digits_){nullptr}
    , decltype(_impl_.id_) { 0 }

    , decltype(_impl_.unit_type_) { 0 }

    , decltype(_impl_.sign_type_) { 0 }

    , decltype(_impl_.archive_type_) { 0 }

    , decltype(_impl_.presentation_unit_type_) { 0 }

    , decltype(_impl_.is_individual_) { false }

    , decltype(_impl_.metric_expected_freq_) { 0 }

    , decltype(_impl_.indicator_vendor_type_) { 0 }

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

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

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

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

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

  _impl_.title_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.compatibility_code_ != nullptr);
      _impl_.compatibility_code_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.coefficient_ != nullptr);
      _impl_.coefficient_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      ABSL_DCHECK(_impl_.shift_ != nullptr);
      _impl_.shift_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      ABSL_DCHECK(_impl_.round_decimal_digits_ != nullptr);
      _impl_.round_decimal_digits_->Clear();
    }
  }
  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.indicator_vendor_type_) -
      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.indicator_vendor_type_));
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* TemplateIndicator::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
      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;
      // string title = 4 [(.google.api.field_behavior) = REQUIRED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_title();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicator.UnitType unit_type = 5 [(.google.api.field_behavior) = REQUIRED];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_unit_type(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_UnitType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicator.SignType sign_type = 6 [(.google.api.field_behavior) = REQUIRED];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_sign_type(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_SignType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicator.ArchiveType archive_type = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_archive_type(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_ArchiveType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicator.UnitType presentation_unit_type = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_presentation_unit_type(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_UnitType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue compatibility_code = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_compatibility_code(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // bool is_individual = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
          _impl_.is_individual_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.FloatValue coefficient = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_coefficient(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.FloatValue shift = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 98)) {
          ptr = ctx->ParseMessage(_internal_mutable_shift(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Int32Value round_decimal_digits = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 106)) {
          ptr = ctx->ParseMessage(_internal_mutable_round_decimal_digits(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 metric_expected_freq = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
          _impl_.metric_expected_freq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_type = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_indicator_vendor_type(static_cast<::keyapis::telemetry_control::v1::TemplateIndicator_VendorType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

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

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

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

  // .keyapis.telemetry_control.v1.TemplateIndicator.UnitType unit_type = 5 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_unit_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        5, this->_internal_unit_type(), target);
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.SignType sign_type = 6 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_sign_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        6, this->_internal_sign_type(), target);
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.ArchiveType archive_type = 7;
  if (this->_internal_archive_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        7, this->_internal_archive_type(), target);
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.UnitType presentation_unit_type = 8;
  if (this->_internal_presentation_unit_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        8, this->_internal_presentation_unit_type(), target);
  }

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

  // bool is_individual = 10;
  if (this->_internal_is_individual() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        10, this->_internal_is_individual(), target);
  }

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

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

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

  // int32 metric_expected_freq = 14;
  if (this->_internal_metric_expected_freq() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        14, this->_internal_metric_expected_freq(), target);
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_type = 15;
  if (this->_internal_indicator_vendor_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        15, this->_internal_indicator_vendor_type(), target);
  }

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

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

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

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

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

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

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

    // .google.protobuf.FloatValue coefficient = 11;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.coefficient_);
    }

    // .google.protobuf.FloatValue shift = 12;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.shift_);
    }

    // .google.protobuf.Int32Value round_decimal_digits = 13;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.round_decimal_digits_);
    }

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

  // .keyapis.telemetry_control.v1.TemplateIndicator.UnitType unit_type = 5 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_unit_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_unit_type());
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.SignType sign_type = 6 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_sign_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_sign_type());
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.ArchiveType archive_type = 7;
  if (this->_internal_archive_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_archive_type());
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.UnitType presentation_unit_type = 8;
  if (this->_internal_presentation_unit_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_presentation_unit_type());
  }

  // bool is_individual = 10;
  if (this->_internal_is_individual() != 0) {
    total_size += 2;
  }

  // int32 metric_expected_freq = 14;
  if (this->_internal_metric_expected_freq() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_metric_expected_freq());
  }

  // .keyapis.telemetry_control.v1.TemplateIndicator.VendorType indicator_vendor_type = 15;
  if (this->_internal_indicator_vendor_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_indicator_vendor_type());
  }

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

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

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

  if (!from._internal_title().empty()) {
    _this->_internal_set_title(from._internal_title());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_compatibility_code()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_compatibility_code());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_coefficient()->::PROTOBUF_NAMESPACE_ID::FloatValue::MergeFrom(
          from._internal_coefficient());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_internal_mutable_shift()->::PROTOBUF_NAMESPACE_ID::FloatValue::MergeFrom(
          from._internal_shift());
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_internal_mutable_round_decimal_digits()->::PROTOBUF_NAMESPACE_ID::Int32Value::MergeFrom(
          from._internal_round_decimal_digits());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  if (from._internal_unit_type() != 0) {
    _this->_internal_set_unit_type(from._internal_unit_type());
  }
  if (from._internal_sign_type() != 0) {
    _this->_internal_set_sign_type(from._internal_sign_type());
  }
  if (from._internal_archive_type() != 0) {
    _this->_internal_set_archive_type(from._internal_archive_type());
  }
  if (from._internal_presentation_unit_type() != 0) {
    _this->_internal_set_presentation_unit_type(from._internal_presentation_unit_type());
  }
  if (from._internal_is_individual() != 0) {
    _this->_internal_set_is_individual(from._internal_is_individual());
  }
  if (from._internal_metric_expected_freq() != 0) {
    _this->_internal_set_metric_expected_freq(from._internal_metric_expected_freq());
  }
  if (from._internal_indicator_vendor_type() != 0) {
    _this->_internal_set_indicator_vendor_type(from._internal_indicator_vendor_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string TemplateIndicator::GetTypeName() const {
  return "keyapis.telemetry_control.v1.TemplateIndicator";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace telemetry_control
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostTemplateDeviceRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostTemplateDeviceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostTemplateDeviceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostTemplateDeviceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DeleteTemplateDeviceRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeleteTemplateDeviceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DeleteTemplateDeviceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DeleteTemplateDeviceResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeleteTemplateDeviceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DeleteTemplateDeviceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceListRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_LimitInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError_OffsetInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDevicePaging_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDevicePaging*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDevicePaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDevicePaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDeviceFilter_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDeviceFilter*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDeviceFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDeviceFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceCountRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateDeviceCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDevice_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDevice_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDevice_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateDevice*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateDevice >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateDevice >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorListRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_LimitInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError_OffsetInvalid >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicatorPaging*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicatorPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicatorFilter_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicatorFilter*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicatorFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicatorFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetTemplateIndicatorCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostTemplateIndicatorRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostTemplateIndicatorRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostTemplateIndicatorRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostTemplateIndicatorResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DeleteTemplateIndicatorRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeleteTemplateIndicatorRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DeleteTemplateIndicatorRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DeleteTemplateIndicatorResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeleteTemplateIndicatorResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DeleteTemplateIndicatorResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicator_ValidationError*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicator_ValidationError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicator_ValidationError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::TemplateIndicator*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::TemplateIndicator >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::TemplateIndicator >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"