// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: components/segmentation_platform/public/proto/model_metadata.proto
// Protobuf C++ Version: 7.35.1

#include "components/segmentation_platform/public/proto/model_metadata.pb.h"

#include <algorithm>
#include <type_traits>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/generated_message_tctable_impl.h"
#include "google/protobuf/internal_visibility.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/generated_message_util.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 = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
namespace segmentation_platform {
namespace proto {
class VersionInfo::_Internal {
 public:
  using HasBits = decltype(::std::declval<VersionInfo>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_._has_bits_);
};

constexpr VersionInfo::ParseTableT_ VersionInfo::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::VersionInfo>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional int32 metadata_cur_version = 2;
      {::_pbi::TcParser::FastV32S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_.metadata_cur_version_)}},
      // optional int32 metadata_min_version = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_.metadata_min_version_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 metadata_min_version = 1;
      {PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_.metadata_min_version_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional int32 metadata_cur_version = 2;
      {PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_.metadata_cur_version_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr VersionInfo::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        metadata_min_version_{0},
        metadata_cur_version_{0} {}

template <typename>
constexpr VersionInfo::VersionInfo(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL VersionInfo::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) VersionInfo(arena);
}
constexpr auto VersionInfo::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(VersionInfo), alignof(VersionInfo));
}
constexpr auto VersionInfo::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &VersionInfo::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<VersionInfo>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &VersionInfo::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<VersionInfo>(), &VersionInfo::ByteSizeLong,
              &VersionInfo::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.VersionInfo",
  };
}
struct VersionInfoGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr VersionInfoGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 VersionInfo_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(VersionInfo::InternalGenerateClassData_(
            _default, &VersionInfo_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<VersionInfo>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~VersionInfoGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) VersionInfo _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<VersionInfo>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(VersionInfoGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST VersionInfoGlobalsTypeInternal VersionInfo_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* VersionInfo_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return VersionInfo_globals_.GetClassData();
#else
  return VersionInfo_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class UMAFeature::_Internal {
 public:
  using HasBits = decltype(::std::declval<UMAFeature>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_._has_bits_);
};

constexpr UMAFeature::ParseTableT_ UMAFeature::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_._has_bits_),
      0, // no _extensions_
      8, 56,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967040,  // skipmap
      offsetof(ParseTableT_, field_entries),
      8,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAFeature>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated float default_values = 8;
      {::_pbi::TcParser::FastF32R1,
       {69, 1, 0,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.default_values_)}},
      // optional .segmentation_platform.proto.SignalType type = 1;
      {::_pbi::TcParser::FastEr0S1,
       {8, 4, 4,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.type_)}},
      // optional string name = 2;
      {::_pbi::TcParser::FastBS1,
       {18, 2, 0,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.name_)}},
      // optional fixed64 name_hash = 3;
      {::_pbi::TcParser::FastF64S1,
       {25, 3, 0,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.name_hash_)}},
      // optional uint64 bucket_count = 4;
      {::_pbi::TcParser::FastV64S1,
       {32, 6, 0,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.bucket_count_)}},
      // optional uint64 tensor_length = 5;
      {::_pbi::TcParser::FastV64S1,
       {40, 7, 0,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.tensor_length_)}},
      // optional .segmentation_platform.proto.Aggregation aggregation = 6;
      {::_pbi::TcParser::FastEr0S1,
       {48, 5, 13,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.aggregation_)}},
      // repeated int32 enum_ids = 7;
      {::_pbi::TcParser::FastV32R1,
       {56, 0, 0,
        PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.enum_ids_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .segmentation_platform.proto.SignalType type = 1;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.type_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // optional string name = 2;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.name_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // optional fixed64 name_hash = 3;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.name_hash_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kFixed64)},
      // optional uint64 bucket_count = 4;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.bucket_count_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)},
      // optional uint64 tensor_length = 5;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.tensor_length_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)},
      // optional .segmentation_platform.proto.Aggregation aggregation = 6;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.aggregation_), _Internal::kHasBitsOffset + 5, 1, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // repeated int32 enum_ids = 7;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.enum_ids_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kInt32)},
      // repeated float default_values = 8;
      {PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.default_values_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kFloat)},
    }},
    {{
        {0, 4},
        {0, 13},
    }},
    {{
    }},
  };
}


inline constexpr UMAFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        enum_ids_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::UMAFeature,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::UMAFeature, _impl_.enum_ids_)>()
         }
        ,
        default_values_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::UMAFeature,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::UMAFeature, _impl_.default_values_)>()
         }
        ,
        name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        name_hash_{::uint64_t{0u}},
        type_{static_cast< ::segmentation_platform::proto::SignalType >(0)},
        aggregation_{static_cast< ::segmentation_platform::proto::Aggregation >(0)},
        bucket_count_{::uint64_t{0u}},
        tensor_length_{::uint64_t{0u}} {}

template <typename>
constexpr UMAFeature::UMAFeature(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL UMAFeature::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) UMAFeature(arena);
}
constexpr auto UMAFeature::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(UMAFeature), alignof(UMAFeature));
}
constexpr auto UMAFeature::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &UMAFeature::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<UMAFeature>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &UMAFeature::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<UMAFeature>(), &UMAFeature::ByteSizeLong,
              &UMAFeature::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.UMAFeature",
  };
}
struct UMAFeatureGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr UMAFeatureGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 UMAFeature_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(UMAFeature::InternalGenerateClassData_(
            _default, &UMAFeature_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<UMAFeature>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~UMAFeatureGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) UMAFeature _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<UMAFeature>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(UMAFeatureGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST UMAFeatureGlobalsTypeInternal UMAFeature_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* UMAFeature_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return UMAFeature_globals_.GetClassData();
#else
  return UMAFeature_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SignalFilterConfig_UkmEvent::_Internal {
 public:
  using HasBits = decltype(::std::declval<SignalFilterConfig_UkmEvent>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_._has_bits_);
};

constexpr SignalFilterConfig_UkmEvent::ParseTableT_ SignalFilterConfig_UkmEvent::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SignalFilterConfig_UkmEvent>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated uint64 metric_hash_filter = 2;
      {::_pbi::TcParser::FastV64R1,
       {16, 0, 0,
        PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_.metric_hash_filter_)}},
      // optional uint64 event_hash = 1;
      {::_pbi::TcParser::FastV64S1,
       {8, 1, 0,
        PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_.event_hash_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional uint64 event_hash = 1;
      {PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_.event_hash_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)},
      // repeated uint64 metric_hash_filter = 2;
      {PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_.metric_hash_filter_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUInt64)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr SignalFilterConfig_UkmEvent::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        metric_hash_filter_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SignalFilterConfig_UkmEvent,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SignalFilterConfig_UkmEvent, _impl_.metric_hash_filter_)>()
         }
        ,
        event_hash_{::uint64_t{0u}} {}

template <typename>
constexpr SignalFilterConfig_UkmEvent::SignalFilterConfig_UkmEvent(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SignalFilterConfig_UkmEvent::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SignalFilterConfig_UkmEvent(arena);
}
constexpr auto SignalFilterConfig_UkmEvent::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SignalFilterConfig_UkmEvent), alignof(SignalFilterConfig_UkmEvent));
}
constexpr auto SignalFilterConfig_UkmEvent::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SignalFilterConfig_UkmEvent::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SignalFilterConfig_UkmEvent>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SignalFilterConfig_UkmEvent::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SignalFilterConfig_UkmEvent>(), &SignalFilterConfig_UkmEvent::ByteSizeLong,
              &SignalFilterConfig_UkmEvent::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEvent, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SignalFilterConfig.UkmEvent",
  };
}
struct SignalFilterConfig_UkmEventGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SignalFilterConfig_UkmEventGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SignalFilterConfig_UkmEvent_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SignalFilterConfig_UkmEvent::InternalGenerateClassData_(
            _default, &SignalFilterConfig_UkmEvent_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SignalFilterConfig_UkmEvent>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SignalFilterConfig_UkmEventGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SignalFilterConfig_UkmEvent _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SignalFilterConfig_UkmEvent>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SignalFilterConfig_UkmEventGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SignalFilterConfig_UkmEventGlobalsTypeInternal SignalFilterConfig_UkmEvent_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SignalFilterConfig_UkmEvent_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SignalFilterConfig_UkmEvent_globals_.GetClassData();
#else
  return SignalFilterConfig_UkmEvent_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SegmentationModelMetadata_DiscreteMapping_Entry::_Internal {
 public:
  using HasBits = decltype(::std::declval<SegmentationModelMetadata_DiscreteMapping_Entry>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_._has_bits_);
};

constexpr SegmentationModelMetadata_DiscreteMapping_Entry::ParseTableT_ SegmentationModelMetadata_DiscreteMapping_Entry::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      0,  // num_aux_entries
      offsetof(ParseTableT_, field_names),  // no aux_entries
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping_Entry>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional int64 rank = 2;
      {::_pbi::TcParser::FastV64S1,
       {16, 0, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_.rank_)}},
      // optional float min_result = 1;
      {::_pbi::TcParser::FastF32S1,
       {13, 1, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_.min_result_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional float min_result = 1;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_.min_result_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)},
      // optional int64 rank = 2;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_.rank_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    }},
    // no aux_entries
    {{
    }},
  };
}


inline constexpr SegmentationModelMetadata_DiscreteMapping_Entry::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        rank_{::int64_t{0}},
        min_result_{0} {}

template <typename>
constexpr SegmentationModelMetadata_DiscreteMapping_Entry::SegmentationModelMetadata_DiscreteMapping_Entry(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SegmentationModelMetadata_DiscreteMapping_Entry::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SegmentationModelMetadata_DiscreteMapping_Entry(arena);
}
constexpr auto SegmentationModelMetadata_DiscreteMapping_Entry::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SegmentationModelMetadata_DiscreteMapping_Entry), alignof(SegmentationModelMetadata_DiscreteMapping_Entry));
}
constexpr auto SegmentationModelMetadata_DiscreteMapping_Entry::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SegmentationModelMetadata_DiscreteMapping_Entry::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SegmentationModelMetadata_DiscreteMapping_Entry>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SegmentationModelMetadata_DiscreteMapping_Entry::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SegmentationModelMetadata_DiscreteMapping_Entry>(), &SegmentationModelMetadata_DiscreteMapping_Entry::ByteSizeLong,
              &SegmentationModelMetadata_DiscreteMapping_Entry::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry",
  };
}
struct SegmentationModelMetadata_DiscreteMapping_EntryGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SegmentationModelMetadata_DiscreteMapping_EntryGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SegmentationModelMetadata_DiscreteMapping_Entry_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SegmentationModelMetadata_DiscreteMapping_Entry::InternalGenerateClassData_(
            _default, &SegmentationModelMetadata_DiscreteMapping_Entry_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SegmentationModelMetadata_DiscreteMapping_Entry>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SegmentationModelMetadata_DiscreteMapping_EntryGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SegmentationModelMetadata_DiscreteMapping_Entry _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SegmentationModelMetadata_DiscreteMapping_Entry>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_EntryGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SegmentationModelMetadata_DiscreteMapping_EntryGlobalsTypeInternal SegmentationModelMetadata_DiscreteMapping_Entry_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SegmentationModelMetadata_DiscreteMapping_Entry_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SegmentationModelMetadata_DiscreteMapping_Entry_globals_.GetClassData();
#else
  return SegmentationModelMetadata_DiscreteMapping_Entry_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class UMAOutput::_Internal {
 public:
  using HasBits = decltype(::std::declval<UMAOutput>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_._has_bits_);
};

constexpr UMAOutput::ParseTableT_ UMAOutput::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAOutput>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional uint64 duration = 2;
      {::_pbi::TcParser::FastV64S1,
       {16, 1, 0,
        PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_.duration_)}},
      // optional .segmentation_platform.proto.UMAFeature uma_feature = 1;
      {::_pbi::TcParser::FastMtS1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_.uma_feature_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .segmentation_platform.proto.UMAFeature uma_feature = 1;
      {PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_.uma_feature_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional uint64 duration = 2;
      {PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_.duration_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAFeature>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::UMAFeature_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr UMAOutput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        uma_feature_{nullptr},
        duration_{::uint64_t{0u}} {}

template <typename>
constexpr UMAOutput::UMAOutput(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL UMAOutput::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) UMAOutput(arena);
}
constexpr auto UMAOutput::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UMAOutput), alignof(UMAOutput));
}
constexpr auto UMAOutput::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &UMAOutput::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<UMAOutput>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &UMAOutput::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<UMAOutput>(), &UMAOutput::ByteSizeLong,
              &UMAOutput::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.UMAOutput",
  };
}
struct UMAOutputGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr UMAOutputGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 UMAOutput_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(UMAOutput::InternalGenerateClassData_(
            _default, &UMAOutput_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<UMAOutput>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~UMAOutputGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) UMAOutput _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<UMAOutput>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(UMAOutputGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST UMAOutputGlobalsTypeInternal UMAOutput_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* UMAOutput_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return UMAOutput_globals_.GetClassData();
#else
  return UMAOutput_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SignalFilterConfig::_Internal {
 public:
  using HasBits = decltype(::std::declval<SignalFilterConfig>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SignalFilterConfig, _impl_._has_bits_);
};

constexpr SignalFilterConfig::ParseTableT_ SignalFilterConfig::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SignalFilterConfig, _impl_._has_bits_),
      0, // no _extensions_
      1, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967294,  // skipmap
      offsetof(ParseTableT_, field_entries),
      1,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SignalFilterConfig>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated .segmentation_platform.proto.SignalFilterConfig.UkmEvent ukm_events = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(SignalFilterConfig, _impl_.ukm_events_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .segmentation_platform.proto.SignalFilterConfig.UkmEvent ukm_events = 1;
      {PROTOBUF_FIELD_OFFSET(SignalFilterConfig, _impl_.ukm_events_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::SignalFilterConfig_UkmEvent>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::SignalFilterConfig_UkmEvent_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr SignalFilterConfig::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        ukm_events_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SignalFilterConfig,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SignalFilterConfig, _impl_.ukm_events_)>()
         }
     {}

template <typename>
constexpr SignalFilterConfig::SignalFilterConfig(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SignalFilterConfig::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SignalFilterConfig(arena);
}
constexpr auto SignalFilterConfig::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SignalFilterConfig), alignof(SignalFilterConfig));
}
constexpr auto SignalFilterConfig::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SignalFilterConfig::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SignalFilterConfig>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SignalFilterConfig::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SignalFilterConfig>(), &SignalFilterConfig::ByteSizeLong,
              &SignalFilterConfig::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SignalFilterConfig, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SignalFilterConfig",
  };
}
struct SignalFilterConfigGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SignalFilterConfigGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SignalFilterConfig_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SignalFilterConfig::InternalGenerateClassData_(
            _default, &SignalFilterConfig_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SignalFilterConfig>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SignalFilterConfigGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SignalFilterConfig _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SignalFilterConfig>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SignalFilterConfigGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SignalFilterConfigGlobalsTypeInternal SignalFilterConfig_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SignalFilterConfig_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SignalFilterConfig_globals_.GetClassData();
#else
  return SignalFilterConfig_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SegmentationModelMetadata_DiscreteMapping::_Internal {
 public:
  using HasBits = decltype(::std::declval<SegmentationModelMetadata_DiscreteMapping>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping, _impl_._has_bits_);
};

constexpr SegmentationModelMetadata_DiscreteMapping::ParseTableT_ SegmentationModelMetadata_DiscreteMapping::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping, _impl_._has_bits_),
      0, // no _extensions_
      1, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967294,  // skipmap
      offsetof(ParseTableT_, field_entries),
      1,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // repeated .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry entries = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping, _impl_.entries_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry entries = 1;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping, _impl_.entries_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping_Entry>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping_Entry_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr SegmentationModelMetadata_DiscreteMapping::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        entries_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping, _impl_.entries_)>()
         }
     {}

template <typename>
constexpr SegmentationModelMetadata_DiscreteMapping::SegmentationModelMetadata_DiscreteMapping(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SegmentationModelMetadata_DiscreteMapping::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SegmentationModelMetadata_DiscreteMapping(arena);
}
constexpr auto SegmentationModelMetadata_DiscreteMapping::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SegmentationModelMetadata_DiscreteMapping), alignof(SegmentationModelMetadata_DiscreteMapping));
}
constexpr auto SegmentationModelMetadata_DiscreteMapping::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SegmentationModelMetadata_DiscreteMapping::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SegmentationModelMetadata_DiscreteMapping>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SegmentationModelMetadata_DiscreteMapping::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SegmentationModelMetadata_DiscreteMapping>(), &SegmentationModelMetadata_DiscreteMapping::ByteSizeLong,
              &SegmentationModelMetadata_DiscreteMapping::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping",
  };
}
struct SegmentationModelMetadata_DiscreteMappingGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SegmentationModelMetadata_DiscreteMappingGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SegmentationModelMetadata_DiscreteMapping_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SegmentationModelMetadata_DiscreteMapping::InternalGenerateClassData_(
            _default, &SegmentationModelMetadata_DiscreteMapping_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SegmentationModelMetadata_DiscreteMapping>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SegmentationModelMetadata_DiscreteMappingGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SegmentationModelMetadata_DiscreteMapping _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SegmentationModelMetadata_DiscreteMapping>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMappingGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SegmentationModelMetadata_DiscreteMappingGlobalsTypeInternal SegmentationModelMetadata_DiscreteMapping_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SegmentationModelMetadata_DiscreteMapping_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SegmentationModelMetadata_DiscreteMapping_globals_.GetClassData();
#else
  return SegmentationModelMetadata_DiscreteMapping_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class CustomInput::_Internal {
 public:
  using HasBits = decltype(::std::declval<CustomInput>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(CustomInput, _impl_._has_bits_);
};

constexpr CustomInput::ParseTableT_ CustomInput::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(CustomInput, _impl_._has_bits_),
      0, // no _extensions_
      5, 56,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967264,  // skipmap
      offsetof(ParseTableT_, field_entries),
      5,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::CustomInput>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // optional int32 tensor_length = 1;
      {::_pbi::TcParser::FastV32S1,
       {8, 2, 0,
        PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.tensor_length_)}},
      // optional .segmentation_platform.proto.CustomInput.FillPolicy fill_policy = 2;
      {::_pbi::TcParser::FastEr0S1,
       {16, 3, 12,
        PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.fill_policy_)}},
      // repeated float default_value = 3;
      {::_pbi::TcParser::FastF32R1,
       {29, 0, 0,
        PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.default_value_)}},
      {::_pbi::TcParser::MiniParse, {}},
      // optional string name = 5;
      {::_pbi::TcParser::FastBS1,
       {42, 1, 0,
        PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.name_)}},
      {::_pbi::TcParser::MiniParse, {}},
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // optional int32 tensor_length = 1;
      {PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.tensor_length_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
      // optional .segmentation_platform.proto.CustomInput.FillPolicy fill_policy = 2;
      {PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.fill_policy_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // repeated float default_value = 3;
      {PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.default_value_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kFloat)},
      // map<string, string> additional_args = 4;
      {PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.additional_args_), _Internal::kHasBitsOffset + 4, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMap)},
      // optional string name = 5;
      {PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.name_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    }},
    {{
        {0, 12},
        {::_pbi::TcParser::GetMapAuxInfo(
            0, 0, 9, 9, 1)},
    }},
    {{
    }},
  };
}


inline constexpr CustomInput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        default_value_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::CustomInput,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::CustomInput, _impl_.default_value_)>()
         }
        ,
        name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        tensor_length_{0},
        fill_policy_{static_cast< ::segmentation_platform::proto::CustomInput_FillPolicy >(0)},
        additional_args_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::CustomInput,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::CustomInput, _impl_.additional_args_)>()
         }
     {}

template <typename>
constexpr CustomInput::CustomInput(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL CustomInput::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) CustomInput(arena);
}
constexpr auto CustomInput::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(CustomInput), alignof(CustomInput));
}
constexpr auto CustomInput::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &CustomInput::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<CustomInput>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &CustomInput::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<CustomInput>(), &CustomInput::ByteSizeLong,
              &CustomInput::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(CustomInput, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.CustomInput",
  };
}
struct CustomInputGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr CustomInputGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 CustomInput_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(CustomInput::InternalGenerateClassData_(
            _default, &CustomInput_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<CustomInput>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~CustomInputGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) CustomInput _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<CustomInput>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(CustomInputGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST CustomInputGlobalsTypeInternal CustomInput_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* CustomInput_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return CustomInput_globals_.GetClassData();
#else
  return CustomInput_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class TrainingOutputs_TriggerConfig_ObservationTrigger::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs_TriggerConfig_ObservationTrigger, _impl_._oneof_case_);
};

constexpr TrainingOutputs_TriggerConfig_ObservationTrigger::ParseTableT_ TrainingOutputs_TriggerConfig_ObservationTrigger::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig_ObservationTrigger,
                            _impl_._cached_size_),  // no hasbits
      0, // no _extensions_
      2, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutputs_TriggerConfig_ObservationTrigger>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // uint64 delay_sec = 1;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig_ObservationTrigger, _impl_.trigger_.delay_sec_), _Internal::kOneofCaseOffset + 0, 0, (0 | ::_fl::kFcOneof | ::_fl::kUInt64)},
      // .segmentation_platform.proto.UMAOutput uma_trigger = 2;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig_ObservationTrigger, _impl_.trigger_.uma_trigger_), _Internal::kOneofCaseOffset + 0, 0, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAOutput>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::UMAOutput_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr TrainingOutputs_TriggerConfig_ObservationTrigger::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : trigger_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
constexpr TrainingOutputs_TriggerConfig_ObservationTrigger::TrainingOutputs_TriggerConfig_ObservationTrigger(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL TrainingOutputs_TriggerConfig_ObservationTrigger::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) TrainingOutputs_TriggerConfig_ObservationTrigger(arena);
}
constexpr auto TrainingOutputs_TriggerConfig_ObservationTrigger::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TrainingOutputs_TriggerConfig_ObservationTrigger), alignof(TrainingOutputs_TriggerConfig_ObservationTrigger));
}
constexpr auto TrainingOutputs_TriggerConfig_ObservationTrigger::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &TrainingOutputs_TriggerConfig_ObservationTrigger::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<TrainingOutputs_TriggerConfig_ObservationTrigger>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &TrainingOutputs_TriggerConfig_ObservationTrigger::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<TrainingOutputs_TriggerConfig_ObservationTrigger>(), &TrainingOutputs_TriggerConfig_ObservationTrigger::ByteSizeLong,
              &TrainingOutputs_TriggerConfig_ObservationTrigger::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig_ObservationTrigger, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger",
  };
}
struct TrainingOutputs_TriggerConfig_ObservationTriggerGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr TrainingOutputs_TriggerConfig_ObservationTriggerGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 TrainingOutputs_TriggerConfig_ObservationTrigger_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(TrainingOutputs_TriggerConfig_ObservationTrigger::InternalGenerateClassData_(
            _default, &TrainingOutputs_TriggerConfig_ObservationTrigger_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutputs_TriggerConfig_ObservationTrigger>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~TrainingOutputs_TriggerConfig_ObservationTriggerGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) TrainingOutputs_TriggerConfig_ObservationTrigger _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutputs_TriggerConfig_ObservationTrigger>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig_ObservationTriggerGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST TrainingOutputs_TriggerConfig_ObservationTriggerGlobalsTypeInternal TrainingOutputs_TriggerConfig_ObservationTrigger_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* TrainingOutputs_TriggerConfig_ObservationTrigger_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return TrainingOutputs_TriggerConfig_ObservationTrigger_globals_.GetClassData();
#else
  return TrainingOutputs_TriggerConfig_ObservationTrigger_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class TrainingOutput::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutput, _impl_._oneof_case_);
};

constexpr TrainingOutput::ParseTableT_ TrainingOutput::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(TrainingOutput,
                            _impl_._cached_size_),  // no hasbits
      0, // no _extensions_
      1, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967294,  // skipmap
      offsetof(ParseTableT_, field_entries),
      1,  // num_field_entries
      1,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutput>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // .segmentation_platform.proto.UMAOutput uma_output = 1;
      {PROTOBUF_FIELD_OFFSET(TrainingOutput, _impl_.output_.uma_output_), _Internal::kOneofCaseOffset + 0, 0, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAOutput>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::UMAOutput_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr TrainingOutput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : output_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
constexpr TrainingOutput::TrainingOutput(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL TrainingOutput::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) TrainingOutput(arena);
}
constexpr auto TrainingOutput::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TrainingOutput), alignof(TrainingOutput));
}
constexpr auto TrainingOutput::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &TrainingOutput::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<TrainingOutput>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &TrainingOutput::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<TrainingOutput>(), &TrainingOutput::ByteSizeLong,
              &TrainingOutput::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(TrainingOutput, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.TrainingOutput",
  };
}
struct TrainingOutputGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr TrainingOutputGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 TrainingOutput_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(TrainingOutput::InternalGenerateClassData_(
            _default, &TrainingOutput_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutput>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~TrainingOutputGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) TrainingOutput _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutput>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(TrainingOutputGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST TrainingOutputGlobalsTypeInternal TrainingOutput_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* TrainingOutput_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return TrainingOutput_globals_.GetClassData();
#else
  return TrainingOutput_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SqlFeature_BindValue::_Internal {
 public:
  using HasBits = decltype(::std::declval<SqlFeature_BindValue>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_._has_bits_);
};

constexpr SqlFeature_BindValue::ParseTableT_ SqlFeature_BindValue::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_._has_bits_),
      0, // no _extensions_
      3, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SqlFeature_BindValue>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
      // repeated int32 bind_field_index = 1;
      {::_pbi::TcParser::FastV32R1,
       {8, 0, 0,
        PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.bind_field_index_)}},
      // optional .segmentation_platform.proto.SqlFeature.BindValue.ParamType param_type = 2;
      {::_pbi::TcParser::FastEr0S1,
       {16, 2, 7,
        PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.param_type_)}},
      // optional .segmentation_platform.proto.CustomInput value = 3;
      {::_pbi::TcParser::FastMtS1,
       {26, 1, 0,
        PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.value_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated int32 bind_field_index = 1;
      {PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.bind_field_index_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kInt32)},
      // optional .segmentation_platform.proto.SqlFeature.BindValue.ParamType param_type = 2;
      {PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.param_type_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // optional .segmentation_platform.proto.CustomInput value = 3;
      {PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.value_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::CustomInput>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::CustomInput_globals_},
        #endif
        {0, 7},
    }},
    {{
    }},
  };
}


inline constexpr SqlFeature_BindValue::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        bind_field_index_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SqlFeature_BindValue,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SqlFeature_BindValue, _impl_.bind_field_index_)>()
         }
        ,
        value_{nullptr},
        param_type_{static_cast< ::segmentation_platform::proto::SqlFeature_BindValue_ParamType >(0)} {}

template <typename>
constexpr SqlFeature_BindValue::SqlFeature_BindValue(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SqlFeature_BindValue::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SqlFeature_BindValue(arena);
}
constexpr auto SqlFeature_BindValue::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SqlFeature_BindValue), alignof(SqlFeature_BindValue));
}
constexpr auto SqlFeature_BindValue::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SqlFeature_BindValue::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SqlFeature_BindValue>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SqlFeature_BindValue::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SqlFeature_BindValue>(), &SqlFeature_BindValue::ByteSizeLong,
              &SqlFeature_BindValue::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SqlFeature.BindValue",
  };
}
struct SqlFeature_BindValueGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SqlFeature_BindValueGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SqlFeature_BindValue_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SqlFeature_BindValue::InternalGenerateClassData_(
            _default, &SqlFeature_BindValue_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SqlFeature_BindValue>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SqlFeature_BindValueGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SqlFeature_BindValue _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SqlFeature_BindValue>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SqlFeature_BindValueGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SqlFeature_BindValueGlobalsTypeInternal SqlFeature_BindValue_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SqlFeature_BindValue_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SqlFeature_BindValue_globals_.GetClassData();
#else
  return SqlFeature_BindValue_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class TrainingOutputs_TriggerConfig::_Internal {
 public:
  using HasBits = decltype(::std::declval<TrainingOutputs_TriggerConfig>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_._has_bits_);
};

constexpr TrainingOutputs_TriggerConfig::ParseTableT_ TrainingOutputs_TriggerConfig::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_._has_bits_),
      0, // no _extensions_
      4, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967280,  // skipmap
      offsetof(ParseTableT_, field_entries),
      4,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutputs_TriggerConfig>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional bool use_flexible_observation_time = 4;
      {::_pbi::TcParser::FastV8S1,
       {32, 3, 0,
        PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.use_flexible_observation_time_)}},
      // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig.DecisionType decision_type = 1;
      {::_pbi::TcParser::FastEr0S1,
       {8, 1, 2,
        PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.decision_type_)}},
      // repeated .segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger observation_trigger = 2;
      {::_pbi::TcParser::FastMtR1,
       {18, 0, 0,
        PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.observation_trigger_)}},
      // optional bool use_exact_prediction_time = 3;
      {::_pbi::TcParser::FastV8S1,
       {24, 2, 0,
        PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.use_exact_prediction_time_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig.DecisionType decision_type = 1;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.decision_type_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // repeated .segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger observation_trigger = 2;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.observation_trigger_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional bool use_exact_prediction_time = 3;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.use_exact_prediction_time_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
      // optional bool use_flexible_observation_time = 4;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.use_flexible_observation_time_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutputs_TriggerConfig_ObservationTrigger>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::TrainingOutputs_TriggerConfig_ObservationTrigger_globals_},
        #endif
        {0, 2},
    }},
    {{
    }},
  };
}


inline constexpr TrainingOutputs_TriggerConfig::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        observation_trigger_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::TrainingOutputs_TriggerConfig,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs_TriggerConfig, _impl_.observation_trigger_)>()
         }
        ,
        decision_type_{static_cast< ::segmentation_platform::proto::TrainingOutputs_TriggerConfig_DecisionType >(0)},
        use_exact_prediction_time_{false},
        use_flexible_observation_time_{false} {}

template <typename>
constexpr TrainingOutputs_TriggerConfig::TrainingOutputs_TriggerConfig(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL TrainingOutputs_TriggerConfig::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) TrainingOutputs_TriggerConfig(arena);
}
constexpr auto TrainingOutputs_TriggerConfig::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TrainingOutputs_TriggerConfig), alignof(TrainingOutputs_TriggerConfig));
}
constexpr auto TrainingOutputs_TriggerConfig::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &TrainingOutputs_TriggerConfig::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<TrainingOutputs_TriggerConfig>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &TrainingOutputs_TriggerConfig::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<TrainingOutputs_TriggerConfig>(), &TrainingOutputs_TriggerConfig::ByteSizeLong,
              &TrainingOutputs_TriggerConfig::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.TrainingOutputs.TriggerConfig",
  };
}
struct TrainingOutputs_TriggerConfigGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr TrainingOutputs_TriggerConfigGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 TrainingOutputs_TriggerConfig_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(TrainingOutputs_TriggerConfig::InternalGenerateClassData_(
            _default, &TrainingOutputs_TriggerConfig_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutputs_TriggerConfig>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~TrainingOutputs_TriggerConfigGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) TrainingOutputs_TriggerConfig _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutputs_TriggerConfig>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfigGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST TrainingOutputs_TriggerConfigGlobalsTypeInternal TrainingOutputs_TriggerConfig_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* TrainingOutputs_TriggerConfig_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return TrainingOutputs_TriggerConfig_globals_.GetClassData();
#else
  return TrainingOutputs_TriggerConfig_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SqlFeature::_Internal {
 public:
  using HasBits = decltype(::std::declval<SqlFeature>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_._has_bits_);
};

constexpr SqlFeature::ParseTableT_ SqlFeature::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_._has_bits_),
      0, // no _extensions_
      4, 24,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967280,  // skipmap
      offsetof(ParseTableT_, field_entries),
      4,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SqlFeature>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional string name = 4;
      {::_pbi::TcParser::FastBS1,
       {34, 2, 0,
        PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.name_)}},
      // optional string sql = 1;
      {::_pbi::TcParser::FastBS1,
       {10, 1, 0,
        PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.sql_)}},
      // optional .segmentation_platform.proto.SignalFilterConfig signal_filter = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 3, 0,
        PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.signal_filter_)}},
      // repeated .segmentation_platform.proto.SqlFeature.BindValue bind_values = 3;
      {::_pbi::TcParser::FastMtR1,
       {26, 0, 1,
        PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.bind_values_)}},
    }}, {{
      65535, 65535
    }}, {{
      // optional string sql = 1;
      {PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.sql_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // optional .segmentation_platform.proto.SignalFilterConfig signal_filter = 2;
      {PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.signal_filter_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // repeated .segmentation_platform.proto.SqlFeature.BindValue bind_values = 3;
      {PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.bind_values_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional string name = 4;
      {PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_.name_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::SignalFilterConfig>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::SignalFilterConfig_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::SqlFeature_BindValue>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::SqlFeature_BindValue_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr SqlFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        bind_values_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SqlFeature,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SqlFeature, _impl_.bind_values_)>()
         }
        ,
        sql_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        signal_filter_{nullptr} {}

template <typename>
constexpr SqlFeature::SqlFeature(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SqlFeature::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SqlFeature(arena);
}
constexpr auto SqlFeature::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SqlFeature), alignof(SqlFeature));
}
constexpr auto SqlFeature::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SqlFeature::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SqlFeature>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SqlFeature::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SqlFeature>(), &SqlFeature::ByteSizeLong,
              &SqlFeature::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SqlFeature, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SqlFeature",
  };
}
struct SqlFeatureGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SqlFeatureGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SqlFeature_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SqlFeature::InternalGenerateClassData_(
            _default, &SqlFeature_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SqlFeature>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SqlFeatureGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SqlFeature _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SqlFeature>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SqlFeatureGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SqlFeatureGlobalsTypeInternal SqlFeature_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SqlFeature_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SqlFeature_globals_.GetClassData();
#else
  return SqlFeature_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class TrainingOutputs::_Internal {
 public:
  using HasBits = decltype(::std::declval<TrainingOutputs>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_._has_bits_);
};

constexpr TrainingOutputs::ParseTableT_ TrainingOutputs::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_._has_bits_),
      0, // no _extensions_
      2, 8,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967292,  // skipmap
      offsetof(ParseTableT_, field_entries),
      2,  // num_field_entries
      2,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutputs>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig trigger_config = 2;
      {::_pbi::TcParser::FastMtS1,
       {18, 1, 1,
        PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_.trigger_config_)}},
      // repeated .segmentation_platform.proto.TrainingOutput outputs = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_.outputs_)}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .segmentation_platform.proto.TrainingOutput outputs = 1;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_.outputs_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig trigger_config = 2;
      {PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_.trigger_config_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutput>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::TrainingOutput_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutputs_TriggerConfig>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::TrainingOutputs_TriggerConfig_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr TrainingOutputs::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        outputs_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::TrainingOutputs,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs, _impl_.outputs_)>()
         }
        ,
        trigger_config_{nullptr} {}

template <typename>
constexpr TrainingOutputs::TrainingOutputs(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL TrainingOutputs::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) TrainingOutputs(arena);
}
constexpr auto TrainingOutputs::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TrainingOutputs), alignof(TrainingOutputs));
}
constexpr auto TrainingOutputs::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &TrainingOutputs::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<TrainingOutputs>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &TrainingOutputs::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<TrainingOutputs>(), &TrainingOutputs::ByteSizeLong,
              &TrainingOutputs::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(TrainingOutputs, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.TrainingOutputs",
  };
}
struct TrainingOutputsGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr TrainingOutputsGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 TrainingOutputs_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(TrainingOutputs::InternalGenerateClassData_(
            _default, &TrainingOutputs_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutputs>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~TrainingOutputsGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) TrainingOutputs _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<TrainingOutputs>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(TrainingOutputsGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST TrainingOutputsGlobalsTypeInternal TrainingOutputs_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* TrainingOutputs_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return TrainingOutputs_globals_.GetClassData();
#else
  return TrainingOutputs_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class InputFeature::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::InputFeature, _impl_._oneof_case_);
};

constexpr InputFeature::ParseTableT_ InputFeature::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(InputFeature,
                            _impl_._cached_size_),  // no hasbits
      0, // no _extensions_
      3, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967288,  // skipmap
      offsetof(ParseTableT_, field_entries),
      3,  // num_field_entries
      3,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::InputFeature>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // .segmentation_platform.proto.UMAFeature uma_feature = 1;
      {PROTOBUF_FIELD_OFFSET(InputFeature, _impl_.Feature_.uma_feature_), _Internal::kOneofCaseOffset + 0, 0, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .segmentation_platform.proto.CustomInput custom_input = 2;
      {PROTOBUF_FIELD_OFFSET(InputFeature, _impl_.Feature_.custom_input_), _Internal::kOneofCaseOffset + 0, 1, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
      // .segmentation_platform.proto.SqlFeature sql_feature = 3;
      {PROTOBUF_FIELD_OFFSET(InputFeature, _impl_.Feature_.sql_feature_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAFeature>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::UMAFeature_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::CustomInput>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::CustomInput_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::SqlFeature>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::SqlFeature_globals_},
        #endif
    }},
    {{
    }},
  };
}


inline constexpr InputFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : Feature_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
constexpr InputFeature::InputFeature(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL InputFeature::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) InputFeature(arena);
}
constexpr auto InputFeature::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(InputFeature), alignof(InputFeature));
}
constexpr auto InputFeature::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &InputFeature::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<InputFeature>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &InputFeature::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<InputFeature>(), &InputFeature::ByteSizeLong,
              &InputFeature::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(InputFeature, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.InputFeature",
  };
}
struct InputFeatureGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr InputFeatureGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 InputFeature_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(InputFeature::InternalGenerateClassData_(
            _default, &InputFeature_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<InputFeature>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~InputFeatureGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) InputFeature _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<InputFeature>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(InputFeatureGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST InputFeatureGlobalsTypeInternal InputFeature_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* InputFeature_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return InputFeature_globals_.GetClassData();
#else
  return InputFeature_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
class SegmentationModelMetadata::_Internal {
 public:
  using HasBits = decltype(::std::declval<SegmentationModelMetadata>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_._has_bits_);
};

constexpr SegmentationModelMetadata::ParseTableT_ SegmentationModelMetadata::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_._has_bits_),
      0, // no _extensions_
      17, 120,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294854656,  // skipmap
      offsetof(ParseTableT_, field_entries),
      15,  // num_field_entries
      9,  // num_aux_entries
      offsetof(ParseTableT_, aux_entries),
      class_data,
      nullptr,  // post_loop_handler
      ::_pbi::TcParser::GenericFallbackLite,  // fallback
      #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
      ::_pbi::TcParser::GetTable<::segmentation_platform::proto::SegmentationModelMetadata>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      // optional .segmentation_platform.proto.OutputConfig output_config = 16;
      {::_pbi::TcParser::FastMtS2,
       {386, 5, 4,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.output_config_)}},
      // repeated .segmentation_platform.proto.UMAFeature features = 1;
      {::_pbi::TcParser::FastMtR1,
       {10, 0, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.features_)}},
      // optional .segmentation_platform.proto.TimeUnit time_unit = 2;
      {::_pbi::TcParser::FastEr0S1,
       {16, 10, 7,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.time_unit_)}},
      // optional uint64 bucket_duration = 3;
      {::_pbi::TcParser::FastV64S1,
       {24, 6, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.bucket_duration_)}},
      // optional int64 signal_storage_length = 4;
      {::_pbi::TcParser::FastV64S1,
       {32, 7, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.signal_storage_length_)}},
      // optional int64 min_signal_collection_length = 5;
      {::_pbi::TcParser::FastV64S1,
       {40, 8, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.min_signal_collection_length_)}},
      // optional int64 result_time_to_live = 6;
      {::_pbi::TcParser::FastV64S1,
       {48, 9, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.result_time_to_live_)}},
      {::_pbi::TcParser::MiniParse, {}},
      // optional string default_discrete_mapping = 8;
      {::_pbi::TcParser::FastBS1,
       {66, 2, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.default_discrete_mapping_)}},
      // optional .segmentation_platform.proto.VersionInfo version_info = 9;
      {::_pbi::TcParser::FastMtS1,
       {74, 3, 1,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.version_info_)}},
      // repeated .segmentation_platform.proto.InputFeature input_features = 10;
      {::_pbi::TcParser::FastMtR1,
       {82, 1, 2,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.input_features_)}},
      // optional .segmentation_platform.proto.TrainingOutputs training_outputs = 11;
      {::_pbi::TcParser::FastMtS1,
       {90, 4, 3,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.training_outputs_)}},
      {::_pbi::TcParser::MiniParse, {}},
      // optional bool upload_tensors = 13;
      {::_pbi::TcParser::FastV8S1,
       {104, 11, 0,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.upload_tensors_)}},
      // optional .segmentation_platform.proto.SegmentationModelMetadata.OutputDescription return_type = 14;
      {::_pbi::TcParser::FastEr0S1,
       {112, 13, 4,
        PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.return_type_)}},
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, {{
      // repeated .segmentation_platform.proto.UMAFeature features = 1;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.features_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .segmentation_platform.proto.TimeUnit time_unit = 2;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.time_unit_), _Internal::kHasBitsOffset + 10, 5, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // optional uint64 bucket_duration = 3;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.bucket_duration_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kUInt64)},
      // optional int64 signal_storage_length = 4;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.signal_storage_length_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
      // optional int64 min_signal_collection_length = 5;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.min_signal_collection_length_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
      // optional int64 result_time_to_live = 6;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.result_time_to_live_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
      // map<string, .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping> discrete_mappings = 7;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.discrete_mappings_), _Internal::kHasBitsOffset + 14, 6, (0 | ::_fl::kFcRepeated | ::_fl::kMap)},
      // optional string default_discrete_mapping = 8;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.default_discrete_mapping_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
      // optional .segmentation_platform.proto.VersionInfo version_info = 9;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.version_info_), _Internal::kHasBitsOffset + 3, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // repeated .segmentation_platform.proto.InputFeature input_features = 10;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.input_features_), _Internal::kHasBitsOffset + 1, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional .segmentation_platform.proto.TrainingOutputs training_outputs = 11;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.training_outputs_), _Internal::kHasBitsOffset + 4, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional bool upload_tensors = 13;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.upload_tensors_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)},
      // optional .segmentation_platform.proto.SegmentationModelMetadata.OutputDescription return_type = 14;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.return_type_), _Internal::kHasBitsOffset + 13, 8, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
      // optional .segmentation_platform.proto.OutputConfig output_config = 16;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.output_config_), _Internal::kHasBitsOffset + 5, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
      // optional int64 fixed_prediction_timestamp = 17;
      {PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.fixed_prediction_timestamp_), _Internal::kHasBitsOffset + 12, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    }},
    {{
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::UMAFeature>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::UMAFeature_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::VersionInfo>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::VersionInfo_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::InputFeature>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::InputFeature_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::TrainingOutputs>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::TrainingOutputs_globals_},
        #endif
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::OutputConfig>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::OutputConfig_globals_},
        #endif
        {0, 7},
        {::_pbi::TcParser::GetMapAuxInfo(
            0, 0, 9, 11, 1)},
        #ifndef PROTOBUF_MESSAGE_GLOBALS
        {::_pbi::TcParser::GetTable<::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping>()},
        #else
        {::_pbi::FieldAuxMessageGlobals(), &::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping_globals_},
        #endif
        {0, 4},
    }},
    {{
    }},
  };
}


inline constexpr SegmentationModelMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        features_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.features_)>()
         }
        ,
        input_features_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.input_features_)>()
         }
        ,
        default_discrete_mapping_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        version_info_{nullptr},
        training_outputs_{nullptr},
        output_config_{nullptr},
        bucket_duration_{::uint64_t{0u}},
        signal_storage_length_{::int64_t{0}},
        min_signal_collection_length_{::int64_t{0}},
        result_time_to_live_{::int64_t{0}},
        time_unit_{static_cast< ::segmentation_platform::proto::TimeUnit >(0)},
        upload_tensors_{false},
        fixed_prediction_timestamp_{::int64_t{0}},
        return_type_{static_cast< ::segmentation_platform::proto::SegmentationModelMetadata_OutputDescription >(0)},
        discrete_mappings_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.discrete_mappings_)>()
         }
     {}

template <typename>
constexpr SegmentationModelMetadata::SegmentationModelMetadata(::_pbi::ConstantInitialized,
                       const ::_pbi::ClassData* PROTOBUF_NONNULL class_data)
    : ::google::protobuf::MessageLite(
#if defined(PROTOBUF_CUSTOM_VTABLE)
          class_data
#endif  // PROTOBUF_CUSTOM_VTABLE
          ),
      _impl_(internal_visibility(), ::_pbi::ConstantInitialized()) {
}
inline void* PROTOBUF_NONNULL SegmentationModelMetadata::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SegmentationModelMetadata(arena);
}
constexpr auto SegmentationModelMetadata::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SegmentationModelMetadata), alignof(SegmentationModelMetadata));
}
constexpr auto SegmentationModelMetadata::InternalGenerateClassData_(
    const MessageLite& prototype,
    const ::google::protobuf::internal::TcParseTableBase* tc_table) {
  return ::google::protobuf::internal::ClassDataLite{
      {
          &prototype,
#ifndef PROTOBUF_MESSAGE_GLOBALS
          &_table_.header,
#else
          tc_table,
#endif
          nullptr,  // IsInitialized
          &SegmentationModelMetadata::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SegmentationModelMetadata>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SegmentationModelMetadata::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SegmentationModelMetadata>(), &SegmentationModelMetadata::ByteSizeLong,
              &SegmentationModelMetadata::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_._cached_size_),
          true,
      },
      "segmentation_platform.proto.SegmentationModelMetadata",
  };
}
struct SegmentationModelMetadataGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SegmentationModelMetadataGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SegmentationModelMetadata_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SegmentationModelMetadata::InternalGenerateClassData_(
            _default, &SegmentationModelMetadata_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SegmentationModelMetadata>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SegmentationModelMetadataGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SegmentationModelMetadata _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SegmentationModelMetadata>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SegmentationModelMetadataGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SegmentationModelMetadataGlobalsTypeInternal SegmentationModelMetadata_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SegmentationModelMetadata_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SegmentationModelMetadata_globals_.GetClassData();
#else
  return SegmentationModelMetadata_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
}  // namespace proto
}  // namespace segmentation_platform
namespace segmentation_platform {
namespace proto {
PROTOBUF_CONSTINIT const uint32_t CustomInput_FillPolicy_internal_data_[] = {
    851968u, 0u, };
static const char CustomInput_FillPolicy_names[] = {
    "FILL_CLIENT_AGE_DAYS"
    "FILL_DEVICE_OS_VERSION_NUMBER"
    "FILL_DEVICE_PPI"
    "FILL_DEVICE_RAM_MB"
    "FILL_FROM_INPUT_CONTEXT"
    "FILL_FROM_SHOPPING_SERVICE"
    "FILL_PREDICTION_TIME"
    "FILL_RANDOM"
    "FILL_SYNC_DEVICE_INFO"
    "FILL_TAB_METRICS"
    "PRICE_TRACKING_HINTS"
    "TIME_RANGE_BEFORE_PREDICTION"
    "UNKNOWN_FILL_POLICY"
};

static const ::google::protobuf::internal::EnumEntry CustomInput_FillPolicy_entries[] = {
    {{&CustomInput_FillPolicy_names[0], 20}, 12},
    {{&CustomInput_FillPolicy_names[20], 29}, 7},
    {{&CustomInput_FillPolicy_names[49], 15}, 8},
    {{&CustomInput_FillPolicy_names[64], 18}, 6},
    {{&CustomInput_FillPolicy_names[82], 23}, 4},
    {{&CustomInput_FillPolicy_names[105], 26}, 11},
    {{&CustomInput_FillPolicy_names[131], 20}, 1},
    {{&CustomInput_FillPolicy_names[151], 11}, 10},
    {{&CustomInput_FillPolicy_names[162], 21}, 5},
    {{&CustomInput_FillPolicy_names[183], 16}, 9},
    {{&CustomInput_FillPolicy_names[199], 20}, 3},
    {{&CustomInput_FillPolicy_names[219], 28}, 2},
    {{&CustomInput_FillPolicy_names[247], 19}, 0},
};

static const int CustomInput_FillPolicy_entries_by_number[] = {
    12,  // 0 -> UNKNOWN_FILL_POLICY
    6,  // 1 -> FILL_PREDICTION_TIME
    11,  // 2 -> TIME_RANGE_BEFORE_PREDICTION
    10,  // 3 -> PRICE_TRACKING_HINTS
    4,  // 4 -> FILL_FROM_INPUT_CONTEXT
    8,  // 5 -> FILL_SYNC_DEVICE_INFO
    3,  // 6 -> FILL_DEVICE_RAM_MB
    1,  // 7 -> FILL_DEVICE_OS_VERSION_NUMBER
    2,  // 8 -> FILL_DEVICE_PPI
    9,  // 9 -> FILL_TAB_METRICS
    7,  // 10 -> FILL_RANDOM
    5,  // 11 -> FILL_FROM_SHOPPING_SERVICE
    0,  // 12 -> FILL_CLIENT_AGE_DAYS
};

bool CustomInput_FillPolicy_Parse(::absl::string_view name,
                                  CustomInput_FillPolicy* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      CustomInput_FillPolicy_entries, 13, name, &int_value);
  if (success) {
    *value = static_cast<CustomInput_FillPolicy>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    CustomInput_FillPolicy_strings[13] = {};

const ::std::string& CustomInput_FillPolicy_Name(CustomInput_FillPolicy value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      CustomInput_FillPolicy_entries, CustomInput_FillPolicy_entries_by_number, 13,
      CustomInput_FillPolicy_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(CustomInput_FillPolicy_entries,
                                  CustomInput_FillPolicy_entries_by_number,
                                  13, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CustomInput_FillPolicy_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SqlFeature_BindValue_ParamType_internal_data_[] = {
    524288u, 0u, };
static const char SqlFeature_BindValue_ParamType_names[] = {
    "BOOL"
    "DOUBLE"
    "INT"
    "INT64"
    "NULL"
    "STRING"
    "TIME"
    "UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry SqlFeature_BindValue_ParamType_entries[] = {
    {{&SqlFeature_BindValue_ParamType_names[0], 4}, 2},
    {{&SqlFeature_BindValue_ParamType_names[4], 6}, 5},
    {{&SqlFeature_BindValue_ParamType_names[10], 3}, 3},
    {{&SqlFeature_BindValue_ParamType_names[13], 5}, 4},
    {{&SqlFeature_BindValue_ParamType_names[18], 4}, 1},
    {{&SqlFeature_BindValue_ParamType_names[22], 6}, 6},
    {{&SqlFeature_BindValue_ParamType_names[28], 4}, 7},
    {{&SqlFeature_BindValue_ParamType_names[32], 7}, 0},
};

static const int SqlFeature_BindValue_ParamType_entries_by_number[] = {
    7,  // 0 -> UNKNOWN
    4,  // 1 -> NULL
    0,  // 2 -> BOOL
    2,  // 3 -> INT
    3,  // 4 -> INT64
    1,  // 5 -> DOUBLE
    5,  // 6 -> STRING
    6,  // 7 -> TIME
};

bool SqlFeature_BindValue_ParamType_Parse(::absl::string_view name,
                                  SqlFeature_BindValue_ParamType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SqlFeature_BindValue_ParamType_entries, 8, name, &int_value);
  if (success) {
    *value = static_cast<SqlFeature_BindValue_ParamType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SqlFeature_BindValue_ParamType_strings[8] = {};

const ::std::string& SqlFeature_BindValue_ParamType_Name(SqlFeature_BindValue_ParamType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SqlFeature_BindValue_ParamType_entries, SqlFeature_BindValue_ParamType_entries_by_number, 8,
      SqlFeature_BindValue_ParamType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SqlFeature_BindValue_ParamType_entries,
                                  SqlFeature_BindValue_ParamType_entries_by_number,
                                  8, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SqlFeature_BindValue_ParamType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t TrainingOutputs_TriggerConfig_DecisionType_internal_data_[] = {
    196608u, 0u, };
static const char TrainingOutputs_TriggerConfig_DecisionType_names[] = {
    "ONDEMAND"
    "PERIODIC"
    "UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry TrainingOutputs_TriggerConfig_DecisionType_entries[] = {
    {{&TrainingOutputs_TriggerConfig_DecisionType_names[0], 8}, 1},
    {{&TrainingOutputs_TriggerConfig_DecisionType_names[8], 8}, 2},
    {{&TrainingOutputs_TriggerConfig_DecisionType_names[16], 7}, 0},
};

static const int TrainingOutputs_TriggerConfig_DecisionType_entries_by_number[] = {
    2,  // 0 -> UNKNOWN
    0,  // 1 -> ONDEMAND
    1,  // 2 -> PERIODIC
};

bool TrainingOutputs_TriggerConfig_DecisionType_Parse(::absl::string_view name,
                                  TrainingOutputs_TriggerConfig_DecisionType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      TrainingOutputs_TriggerConfig_DecisionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<TrainingOutputs_TriggerConfig_DecisionType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    TrainingOutputs_TriggerConfig_DecisionType_strings[3] = {};

const ::std::string& TrainingOutputs_TriggerConfig_DecisionType_Name(TrainingOutputs_TriggerConfig_DecisionType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      TrainingOutputs_TriggerConfig_DecisionType_entries, TrainingOutputs_TriggerConfig_DecisionType_entries_by_number, 3,
      TrainingOutputs_TriggerConfig_DecisionType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(TrainingOutputs_TriggerConfig_DecisionType_entries,
                                  TrainingOutputs_TriggerConfig_DecisionType_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : TrainingOutputs_TriggerConfig_DecisionType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SegmentationModelMetadata_OutputDescription_internal_data_[] = {
    327680u, 0u, };
static const char SegmentationModelMetadata_OutputDescription_names[] = {
    "RETURN_TYPE_HEURISTIC"
    "RETURN_TYPE_INTEGER"
    "RETURN_TYPE_MULTISEGMENT"
    "RETURN_TYPE_PROBABILITY"
    "UNKNOWN_RETURN_TYPE"
};

static const ::google::protobuf::internal::EnumEntry SegmentationModelMetadata_OutputDescription_entries[] = {
    {{&SegmentationModelMetadata_OutputDescription_names[0], 21}, 1},
    {{&SegmentationModelMetadata_OutputDescription_names[21], 19}, 4},
    {{&SegmentationModelMetadata_OutputDescription_names[40], 24}, 2},
    {{&SegmentationModelMetadata_OutputDescription_names[64], 23}, 3},
    {{&SegmentationModelMetadata_OutputDescription_names[87], 19}, 0},
};

static const int SegmentationModelMetadata_OutputDescription_entries_by_number[] = {
    4,  // 0 -> UNKNOWN_RETURN_TYPE
    0,  // 1 -> RETURN_TYPE_HEURISTIC
    2,  // 2 -> RETURN_TYPE_MULTISEGMENT
    3,  // 3 -> RETURN_TYPE_PROBABILITY
    1,  // 4 -> RETURN_TYPE_INTEGER
};

bool SegmentationModelMetadata_OutputDescription_Parse(::absl::string_view name,
                                  SegmentationModelMetadata_OutputDescription* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SegmentationModelMetadata_OutputDescription_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<SegmentationModelMetadata_OutputDescription>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SegmentationModelMetadata_OutputDescription_strings[5] = {};

const ::std::string& SegmentationModelMetadata_OutputDescription_Name(SegmentationModelMetadata_OutputDescription value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SegmentationModelMetadata_OutputDescription_entries, SegmentationModelMetadata_OutputDescription_entries_by_number, 5,
      SegmentationModelMetadata_OutputDescription_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SegmentationModelMetadata_OutputDescription_entries,
                                  SegmentationModelMetadata_OutputDescription_entries_by_number,
                                  5, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SegmentationModelMetadata_OutputDescription_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t CurrentVersion_internal_data_[] = {
    65539u, 0u, };
static const char CurrentVersion_names[] = {
    "METADATA_VERSION"
};

static const ::google::protobuf::internal::EnumEntry CurrentVersion_entries[] = {
    {{&CurrentVersion_names[0], 16}, 3},
};

static const int CurrentVersion_entries_by_number[] = {
    0,  // 3 -> METADATA_VERSION
};

bool CurrentVersion_Parse(::absl::string_view name,
                                  CurrentVersion* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      CurrentVersion_entries, 1, name, &int_value);
  if (success) {
    *value = static_cast<CurrentVersion>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    CurrentVersion_strings[1] = {};

const ::std::string& CurrentVersion_Name(CurrentVersion value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      CurrentVersion_entries, CurrentVersion_entries_by_number, 1,
      CurrentVersion_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(CurrentVersion_entries,
                                  CurrentVersion_entries_by_number,
                                  1, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CurrentVersion_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t ModelSource_internal_data_[] = {
    196608u, 0u, };
static const char ModelSource_names[] = {
    "DEFAULT_MODEL_SOURCE"
    "SERVER_MODEL_SOURCE"
    "UNKNOWN_MODEL_SOURCE"
};

static const ::google::protobuf::internal::EnumEntry ModelSource_entries[] = {
    {{&ModelSource_names[0], 20}, 2},
    {{&ModelSource_names[20], 19}, 1},
    {{&ModelSource_names[39], 20}, 0},
};

static const int ModelSource_entries_by_number[] = {
    2,  // 0 -> UNKNOWN_MODEL_SOURCE
    1,  // 1 -> SERVER_MODEL_SOURCE
    0,  // 2 -> DEFAULT_MODEL_SOURCE
};

bool ModelSource_Parse(::absl::string_view name,
                                  ModelSource* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      ModelSource_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<ModelSource>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    ModelSource_strings[3] = {};

const ::std::string& ModelSource_Name(ModelSource value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      ModelSource_entries, ModelSource_entries_by_number, 3,
      ModelSource_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(ModelSource_entries,
                                  ModelSource_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ModelSource_strings[idx].get();
}
// ===================================================================

VersionInfo::VersionInfo(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, VersionInfo_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.VersionInfo)
}
VersionInfo::VersionInfo(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const VersionInfo& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, VersionInfo_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE VersionInfo::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void VersionInfo::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, metadata_min_version_),
           0,
           offsetof(Impl_, metadata_cur_version_) -
               offsetof(Impl_, metadata_min_version_) +
               sizeof(Impl_::metadata_cur_version_));
}
VersionInfo::~VersionInfo() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.VersionInfo)
  SharedDtor(*this);
}
inline void VersionInfo::SharedDtor(MessageLite& self) {
  VersionInfo& this_ = static_cast<VersionInfo&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite VersionInfo_class_data_ =
    VersionInfo::InternalGenerateClassData_(VersionInfo_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
VersionInfo::GetClassData() const {
  return VersionInfo_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
VersionInfo::GetClassData() const {
  return VersionInfo_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const VersionInfo::ParseTableT_
    VersionInfo::_table_ =
        VersionInfo::InternalGenerateParseTable_(VersionInfo_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void VersionInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.VersionInfo)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.metadata_min_version_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.metadata_cur_version_) -
        reinterpret_cast<char*>(&_impl_.metadata_min_version_)) + sizeof(_impl_.metadata_cur_version_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL VersionInfo::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const VersionInfo& this_ = static_cast<const VersionInfo&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL VersionInfo::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const VersionInfo& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.VersionInfo)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 metadata_min_version = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_metadata_min_version(), target);
  }

  // optional int32 metadata_cur_version = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(
            stream, this_._internal_metadata_cur_version(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.VersionInfo)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t VersionInfo::ByteSizeLong(const MessageLite& base) {
  const VersionInfo& this_ = static_cast<const VersionInfo&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t VersionInfo::ByteSizeLong() const {
  const VersionInfo& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.VersionInfo)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // optional int32 metadata_min_version = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_metadata_min_version());
    }
    // optional int32 metadata_cur_version = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_metadata_cur_version());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void VersionInfo::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<VersionInfo*>(&to_msg);
  auto& from = static_cast<const VersionInfo&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.VersionInfo)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.metadata_min_version_ = from._impl_.metadata_min_version_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.metadata_cur_version_ = from._impl_.metadata_cur_version_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void VersionInfo::CopyFrom(const VersionInfo& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.VersionInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void VersionInfo::InternalSwap(VersionInfo* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_.metadata_cur_version_)
      + sizeof(VersionInfo::_impl_.metadata_cur_version_)
      - PROTOBUF_FIELD_OFFSET(VersionInfo, _impl_.metadata_min_version_)>(
          reinterpret_cast<char*>(&_impl_.metadata_min_version_),
          reinterpret_cast<char*>(&other->_impl_.metadata_min_version_));
}

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

UMAFeature::UMAFeature(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, UMAFeature_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.UMAFeature)
}
PROTOBUF_NDEBUG_INLINE UMAFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::UMAFeature& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        enum_ids_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::UMAFeature,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::UMAFeature, _impl_.enum_ids_)>()
          , from.enum_ids_
        }
        ,
        default_values_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::UMAFeature,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::UMAFeature, _impl_.default_values_)>()
          , from.default_values_
        }
        ,
        name_(arena, from.name_) {}

UMAFeature::UMAFeature(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const UMAFeature& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, UMAFeature_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  UMAFeature* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, name_hash_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, name_hash_),
           offsetof(Impl_, tensor_length_) -
               offsetof(Impl_, name_hash_) +
               sizeof(Impl_::tensor_length_));

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.UMAFeature)
}
PROTOBUF_NDEBUG_INLINE UMAFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        enum_ids_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::UMAFeature,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::UMAFeature, _impl_.enum_ids_)>()
         }
        ,
        default_values_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::UMAFeature,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::UMAFeature, _impl_.default_values_)>()
         }
        ,
        name_(arena) {}

inline void UMAFeature::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, name_hash_),
           0,
           offsetof(Impl_, tensor_length_) -
               offsetof(Impl_, name_hash_) +
               sizeof(Impl_::tensor_length_));
}
UMAFeature::~UMAFeature() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.UMAFeature)
  SharedDtor(*this);
}
inline void UMAFeature::SharedDtor(MessageLite& self) {
  UMAFeature& this_ = static_cast<UMAFeature&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.name_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite UMAFeature_class_data_ =
    UMAFeature::InternalGenerateClassData_(UMAFeature_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
UMAFeature::GetClassData() const {
  return UMAFeature_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
UMAFeature::GetClassData() const {
  return UMAFeature_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const UMAFeature::ParseTableT_
    UMAFeature::_table_ =
        UMAFeature::InternalGenerateParseTable_(UMAFeature_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void UMAFeature::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.UMAFeature)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.enum_ids_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.default_values_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _impl_.name_.ClearNonDefaultToEmpty();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x000000f8U)) {
    ::memset(&_impl_.name_hash_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.tensor_length_) -
        reinterpret_cast<char*>(&_impl_.name_hash_)) + sizeof(_impl_.tensor_length_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL UMAFeature::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const UMAFeature& this_ = static_cast<const UMAFeature&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL UMAFeature::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const UMAFeature& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.UMAFeature)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .segmentation_platform.proto.SignalType type = 1;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_type(), target);
  }

  // optional string name = 2;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    const ::std::string& _s = this_._internal_name();
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  // optional fixed64 name_hash = 3;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(
        3, this_._internal_name_hash(), target);
  }

  // optional uint64 bucket_count = 4;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
        4, this_._internal_bucket_count(), target);
  }

  // optional uint64 tensor_length = 5;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
        5, this_._internal_tensor_length(), target);
  }

  // optional .segmentation_platform.proto.Aggregation aggregation = 6;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        6, this_._internal_aggregation(), target);
  }

  // repeated int32 enum_ids = 7;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (int i = 0, n = this_._internal_enum_ids_size(); i < n; ++i) {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          7, this_._internal_enum_ids().Get(i), target);
    }
  }

  // repeated float default_values = 8;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    for (int i = 0, n = this_._internal_default_values_size(); i < n; ++i) {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteFloatToArray(
          8, this_._internal_default_values().Get(i), target);
    }
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.UMAFeature)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t UMAFeature::ByteSizeLong(const MessageLite& base) {
  const UMAFeature& this_ = static_cast<const UMAFeature&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t UMAFeature::ByteSizeLong() const {
  const UMAFeature& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.UMAFeature)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000008U & cached_has_bits) * 9;
  if (BatchCheckHasBit(cached_has_bits, 0x000000f7U)) {
    // repeated int32 enum_ids = 7;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
          this_._internal_enum_ids());
      ::size_t tag_size = ::size_t{1} *
          ::_pbi::FromIntSize(this_._internal_enum_ids_size());
      total_size += tag_size + data_size;
    }
    // repeated float default_values = 8;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ::size_t data_size = ::size_t{4} *
          ::_pbi::FromIntSize(this_._internal_default_values_size());
      ::size_t tag_size = ::size_t{1} *
          ::_pbi::FromIntSize(this_._internal_default_values_size());
      total_size += tag_size + data_size;
    }
    // optional string name = 2;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_name());
    }
    // optional .segmentation_platform.proto.SignalType type = 1;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_type());
    }
    // optional .segmentation_platform.proto.Aggregation aggregation = 6;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_aggregation());
    }
    // optional uint64 bucket_count = 4;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(
          this_._internal_bucket_count());
    }
    // optional uint64 tensor_length = 5;
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(
          this_._internal_tensor_length());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void UMAFeature::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<UMAFeature*>(&to_msg);
  auto& from = static_cast<const UMAFeature&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.UMAFeature)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_enum_ids()->MergeFrom(from._internal_enum_ids());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_default_values()->MergeFrom(from._internal_default_values());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_internal_set_name(from._internal_name());
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.name_hash_ = from._impl_.name_hash_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.type_ = from._impl_.type_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.aggregation_ = from._impl_.aggregation_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.bucket_count_ = from._impl_.bucket_count_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.tensor_length_ = from._impl_.tensor_length_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void UMAFeature::CopyFrom(const UMAFeature& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.UMAFeature)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void UMAFeature::InternalSwap(UMAFeature* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.enum_ids_.InternalSwap(&other->_impl_.enum_ids_);
  _impl_.default_values_.InternalSwap(&other->_impl_.default_values_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.tensor_length_)
      + sizeof(UMAFeature::_impl_.tensor_length_)
      - PROTOBUF_FIELD_OFFSET(UMAFeature, _impl_.name_hash_)>(
          reinterpret_cast<char*>(&_impl_.name_hash_),
          reinterpret_cast<char*>(&other->_impl_.name_hash_));
}

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

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

CustomInput::CustomInput(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, CustomInput_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.CustomInput)
}
PROTOBUF_NDEBUG_INLINE CustomInput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::CustomInput& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        default_value_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::CustomInput,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::CustomInput, _impl_.default_value_)>()
          , from.default_value_
        }
        ,
        name_(arena, from.name_),
        additional_args_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::CustomInput,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::CustomInput, _impl_.additional_args_)>()
          , from.additional_args_
        }
     {}

CustomInput::CustomInput(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const CustomInput& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, CustomInput_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  CustomInput* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, tensor_length_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, tensor_length_),
           offsetof(Impl_, fill_policy_) -
               offsetof(Impl_, tensor_length_) +
               sizeof(Impl_::fill_policy_));

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.CustomInput)
}
PROTOBUF_NDEBUG_INLINE CustomInput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        default_value_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::CustomInput,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::CustomInput, _impl_.default_value_)>()
         }
        ,
        name_(arena),
        additional_args_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::CustomInput,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::CustomInput, _impl_.additional_args_)>()
         }
     {}

inline void CustomInput::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, tensor_length_),
           0,
           offsetof(Impl_, fill_policy_) -
               offsetof(Impl_, tensor_length_) +
               sizeof(Impl_::fill_policy_));
}
CustomInput::~CustomInput() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.CustomInput)
  SharedDtor(*this);
}
inline void CustomInput::SharedDtor(MessageLite& self) {
  CustomInput& this_ = static_cast<CustomInput&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.name_.Destroy();
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite CustomInput_class_data_ =
    CustomInput::InternalGenerateClassData_(CustomInput_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
CustomInput::GetClassData() const {
  return CustomInput_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
CustomInput::GetClassData() const {
  return CustomInput_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const CustomInput::ParseTableT_
    CustomInput::_table_ =
        CustomInput::InternalGenerateParseTable_(CustomInput_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void CustomInput::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.CustomInput)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.default_value_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.name_.ClearNonDefaultToEmpty();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000001cU)) {
    ::memset(&_impl_.tensor_length_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.fill_policy_) -
        reinterpret_cast<char*>(&_impl_.tensor_length_)) + sizeof(_impl_.fill_policy_));
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _impl_.additional_args_.Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL CustomInput::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const CustomInput& this_ = static_cast<const CustomInput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL CustomInput::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const CustomInput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.CustomInput)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 tensor_length = 1;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_tensor_length(), target);
  }

  // optional .segmentation_platform.proto.CustomInput.FillPolicy fill_policy = 2;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this_._internal_fill_policy(), target);
  }

  // repeated float default_value = 3;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (int i = 0, n = this_._internal_default_value_size(); i < n; ++i) {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteFloatToArray(
          3, this_._internal_default_value().Get(i), target);
    }
  }

  // map<string, string> additional_args = 4;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    if (!this_._internal_additional_args().empty()) {
      using MapType = ::google::protobuf::Map<::std::string, ::std::string>;
      using WireHelper = _pbi::MapEntryFuncs<::std::string, ::std::string,
                                     _pbi::WireFormatLite::TYPE_STRING,
                                     _pbi::WireFormatLite::TYPE_STRING>;
      const auto& field = this_._internal_additional_args();

      if (stream->IsSerializationDeterministic() && field.size() > 1) {
        for (const auto& entry : ::google::protobuf::internal::MapSorterPtr<MapType>(field)) {
          target = WireHelper::InternalSerialize(
              4, entry.first, entry.second, target, stream);
        }
      } else {
        for (const auto& entry : field) {
          target = WireHelper::InternalSerialize(
              4, entry.first, entry.second, target, stream);
        }
      }
    }
  }

  // optional string name = 5;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    const ::std::string& _s = this_._internal_name();
    target = stream->WriteStringMaybeAliased(5, _s, target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.CustomInput)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t CustomInput::ByteSizeLong(const MessageLite& base) {
  const CustomInput& this_ = static_cast<const CustomInput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t CustomInput::ByteSizeLong() const {
  const CustomInput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.CustomInput)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {
    // repeated float default_value = 3;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ::size_t data_size = ::size_t{4} *
          ::_pbi::FromIntSize(this_._internal_default_value_size());
      ::size_t tag_size = ::size_t{1} *
          ::_pbi::FromIntSize(this_._internal_default_value_size());
      total_size += tag_size + data_size;
    }
    // optional string name = 5;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_name());
    }
    // optional int32 tensor_length = 1;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_tensor_length());
    }
    // optional .segmentation_platform.proto.CustomInput.FillPolicy fill_policy = 2;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_fill_policy());
    }
    // map<string, string> additional_args = 4;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size +=
          1 * ::google::protobuf::internal::FromIntSize(this_._internal_additional_args_size());
      for (const auto& entry : this_._internal_additional_args()) {
        total_size += _pbi::MapEntryFuncs<::std::string, ::std::string,
                                       _pbi::WireFormatLite::TYPE_STRING,
                                       _pbi::WireFormatLite::TYPE_STRING>::ByteSizeLong(entry.first, entry.second);
      }
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void CustomInput::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<CustomInput*>(&to_msg);
  auto& from = static_cast<const CustomInput&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.CustomInput)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_default_value()->MergeFrom(from._internal_default_value());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_set_name(from._internal_name());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.tensor_length_ = from._impl_.tensor_length_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.fill_policy_ = from._impl_.fill_policy_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.additional_args_.MergeFrom(from._impl_.additional_args_);
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void CustomInput::CopyFrom(const CustomInput& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.CustomInput)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void CustomInput::InternalSwap(CustomInput* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.default_value_.InternalSwap(&other->_impl_.default_value_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.fill_policy_)
      + sizeof(CustomInput::_impl_.fill_policy_)
      - PROTOBUF_FIELD_OFFSET(CustomInput, _impl_.tensor_length_)>(
          reinterpret_cast<char*>(&_impl_.tensor_length_),
          reinterpret_cast<char*>(&other->_impl_.tensor_length_));
  _impl_.additional_args_.InternalSwap(&other->_impl_.additional_args_);
}

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

SignalFilterConfig_UkmEvent::SignalFilterConfig_UkmEvent(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SignalFilterConfig_UkmEvent_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
}
PROTOBUF_NDEBUG_INLINE SignalFilterConfig_UkmEvent::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::SignalFilterConfig_UkmEvent& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        metric_hash_filter_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SignalFilterConfig_UkmEvent,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SignalFilterConfig_UkmEvent, _impl_.metric_hash_filter_)>()
          , from.metric_hash_filter_
        }
     {}

SignalFilterConfig_UkmEvent::SignalFilterConfig_UkmEvent(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SignalFilterConfig_UkmEvent& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SignalFilterConfig_UkmEvent_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SignalFilterConfig_UkmEvent* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  _impl_.event_hash_ = from._impl_.event_hash_;

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
}
PROTOBUF_NDEBUG_INLINE SignalFilterConfig_UkmEvent::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        metric_hash_filter_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SignalFilterConfig_UkmEvent,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SignalFilterConfig_UkmEvent, _impl_.metric_hash_filter_)>()
         }
     {}

inline void SignalFilterConfig_UkmEvent::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.event_hash_ = {};
}
SignalFilterConfig_UkmEvent::~SignalFilterConfig_UkmEvent() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  SharedDtor(*this);
}
inline void SignalFilterConfig_UkmEvent::SharedDtor(MessageLite& self) {
  SignalFilterConfig_UkmEvent& this_ = static_cast<SignalFilterConfig_UkmEvent&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SignalFilterConfig_UkmEvent_class_data_ =
    SignalFilterConfig_UkmEvent::InternalGenerateClassData_(SignalFilterConfig_UkmEvent_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SignalFilterConfig_UkmEvent::GetClassData() const {
  return SignalFilterConfig_UkmEvent_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SignalFilterConfig_UkmEvent::GetClassData() const {
  return SignalFilterConfig_UkmEvent_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SignalFilterConfig_UkmEvent::ParseTableT_
    SignalFilterConfig_UkmEvent::_table_ =
        SignalFilterConfig_UkmEvent::InternalGenerateParseTable_(SignalFilterConfig_UkmEvent_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SignalFilterConfig_UkmEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _impl_.metric_hash_filter_.Clear();
  }
  _impl_.event_hash_ = ::uint64_t{0u};
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SignalFilterConfig_UkmEvent::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SignalFilterConfig_UkmEvent& this_ = static_cast<const SignalFilterConfig_UkmEvent&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SignalFilterConfig_UkmEvent::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SignalFilterConfig_UkmEvent& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional uint64 event_hash = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
        1, this_._internal_event_hash(), target);
  }

  // repeated uint64 metric_hash_filter = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (int i = 0, n = this_._internal_metric_hash_filter_size(); i < n; ++i) {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
          2, this_._internal_metric_hash_filter().Get(i), target);
    }
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SignalFilterConfig_UkmEvent::ByteSizeLong(const MessageLite& base) {
  const SignalFilterConfig_UkmEvent& this_ = static_cast<const SignalFilterConfig_UkmEvent&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SignalFilterConfig_UkmEvent::ByteSizeLong() const {
  const SignalFilterConfig_UkmEvent& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // repeated uint64 metric_hash_filter = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ::size_t data_size = ::_pbi::WireFormatLite::UInt64Size(
          this_._internal_metric_hash_filter());
      ::size_t tag_size = ::size_t{1} *
          ::_pbi::FromIntSize(this_._internal_metric_hash_filter_size());
      total_size += tag_size + data_size;
    }
    // optional uint64 event_hash = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(
          this_._internal_event_hash());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SignalFilterConfig_UkmEvent::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SignalFilterConfig_UkmEvent*>(&to_msg);
  auto& from = static_cast<const SignalFilterConfig_UkmEvent&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_metric_hash_filter()->MergeFrom(from._internal_metric_hash_filter());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.event_hash_ = from._impl_.event_hash_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SignalFilterConfig_UkmEvent::CopyFrom(const SignalFilterConfig_UkmEvent& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SignalFilterConfig.UkmEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void SignalFilterConfig_UkmEvent::InternalSwap(SignalFilterConfig_UkmEvent* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.metric_hash_filter_.InternalSwap(&other->_impl_.metric_hash_filter_);
  swap(_impl_.event_hash_, other->_impl_.event_hash_);
}

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

SignalFilterConfig::SignalFilterConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SignalFilterConfig_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SignalFilterConfig)
}
PROTOBUF_NDEBUG_INLINE SignalFilterConfig::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::SignalFilterConfig& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        ukm_events_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SignalFilterConfig,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SignalFilterConfig, _impl_.ukm_events_)>()
          , from.ukm_events_
        }
     {}

SignalFilterConfig::SignalFilterConfig(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SignalFilterConfig& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SignalFilterConfig_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SignalFilterConfig* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.SignalFilterConfig)
}
PROTOBUF_NDEBUG_INLINE SignalFilterConfig::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        ukm_events_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SignalFilterConfig,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SignalFilterConfig, _impl_.ukm_events_)>()
         }
     {}

inline void SignalFilterConfig::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
SignalFilterConfig::~SignalFilterConfig() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SignalFilterConfig)
  SharedDtor(*this);
}
inline void SignalFilterConfig::SharedDtor(MessageLite& self) {
  SignalFilterConfig& this_ = static_cast<SignalFilterConfig&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SignalFilterConfig_class_data_ =
    SignalFilterConfig::InternalGenerateClassData_(SignalFilterConfig_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SignalFilterConfig::GetClassData() const {
  return SignalFilterConfig_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SignalFilterConfig::GetClassData() const {
  return SignalFilterConfig_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SignalFilterConfig::ParseTableT_
    SignalFilterConfig::_table_ =
        SignalFilterConfig::InternalGenerateParseTable_(SignalFilterConfig_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SignalFilterConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SignalFilterConfig)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _impl_.ukm_events_.Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SignalFilterConfig::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SignalFilterConfig& this_ = static_cast<const SignalFilterConfig&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SignalFilterConfig::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SignalFilterConfig& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SignalFilterConfig)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .segmentation_platform.proto.SignalFilterConfig.UkmEvent ukm_events = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_ukm_events_size());
         i < n; i++) {
      const auto& repfield = this_._internal_ukm_events().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SignalFilterConfig)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SignalFilterConfig::ByteSizeLong(const MessageLite& base) {
  const SignalFilterConfig& this_ = static_cast<const SignalFilterConfig&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SignalFilterConfig::ByteSizeLong() const {
  const SignalFilterConfig& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SignalFilterConfig)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
   {
    // repeated .segmentation_platform.proto.SignalFilterConfig.UkmEvent ukm_events = 1;
    cached_has_bits = this_._impl_._has_bits_[0];
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_ukm_events_size();
      for (const auto& msg : this_._internal_ukm_events()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SignalFilterConfig::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SignalFilterConfig*>(&to_msg);
  auto& from = static_cast<const SignalFilterConfig&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SignalFilterConfig)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _this->_internal_mutable_ukm_events()->InternalMergeFromWithArena(
        ::google::protobuf::MessageLite::internal_visibility(), arena,
        from._internal_ukm_events());
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SignalFilterConfig::CopyFrom(const SignalFilterConfig& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SignalFilterConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


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

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

SqlFeature_BindValue::SqlFeature_BindValue(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SqlFeature_BindValue_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SqlFeature.BindValue)
}
PROTOBUF_NDEBUG_INLINE SqlFeature_BindValue::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::SqlFeature_BindValue& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        bind_field_index_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SqlFeature_BindValue,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SqlFeature_BindValue, _impl_.bind_field_index_)>()
          , from.bind_field_index_
        }
     {}

SqlFeature_BindValue::SqlFeature_BindValue(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SqlFeature_BindValue& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SqlFeature_BindValue_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SqlFeature_BindValue* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.value_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.value_)
                : nullptr;
  _impl_.param_type_ = from._impl_.param_type_;

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.SqlFeature.BindValue)
}
PROTOBUF_NDEBUG_INLINE SqlFeature_BindValue::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        bind_field_index_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SqlFeature_BindValue,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SqlFeature_BindValue, _impl_.bind_field_index_)>()
         }
     {}

inline void SqlFeature_BindValue::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, value_),
           0,
           offsetof(Impl_, param_type_) -
               offsetof(Impl_, value_) +
               sizeof(Impl_::param_type_));
}
SqlFeature_BindValue::~SqlFeature_BindValue() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SqlFeature.BindValue)
  SharedDtor(*this);
}
inline void SqlFeature_BindValue::SharedDtor(MessageLite& self) {
  SqlFeature_BindValue& this_ = static_cast<SqlFeature_BindValue&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.value_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SqlFeature_BindValue_class_data_ =
    SqlFeature_BindValue::InternalGenerateClassData_(SqlFeature_BindValue_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SqlFeature_BindValue::GetClassData() const {
  return SqlFeature_BindValue_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SqlFeature_BindValue::GetClassData() const {
  return SqlFeature_BindValue_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SqlFeature_BindValue::ParseTableT_
    SqlFeature_BindValue::_table_ =
        SqlFeature_BindValue::InternalGenerateParseTable_(SqlFeature_BindValue_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SqlFeature_BindValue::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SqlFeature.BindValue)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.bind_field_index_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(_impl_.value_ != nullptr);
      _impl_.value_->Clear();
    }
  }
  _impl_.param_type_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SqlFeature_BindValue::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SqlFeature_BindValue& this_ = static_cast<const SqlFeature_BindValue&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SqlFeature_BindValue::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SqlFeature_BindValue& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SqlFeature.BindValue)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated int32 bind_field_index = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (int i = 0, n = this_._internal_bind_field_index_size(); i < n; ++i) {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          1, this_._internal_bind_field_index().Get(i), target);
    }
  }

  // optional .segmentation_platform.proto.SqlFeature.BindValue.ParamType param_type = 2;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this_._internal_param_type(), target);
  }

  // optional .segmentation_platform.proto.CustomInput value = 3;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        3, *this_._impl_.value_, this_._impl_.value_->GetCachedSize(), target,
        stream);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SqlFeature.BindValue)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SqlFeature_BindValue::ByteSizeLong(const MessageLite& base) {
  const SqlFeature_BindValue& this_ = static_cast<const SqlFeature_BindValue&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SqlFeature_BindValue::ByteSizeLong() const {
  const SqlFeature_BindValue& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SqlFeature.BindValue)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    // repeated int32 bind_field_index = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ::size_t data_size = ::_pbi::WireFormatLite::Int32Size(
          this_._internal_bind_field_index());
      ::size_t tag_size = ::size_t{1} *
          ::_pbi::FromIntSize(this_._internal_bind_field_index_size());
      total_size += tag_size + data_size;
    }
    // optional .segmentation_platform.proto.CustomInput value = 3;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.value_);
    }
    // optional .segmentation_platform.proto.SqlFeature.BindValue.ParamType param_type = 2;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_param_type());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SqlFeature_BindValue::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SqlFeature_BindValue*>(&to_msg);
  auto& from = static_cast<const SqlFeature_BindValue&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SqlFeature.BindValue)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_bind_field_index()->MergeFrom(from._internal_bind_field_index());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.value_ != nullptr);
      if (_this->_impl_.value_ == nullptr) {
        _this->_impl_.value_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.value_);
      } else {
        _this->_impl_.value_->MergeFrom(*from._impl_.value_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.param_type_ = from._impl_.param_type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SqlFeature_BindValue::CopyFrom(const SqlFeature_BindValue& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SqlFeature.BindValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void SqlFeature_BindValue::InternalSwap(SqlFeature_BindValue* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.bind_field_index_.InternalSwap(&other->_impl_.bind_field_index_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.param_type_)
      + sizeof(SqlFeature_BindValue::_impl_.param_type_)
      - PROTOBUF_FIELD_OFFSET(SqlFeature_BindValue, _impl_.value_)>(
          reinterpret_cast<char*>(&_impl_.value_),
          reinterpret_cast<char*>(&other->_impl_.value_));
}

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

SqlFeature::SqlFeature(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SqlFeature_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SqlFeature)
}
PROTOBUF_NDEBUG_INLINE SqlFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::SqlFeature& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        bind_values_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SqlFeature,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SqlFeature, _impl_.bind_values_)>()
          , from.bind_values_
        }
        ,
        sql_(arena, from.sql_),
        name_(arena, from.name_) {}

SqlFeature::SqlFeature(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SqlFeature& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SqlFeature_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SqlFeature* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.signal_filter_ = (CheckHasBit(cached_has_bits, 0x00000008U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.signal_filter_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.SqlFeature)
}
PROTOBUF_NDEBUG_INLINE SqlFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        bind_values_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SqlFeature,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SqlFeature, _impl_.bind_values_)>()
         }
        ,
        sql_(arena),
        name_(arena) {}

inline void SqlFeature::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.signal_filter_ = {};
}
SqlFeature::~SqlFeature() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SqlFeature)
  SharedDtor(*this);
}
inline void SqlFeature::SharedDtor(MessageLite& self) {
  SqlFeature& this_ = static_cast<SqlFeature&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.sql_.Destroy();
  this_._impl_.name_.Destroy();
  delete this_._impl_.signal_filter_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SqlFeature_class_data_ =
    SqlFeature::InternalGenerateClassData_(SqlFeature_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SqlFeature::GetClassData() const {
  return SqlFeature_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SqlFeature::GetClassData() const {
  return SqlFeature_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SqlFeature::ParseTableT_
    SqlFeature::_table_ =
        SqlFeature::InternalGenerateParseTable_(SqlFeature_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SqlFeature::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SqlFeature)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.bind_values_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.sql_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _impl_.name_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(_impl_.signal_filter_ != nullptr);
      _impl_.signal_filter_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SqlFeature::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SqlFeature& this_ = static_cast<const SqlFeature&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SqlFeature::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SqlFeature& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SqlFeature)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional string sql = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    const ::std::string& _s = this_._internal_sql();
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // optional .segmentation_platform.proto.SignalFilterConfig signal_filter = 2;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.signal_filter_, this_._impl_.signal_filter_->GetCachedSize(), target,
        stream);
  }

  // repeated .segmentation_platform.proto.SqlFeature.BindValue bind_values = 3;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_bind_values_size());
         i < n; i++) {
      const auto& repfield = this_._internal_bind_values().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              3, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional string name = 4;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    const ::std::string& _s = this_._internal_name();
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SqlFeature)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SqlFeature::ByteSizeLong(const MessageLite& base) {
  const SqlFeature& this_ = static_cast<const SqlFeature&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SqlFeature::ByteSizeLong() const {
  const SqlFeature& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SqlFeature)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    // repeated .segmentation_platform.proto.SqlFeature.BindValue bind_values = 3;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_bind_values_size();
      for (const auto& msg : this_._internal_bind_values()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional string sql = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_sql());
    }
    // optional string name = 4;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_name());
    }
    // optional .segmentation_platform.proto.SignalFilterConfig signal_filter = 2;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.signal_filter_);
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SqlFeature::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SqlFeature*>(&to_msg);
  auto& from = static_cast<const SqlFeature&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SqlFeature)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_bind_values()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_bind_values());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_set_sql(from._internal_sql());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_internal_set_name(from._internal_name());
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(from._impl_.signal_filter_ != nullptr);
      if (_this->_impl_.signal_filter_ == nullptr) {
        _this->_impl_.signal_filter_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.signal_filter_);
      } else {
        _this->_impl_.signal_filter_->MergeFrom(*from._impl_.signal_filter_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SqlFeature::CopyFrom(const SqlFeature& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SqlFeature)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void SqlFeature::InternalSwap(SqlFeature* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.bind_values_.InternalSwap(&other->_impl_.bind_values_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.sql_, &other->_impl_.sql_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);
  swap(_impl_.signal_filter_, other->_impl_.signal_filter_);
}

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

void InputFeature::set_allocated_uma_feature(::segmentation_platform::proto::UMAFeature* PROTOBUF_NULLABLE uma_feature) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_Feature();
  if (uma_feature) {
    ::google::protobuf::Arena* submessage_arena = uma_feature->GetArena();
    if (message_arena != submessage_arena) {
      uma_feature = ::google::protobuf::internal::GetOwnedMessage(message_arena, uma_feature, submessage_arena);
    }
    set_has_uma_feature();
    _impl_.Feature_.uma_feature_ = uma_feature;
  }
  // @@protoc_insertion_point(field_set_allocated:segmentation_platform.proto.InputFeature.uma_feature)
}
void InputFeature::set_allocated_custom_input(::segmentation_platform::proto::CustomInput* PROTOBUF_NULLABLE custom_input) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_Feature();
  if (custom_input) {
    ::google::protobuf::Arena* submessage_arena = custom_input->GetArena();
    if (message_arena != submessage_arena) {
      custom_input = ::google::protobuf::internal::GetOwnedMessage(message_arena, custom_input, submessage_arena);
    }
    set_has_custom_input();
    _impl_.Feature_.custom_input_ = custom_input;
  }
  // @@protoc_insertion_point(field_set_allocated:segmentation_platform.proto.InputFeature.custom_input)
}
void InputFeature::set_allocated_sql_feature(::segmentation_platform::proto::SqlFeature* PROTOBUF_NULLABLE sql_feature) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_Feature();
  if (sql_feature) {
    ::google::protobuf::Arena* submessage_arena = sql_feature->GetArena();
    if (message_arena != submessage_arena) {
      sql_feature = ::google::protobuf::internal::GetOwnedMessage(message_arena, sql_feature, submessage_arena);
    }
    set_has_sql_feature();
    _impl_.Feature_.sql_feature_ = sql_feature;
  }
  // @@protoc_insertion_point(field_set_allocated:segmentation_platform.proto.InputFeature.sql_feature)
}
InputFeature::InputFeature(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, InputFeature_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.InputFeature)
}
PROTOBUF_NDEBUG_INLINE InputFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::InputFeature& from_msg)
      : Feature_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

InputFeature::InputFeature(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const InputFeature& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, InputFeature_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  InputFeature* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (Feature_case()) {
    case FEATURE_NOT_SET:
      break;
      case kUmaFeature:
        _impl_.Feature_.uma_feature_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.Feature_.uma_feature_);
        break;
      case kCustomInput:
        _impl_.Feature_.custom_input_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.Feature_.custom_input_);
        break;
      case kSqlFeature:
        _impl_.Feature_.sql_feature_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.Feature_.sql_feature_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.InputFeature)
}
PROTOBUF_NDEBUG_INLINE InputFeature::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : Feature_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void InputFeature::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
InputFeature::~InputFeature() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.InputFeature)
  SharedDtor(*this);
}
inline void InputFeature::SharedDtor(MessageLite& self) {
  InputFeature& this_ = static_cast<InputFeature&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_Feature()) {
    this_.clear_Feature();
  }
  this_._impl_.~Impl_();
}

void InputFeature::clear_Feature() {
// @@protoc_insertion_point(one_of_clear_start:segmentation_platform.proto.InputFeature)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (Feature_case()) {
    case kUmaFeature: {
      if (GetArena() == nullptr) {
        delete _impl_.Feature_.uma_feature_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.Feature_.uma_feature_ != nullptr) {
          _impl_.Feature_.uma_feature_->Clear();
        }
      }
      break;
    }
    case kCustomInput: {
      if (GetArena() == nullptr) {
        delete _impl_.Feature_.custom_input_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.Feature_.custom_input_ != nullptr) {
          _impl_.Feature_.custom_input_->Clear();
        }
      }
      break;
    }
    case kSqlFeature: {
      if (GetArena() == nullptr) {
        delete _impl_.Feature_.sql_feature_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.Feature_.sql_feature_ != nullptr) {
          _impl_.Feature_.sql_feature_->Clear();
        }
      }
      break;
    }
    case FEATURE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = FEATURE_NOT_SET;
}


#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite InputFeature_class_data_ =
    InputFeature::InternalGenerateClassData_(InputFeature_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
InputFeature::GetClassData() const {
  return InputFeature_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
InputFeature::GetClassData() const {
  return InputFeature_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const InputFeature::ParseTableT_
    InputFeature::_table_ =
        InputFeature::InternalGenerateParseTable_(InputFeature_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void InputFeature::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.InputFeature)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL InputFeature::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const InputFeature& this_ = static_cast<const InputFeature&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL InputFeature::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const InputFeature& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.InputFeature)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  switch (this_.Feature_case()) {
    case kUmaFeature: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          1, *this_._impl_.Feature_.uma_feature_, this_._impl_.Feature_.uma_feature_->GetCachedSize(), target,
          stream);
      break;
    }
    case kCustomInput: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          2, *this_._impl_.Feature_.custom_input_, this_._impl_.Feature_.custom_input_->GetCachedSize(), target,
          stream);
      break;
    }
    case kSqlFeature: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          3, *this_._impl_.Feature_.sql_feature_, this_._impl_.Feature_.sql_feature_->GetCachedSize(), target,
          stream);
      break;
    }
    default:
      break;
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.InputFeature)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t InputFeature::ByteSizeLong(const MessageLite& base) {
  const InputFeature& this_ = static_cast<const InputFeature&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t InputFeature::ByteSizeLong() const {
  const InputFeature& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.InputFeature)
  ::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 (this_.Feature_case()) {
    // .segmentation_platform.proto.UMAFeature uma_feature = 1;
    case kUmaFeature: {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.Feature_.uma_feature_);
      break;
    }
    // .segmentation_platform.proto.CustomInput custom_input = 2;
    case kCustomInput: {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.Feature_.custom_input_);
      break;
    }
    // .segmentation_platform.proto.SqlFeature sql_feature = 3;
    case kSqlFeature: {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.Feature_.sql_feature_);
      break;
    }
    case FEATURE_NOT_SET: {
      break;
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void InputFeature::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<InputFeature*>(&to_msg);
  auto& from = static_cast<const InputFeature&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.InputFeature)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  if (const uint32_t oneof_from_case =
          from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_Feature();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kUmaFeature: {
        if (oneof_needs_init) {
          _this->_impl_.Feature_.uma_feature_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.Feature_.uma_feature_);
        } else {
          _this->_impl_.Feature_.uma_feature_->CheckTypeAndMergeFrom(*from._impl_.Feature_.uma_feature_);
        }
        break;
      }
      case kCustomInput: {
        if (oneof_needs_init) {
          _this->_impl_.Feature_.custom_input_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.Feature_.custom_input_);
        } else {
          _this->_impl_.Feature_.custom_input_->CheckTypeAndMergeFrom(*from._impl_.Feature_.custom_input_);
        }
        break;
      }
      case kSqlFeature: {
        if (oneof_needs_init) {
          _this->_impl_.Feature_.sql_feature_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.Feature_.sql_feature_);
        } else {
          _this->_impl_.Feature_.sql_feature_->CheckTypeAndMergeFrom(*from._impl_.Feature_.sql_feature_);
        }
        break;
      }
      case FEATURE_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void InputFeature::CopyFrom(const InputFeature& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.InputFeature)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


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

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

void TrainingOutputs_TriggerConfig_ObservationTrigger::set_allocated_uma_trigger(::segmentation_platform::proto::UMAOutput* PROTOBUF_NULLABLE uma_trigger) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_trigger();
  if (uma_trigger) {
    ::google::protobuf::Arena* submessage_arena = uma_trigger->GetArena();
    if (message_arena != submessage_arena) {
      uma_trigger = ::google::protobuf::internal::GetOwnedMessage(message_arena, uma_trigger, submessage_arena);
    }
    set_has_uma_trigger();
    _impl_.trigger_.uma_trigger_ = uma_trigger;
  }
  // @@protoc_insertion_point(field_set_allocated:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger.uma_trigger)
}
TrainingOutputs_TriggerConfig_ObservationTrigger::TrainingOutputs_TriggerConfig_ObservationTrigger(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutputs_TriggerConfig_ObservationTrigger_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
}
PROTOBUF_NDEBUG_INLINE TrainingOutputs_TriggerConfig_ObservationTrigger::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::TrainingOutputs_TriggerConfig_ObservationTrigger& from_msg)
      : trigger_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

TrainingOutputs_TriggerConfig_ObservationTrigger::TrainingOutputs_TriggerConfig_ObservationTrigger(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const TrainingOutputs_TriggerConfig_ObservationTrigger& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutputs_TriggerConfig_ObservationTrigger_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  TrainingOutputs_TriggerConfig_ObservationTrigger* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (trigger_case()) {
    case TRIGGER_NOT_SET:
      break;
      case kDelaySec:
        _impl_.trigger_.delay_sec_ = from._impl_.trigger_.delay_sec_;
        break;
      case kUmaTrigger:
        _impl_.trigger_.uma_trigger_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.trigger_.uma_trigger_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
}
PROTOBUF_NDEBUG_INLINE TrainingOutputs_TriggerConfig_ObservationTrigger::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : trigger_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void TrainingOutputs_TriggerConfig_ObservationTrigger::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
TrainingOutputs_TriggerConfig_ObservationTrigger::~TrainingOutputs_TriggerConfig_ObservationTrigger() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  SharedDtor(*this);
}
inline void TrainingOutputs_TriggerConfig_ObservationTrigger::SharedDtor(MessageLite& self) {
  TrainingOutputs_TriggerConfig_ObservationTrigger& this_ = static_cast<TrainingOutputs_TriggerConfig_ObservationTrigger&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_trigger()) {
    this_.clear_trigger();
  }
  this_._impl_.~Impl_();
}

void TrainingOutputs_TriggerConfig_ObservationTrigger::clear_trigger() {
// @@protoc_insertion_point(one_of_clear_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (trigger_case()) {
    case kDelaySec: {
      // No need to clear
      break;
    }
    case kUmaTrigger: {
      if (GetArena() == nullptr) {
        delete _impl_.trigger_.uma_trigger_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.trigger_.uma_trigger_ != nullptr) {
          _impl_.trigger_.uma_trigger_->Clear();
        }
      }
      break;
    }
    case TRIGGER_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TRIGGER_NOT_SET;
}


#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite TrainingOutputs_TriggerConfig_ObservationTrigger_class_data_ =
    TrainingOutputs_TriggerConfig_ObservationTrigger::InternalGenerateClassData_(TrainingOutputs_TriggerConfig_ObservationTrigger_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutputs_TriggerConfig_ObservationTrigger::GetClassData() const {
  return TrainingOutputs_TriggerConfig_ObservationTrigger_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutputs_TriggerConfig_ObservationTrigger::GetClassData() const {
  return TrainingOutputs_TriggerConfig_ObservationTrigger_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const TrainingOutputs_TriggerConfig_ObservationTrigger::ParseTableT_
    TrainingOutputs_TriggerConfig_ObservationTrigger::_table_ =
        TrainingOutputs_TriggerConfig_ObservationTrigger::InternalGenerateParseTable_(TrainingOutputs_TriggerConfig_ObservationTrigger_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void TrainingOutputs_TriggerConfig_ObservationTrigger::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL TrainingOutputs_TriggerConfig_ObservationTrigger::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const TrainingOutputs_TriggerConfig_ObservationTrigger& this_ = static_cast<const TrainingOutputs_TriggerConfig_ObservationTrigger&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL TrainingOutputs_TriggerConfig_ObservationTrigger::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const TrainingOutputs_TriggerConfig_ObservationTrigger& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  switch (this_.trigger_case()) {
    case kDelaySec: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
          1, this_._internal_delay_sec(), target);
      break;
    }
    case kUmaTrigger: {
      target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
          2, *this_._impl_.trigger_.uma_trigger_, this_._impl_.trigger_.uma_trigger_->GetCachedSize(), target,
          stream);
      break;
    }
    default:
      break;
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t TrainingOutputs_TriggerConfig_ObservationTrigger::ByteSizeLong(const MessageLite& base) {
  const TrainingOutputs_TriggerConfig_ObservationTrigger& this_ = static_cast<const TrainingOutputs_TriggerConfig_ObservationTrigger&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t TrainingOutputs_TriggerConfig_ObservationTrigger::ByteSizeLong() const {
  const TrainingOutputs_TriggerConfig_ObservationTrigger& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  ::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 (this_.trigger_case()) {
    // uint64 delay_sec = 1;
    case kDelaySec: {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(
          this_._internal_delay_sec());
      break;
    }
    // .segmentation_platform.proto.UMAOutput uma_trigger = 2;
    case kUmaTrigger: {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.trigger_.uma_trigger_);
      break;
    }
    case TRIGGER_NOT_SET: {
      break;
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void TrainingOutputs_TriggerConfig_ObservationTrigger::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<TrainingOutputs_TriggerConfig_ObservationTrigger*>(&to_msg);
  auto& from = static_cast<const TrainingOutputs_TriggerConfig_ObservationTrigger&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  if (const uint32_t oneof_from_case =
          from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_trigger();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kDelaySec: {
        _this->_impl_.trigger_.delay_sec_ = from._impl_.trigger_.delay_sec_;
        break;
      }
      case kUmaTrigger: {
        if (oneof_needs_init) {
          _this->_impl_.trigger_.uma_trigger_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.trigger_.uma_trigger_);
        } else {
          _this->_impl_.trigger_.uma_trigger_->MergeFrom(*from._impl_.trigger_.uma_trigger_);
        }
        break;
      }
      case TRIGGER_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void TrainingOutputs_TriggerConfig_ObservationTrigger::CopyFrom(const TrainingOutputs_TriggerConfig_ObservationTrigger& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


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

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

TrainingOutputs_TriggerConfig::TrainingOutputs_TriggerConfig(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutputs_TriggerConfig_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
}
PROTOBUF_NDEBUG_INLINE TrainingOutputs_TriggerConfig::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::TrainingOutputs_TriggerConfig& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        observation_trigger_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::TrainingOutputs_TriggerConfig,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs_TriggerConfig, _impl_.observation_trigger_)>()
          , from.observation_trigger_
        }
     {}

TrainingOutputs_TriggerConfig::TrainingOutputs_TriggerConfig(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const TrainingOutputs_TriggerConfig& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutputs_TriggerConfig_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  TrainingOutputs_TriggerConfig* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, decision_type_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, decision_type_),
           offsetof(Impl_, use_flexible_observation_time_) -
               offsetof(Impl_, decision_type_) +
               sizeof(Impl_::use_flexible_observation_time_));

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
}
PROTOBUF_NDEBUG_INLINE TrainingOutputs_TriggerConfig::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        observation_trigger_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::TrainingOutputs_TriggerConfig,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs_TriggerConfig, _impl_.observation_trigger_)>()
         }
     {}

inline void TrainingOutputs_TriggerConfig::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, decision_type_),
           0,
           offsetof(Impl_, use_flexible_observation_time_) -
               offsetof(Impl_, decision_type_) +
               sizeof(Impl_::use_flexible_observation_time_));
}
TrainingOutputs_TriggerConfig::~TrainingOutputs_TriggerConfig() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  SharedDtor(*this);
}
inline void TrainingOutputs_TriggerConfig::SharedDtor(MessageLite& self) {
  TrainingOutputs_TriggerConfig& this_ = static_cast<TrainingOutputs_TriggerConfig&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite TrainingOutputs_TriggerConfig_class_data_ =
    TrainingOutputs_TriggerConfig::InternalGenerateClassData_(TrainingOutputs_TriggerConfig_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutputs_TriggerConfig::GetClassData() const {
  return TrainingOutputs_TriggerConfig_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutputs_TriggerConfig::GetClassData() const {
  return TrainingOutputs_TriggerConfig_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const TrainingOutputs_TriggerConfig::ParseTableT_
    TrainingOutputs_TriggerConfig::_table_ =
        TrainingOutputs_TriggerConfig::InternalGenerateParseTable_(TrainingOutputs_TriggerConfig_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void TrainingOutputs_TriggerConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _impl_.observation_trigger_.Clear();
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000000eU)) {
    ::memset(&_impl_.decision_type_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.use_flexible_observation_time_) -
        reinterpret_cast<char*>(&_impl_.decision_type_)) + sizeof(_impl_.use_flexible_observation_time_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL TrainingOutputs_TriggerConfig::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const TrainingOutputs_TriggerConfig& this_ = static_cast<const TrainingOutputs_TriggerConfig&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL TrainingOutputs_TriggerConfig::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const TrainingOutputs_TriggerConfig& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig.DecisionType decision_type = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_decision_type(), target);
  }

  // repeated .segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger observation_trigger = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_observation_trigger_size());
         i < n; i++) {
      const auto& repfield = this_._internal_observation_trigger().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional bool use_exact_prediction_time = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        3, this_._internal_use_exact_prediction_time(), target);
  }

  // optional bool use_flexible_observation_time = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        4, this_._internal_use_flexible_observation_time(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t TrainingOutputs_TriggerConfig::ByteSizeLong(const MessageLite& base) {
  const TrainingOutputs_TriggerConfig& this_ = static_cast<const TrainingOutputs_TriggerConfig&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t TrainingOutputs_TriggerConfig::ByteSizeLong() const {
  const TrainingOutputs_TriggerConfig& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x0000000cU & cached_has_bits) * 2;
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // repeated .segmentation_platform.proto.TrainingOutputs.TriggerConfig.ObservationTrigger observation_trigger = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_observation_trigger_size();
      for (const auto& msg : this_._internal_observation_trigger()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig.DecisionType decision_type = 1;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_decision_type());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void TrainingOutputs_TriggerConfig::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<TrainingOutputs_TriggerConfig*>(&to_msg);
  auto& from = static_cast<const TrainingOutputs_TriggerConfig&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_observation_trigger()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_observation_trigger());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.decision_type_ = from._impl_.decision_type_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.use_exact_prediction_time_ = from._impl_.use_exact_prediction_time_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.use_flexible_observation_time_ = from._impl_.use_flexible_observation_time_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void TrainingOutputs_TriggerConfig::CopyFrom(const TrainingOutputs_TriggerConfig& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.TrainingOutputs.TriggerConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void TrainingOutputs_TriggerConfig::InternalSwap(TrainingOutputs_TriggerConfig* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.observation_trigger_.InternalSwap(&other->_impl_.observation_trigger_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.use_flexible_observation_time_)
      + sizeof(TrainingOutputs_TriggerConfig::_impl_.use_flexible_observation_time_)
      - PROTOBUF_FIELD_OFFSET(TrainingOutputs_TriggerConfig, _impl_.decision_type_)>(
          reinterpret_cast<char*>(&_impl_.decision_type_),
          reinterpret_cast<char*>(&other->_impl_.decision_type_));
}

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

TrainingOutputs::TrainingOutputs(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutputs_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.TrainingOutputs)
}
PROTOBUF_NDEBUG_INLINE TrainingOutputs::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::TrainingOutputs& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        outputs_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::TrainingOutputs,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs, _impl_.outputs_)>()
          , from.outputs_
        }
     {}

TrainingOutputs::TrainingOutputs(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const TrainingOutputs& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutputs_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  TrainingOutputs* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.trigger_config_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.trigger_config_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.TrainingOutputs)
}
PROTOBUF_NDEBUG_INLINE TrainingOutputs::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        outputs_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::TrainingOutputs,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::TrainingOutputs, _impl_.outputs_)>()
         }
     {}

inline void TrainingOutputs::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.trigger_config_ = {};
}
TrainingOutputs::~TrainingOutputs() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.TrainingOutputs)
  SharedDtor(*this);
}
inline void TrainingOutputs::SharedDtor(MessageLite& self) {
  TrainingOutputs& this_ = static_cast<TrainingOutputs&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.trigger_config_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite TrainingOutputs_class_data_ =
    TrainingOutputs::InternalGenerateClassData_(TrainingOutputs_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutputs::GetClassData() const {
  return TrainingOutputs_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutputs::GetClassData() const {
  return TrainingOutputs_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const TrainingOutputs::ParseTableT_
    TrainingOutputs::_table_ =
        TrainingOutputs::InternalGenerateParseTable_(TrainingOutputs_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void TrainingOutputs::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.TrainingOutputs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.outputs_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(_impl_.trigger_config_ != nullptr);
      _impl_.trigger_config_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL TrainingOutputs::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const TrainingOutputs& this_ = static_cast<const TrainingOutputs&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL TrainingOutputs::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const TrainingOutputs& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.TrainingOutputs)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .segmentation_platform.proto.TrainingOutput outputs = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_outputs_size());
         i < n; i++) {
      const auto& repfield = this_._internal_outputs().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig trigger_config = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, *this_._impl_.trigger_config_, this_._impl_.trigger_config_->GetCachedSize(), target,
        stream);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.TrainingOutputs)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t TrainingOutputs::ByteSizeLong(const MessageLite& base) {
  const TrainingOutputs& this_ = static_cast<const TrainingOutputs&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t TrainingOutputs::ByteSizeLong() const {
  const TrainingOutputs& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.TrainingOutputs)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // repeated .segmentation_platform.proto.TrainingOutput outputs = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_outputs_size();
      for (const auto& msg : this_._internal_outputs()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .segmentation_platform.proto.TrainingOutputs.TriggerConfig trigger_config = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.trigger_config_);
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void TrainingOutputs::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<TrainingOutputs*>(&to_msg);
  auto& from = static_cast<const TrainingOutputs&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.TrainingOutputs)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_outputs()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_outputs());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.trigger_config_ != nullptr);
      if (_this->_impl_.trigger_config_ == nullptr) {
        _this->_impl_.trigger_config_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.trigger_config_);
      } else {
        _this->_impl_.trigger_config_->MergeFrom(*from._impl_.trigger_config_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void TrainingOutputs::CopyFrom(const TrainingOutputs& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.TrainingOutputs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void TrainingOutputs::InternalSwap(TrainingOutputs* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.outputs_.InternalSwap(&other->_impl_.outputs_);
  swap(_impl_.trigger_config_, other->_impl_.trigger_config_);
}

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

void TrainingOutput::set_allocated_uma_output(::segmentation_platform::proto::UMAOutput* PROTOBUF_NULLABLE uma_output) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_output();
  if (uma_output) {
    ::google::protobuf::Arena* submessage_arena = uma_output->GetArena();
    if (message_arena != submessage_arena) {
      uma_output = ::google::protobuf::internal::GetOwnedMessage(message_arena, uma_output, submessage_arena);
    }
    set_has_uma_output();
    _impl_.output_.uma_output_ = uma_output;
  }
  // @@protoc_insertion_point(field_set_allocated:segmentation_platform.proto.TrainingOutput.uma_output)
}
TrainingOutput::TrainingOutput(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutput_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.TrainingOutput)
}
PROTOBUF_NDEBUG_INLINE TrainingOutput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::TrainingOutput& from_msg)
      : output_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

TrainingOutput::TrainingOutput(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const TrainingOutput& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, TrainingOutput_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  TrainingOutput* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (output_case()) {
    case OUTPUT_NOT_SET:
      break;
      case kUmaOutput:
        _impl_.output_.uma_output_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.output_.uma_output_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.TrainingOutput)
}
PROTOBUF_NDEBUG_INLINE TrainingOutput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : output_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void TrainingOutput::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
TrainingOutput::~TrainingOutput() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.TrainingOutput)
  SharedDtor(*this);
}
inline void TrainingOutput::SharedDtor(MessageLite& self) {
  TrainingOutput& this_ = static_cast<TrainingOutput&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_output()) {
    this_.clear_output();
  }
  this_._impl_.~Impl_();
}

void TrainingOutput::clear_output() {
// @@protoc_insertion_point(one_of_clear_start:segmentation_platform.proto.TrainingOutput)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (output_case()) {
    case kUmaOutput: {
      if (GetArena() == nullptr) {
        delete _impl_.output_.uma_output_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        if (_impl_.output_.uma_output_ != nullptr) {
          _impl_.output_.uma_output_->Clear();
        }
      }
      break;
    }
    case OUTPUT_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = OUTPUT_NOT_SET;
}


#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite TrainingOutput_class_data_ =
    TrainingOutput::InternalGenerateClassData_(TrainingOutput_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutput::GetClassData() const {
  return TrainingOutput_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
TrainingOutput::GetClassData() const {
  return TrainingOutput_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const TrainingOutput::ParseTableT_
    TrainingOutput::_table_ =
        TrainingOutput::InternalGenerateParseTable_(TrainingOutput_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void TrainingOutput::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.TrainingOutput)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL TrainingOutput::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const TrainingOutput& this_ = static_cast<const TrainingOutput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL TrainingOutput::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const TrainingOutput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.TrainingOutput)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // .segmentation_platform.proto.UMAOutput uma_output = 1;
  if (this_.output_case() == kUmaOutput) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.output_.uma_output_, this_._impl_.output_.uma_output_->GetCachedSize(), target,
        stream);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.TrainingOutput)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t TrainingOutput::ByteSizeLong(const MessageLite& base) {
  const TrainingOutput& this_ = static_cast<const TrainingOutput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t TrainingOutput::ByteSizeLong() const {
  const TrainingOutput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.TrainingOutput)
  ::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 (this_.output_case()) {
    // .segmentation_platform.proto.UMAOutput uma_output = 1;
    case kUmaOutput: {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.output_.uma_output_);
      break;
    }
    case OUTPUT_NOT_SET: {
      break;
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void TrainingOutput::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<TrainingOutput*>(&to_msg);
  auto& from = static_cast<const TrainingOutput&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.TrainingOutput)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  if (const uint32_t oneof_from_case =
          from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_output();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kUmaOutput: {
        if (oneof_needs_init) {
          _this->_impl_.output_.uma_output_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.output_.uma_output_);
        } else {
          _this->_impl_.output_.uma_output_->MergeFrom(*from._impl_.output_.uma_output_);
        }
        break;
      }
      case OUTPUT_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void TrainingOutput::CopyFrom(const TrainingOutput& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.TrainingOutput)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


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

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

UMAOutput::UMAOutput(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, UMAOutput_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.UMAOutput)
}
PROTOBUF_NDEBUG_INLINE UMAOutput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::UMAOutput& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

UMAOutput::UMAOutput(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const UMAOutput& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, UMAOutput_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  UMAOutput* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.uma_feature_ = (CheckHasBit(cached_has_bits, 0x00000001U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.uma_feature_)
                : nullptr;
  _impl_.duration_ = from._impl_.duration_;

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.UMAOutput)
}
PROTOBUF_NDEBUG_INLINE UMAOutput::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void UMAOutput::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, uma_feature_),
           0,
           offsetof(Impl_, duration_) -
               offsetof(Impl_, uma_feature_) +
               sizeof(Impl_::duration_));
}
UMAOutput::~UMAOutput() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.UMAOutput)
  SharedDtor(*this);
}
inline void UMAOutput::SharedDtor(MessageLite& self) {
  UMAOutput& this_ = static_cast<UMAOutput&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.uma_feature_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite UMAOutput_class_data_ =
    UMAOutput::InternalGenerateClassData_(UMAOutput_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
UMAOutput::GetClassData() const {
  return UMAOutput_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
UMAOutput::GetClassData() const {
  return UMAOutput_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const UMAOutput::ParseTableT_
    UMAOutput::_table_ =
        UMAOutput::InternalGenerateParseTable_(UMAOutput_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void UMAOutput::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.UMAOutput)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (CheckHasBit(cached_has_bits, 0x00000001U)) {
    ABSL_DCHECK(_impl_.uma_feature_ != nullptr);
    _impl_.uma_feature_->Clear();
  }
  _impl_.duration_ = ::uint64_t{0u};
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL UMAOutput::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const UMAOutput& this_ = static_cast<const UMAOutput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL UMAOutput::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const UMAOutput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.UMAOutput)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .segmentation_platform.proto.UMAFeature uma_feature = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, *this_._impl_.uma_feature_, this_._impl_.uma_feature_->GetCachedSize(), target,
        stream);
  }

  // optional uint64 duration = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
        2, this_._internal_duration(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.UMAOutput)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t UMAOutput::ByteSizeLong(const MessageLite& base) {
  const UMAOutput& this_ = static_cast<const UMAOutput&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t UMAOutput::ByteSizeLong() const {
  const UMAOutput& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.UMAOutput)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    // optional .segmentation_platform.proto.UMAFeature uma_feature = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.uma_feature_);
    }
    // optional uint64 duration = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(
          this_._internal_duration());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void UMAOutput::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<UMAOutput*>(&to_msg);
  auto& from = static_cast<const UMAOutput&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.UMAOutput)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      ABSL_DCHECK(from._impl_.uma_feature_ != nullptr);
      if (_this->_impl_.uma_feature_ == nullptr) {
        _this->_impl_.uma_feature_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.uma_feature_);
      } else {
        _this->_impl_.uma_feature_->MergeFrom(*from._impl_.uma_feature_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.duration_ = from._impl_.duration_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void UMAOutput::CopyFrom(const UMAOutput& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.UMAOutput)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void UMAOutput::InternalSwap(UMAOutput* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_.duration_)
      + sizeof(UMAOutput::_impl_.duration_)
      - PROTOBUF_FIELD_OFFSET(UMAOutput, _impl_.uma_feature_)>(
          reinterpret_cast<char*>(&_impl_.uma_feature_),
          reinterpret_cast<char*>(&other->_impl_.uma_feature_));
}

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

SegmentationModelMetadata_DiscreteMapping_Entry::SegmentationModelMetadata_DiscreteMapping_Entry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SegmentationModelMetadata_DiscreteMapping_Entry_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
}
SegmentationModelMetadata_DiscreteMapping_Entry::SegmentationModelMetadata_DiscreteMapping_Entry(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SegmentationModelMetadata_DiscreteMapping_Entry& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SegmentationModelMetadata_DiscreteMapping_Entry_get_class_data()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE SegmentationModelMetadata_DiscreteMapping_Entry::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void SegmentationModelMetadata_DiscreteMapping_Entry::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, rank_),
           0,
           offsetof(Impl_, min_result_) -
               offsetof(Impl_, rank_) +
               sizeof(Impl_::min_result_));
}
SegmentationModelMetadata_DiscreteMapping_Entry::~SegmentationModelMetadata_DiscreteMapping_Entry() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  SharedDtor(*this);
}
inline void SegmentationModelMetadata_DiscreteMapping_Entry::SharedDtor(MessageLite& self) {
  SegmentationModelMetadata_DiscreteMapping_Entry& this_ = static_cast<SegmentationModelMetadata_DiscreteMapping_Entry&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SegmentationModelMetadata_DiscreteMapping_Entry_class_data_ =
    SegmentationModelMetadata_DiscreteMapping_Entry::InternalGenerateClassData_(SegmentationModelMetadata_DiscreteMapping_Entry_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SegmentationModelMetadata_DiscreteMapping_Entry::GetClassData() const {
  return SegmentationModelMetadata_DiscreteMapping_Entry_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SegmentationModelMetadata_DiscreteMapping_Entry::GetClassData() const {
  return SegmentationModelMetadata_DiscreteMapping_Entry_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SegmentationModelMetadata_DiscreteMapping_Entry::ParseTableT_
    SegmentationModelMetadata_DiscreteMapping_Entry::_table_ =
        SegmentationModelMetadata_DiscreteMapping_Entry::InternalGenerateParseTable_(SegmentationModelMetadata_DiscreteMapping_Entry_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SegmentationModelMetadata_DiscreteMapping_Entry::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    ::memset(&_impl_.rank_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.min_result_) -
        reinterpret_cast<char*>(&_impl_.rank_)) + sizeof(_impl_.min_result_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SegmentationModelMetadata_DiscreteMapping_Entry::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SegmentationModelMetadata_DiscreteMapping_Entry& this_ = static_cast<const SegmentationModelMetadata_DiscreteMapping_Entry&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SegmentationModelMetadata_DiscreteMapping_Entry::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SegmentationModelMetadata_DiscreteMapping_Entry& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // optional float min_result = 1;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        1, this_._internal_min_result(), target);
  }

  // optional int64 rank = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<2>(
            stream, this_._internal_rank(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SegmentationModelMetadata_DiscreteMapping_Entry::ByteSizeLong(const MessageLite& base) {
  const SegmentationModelMetadata_DiscreteMapping_Entry& this_ = static_cast<const SegmentationModelMetadata_DiscreteMapping_Entry&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SegmentationModelMetadata_DiscreteMapping_Entry::ByteSizeLong() const {
  const SegmentationModelMetadata_DiscreteMapping_Entry& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000002U & cached_has_bits) * 5;
   {
    // optional int64 rank = 2;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_rank());
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SegmentationModelMetadata_DiscreteMapping_Entry::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SegmentationModelMetadata_DiscreteMapping_Entry*>(&to_msg);
  auto& from = static_cast<const SegmentationModelMetadata_DiscreteMapping_Entry&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.rank_ = from._impl_.rank_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.min_result_ = from._impl_.min_result_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SegmentationModelMetadata_DiscreteMapping_Entry::CopyFrom(const SegmentationModelMetadata_DiscreteMapping_Entry& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void SegmentationModelMetadata_DiscreteMapping_Entry::InternalSwap(SegmentationModelMetadata_DiscreteMapping_Entry* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_.min_result_)
      + sizeof(SegmentationModelMetadata_DiscreteMapping_Entry::_impl_.min_result_)
      - PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata_DiscreteMapping_Entry, _impl_.rank_)>(
          reinterpret_cast<char*>(&_impl_.rank_),
          reinterpret_cast<char*>(&other->_impl_.rank_));
}

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

SegmentationModelMetadata_DiscreteMapping::SegmentationModelMetadata_DiscreteMapping(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SegmentationModelMetadata_DiscreteMapping_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
}
PROTOBUF_NDEBUG_INLINE SegmentationModelMetadata_DiscreteMapping::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        entries_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping, _impl_.entries_)>()
          , from.entries_
        }
     {}

SegmentationModelMetadata_DiscreteMapping::SegmentationModelMetadata_DiscreteMapping(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SegmentationModelMetadata_DiscreteMapping& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SegmentationModelMetadata_DiscreteMapping_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SegmentationModelMetadata_DiscreteMapping* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
}
PROTOBUF_NDEBUG_INLINE SegmentationModelMetadata_DiscreteMapping::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        entries_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping, _impl_.entries_)>()
         }
     {}

inline void SegmentationModelMetadata_DiscreteMapping::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
SegmentationModelMetadata_DiscreteMapping::~SegmentationModelMetadata_DiscreteMapping() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  SharedDtor(*this);
}
inline void SegmentationModelMetadata_DiscreteMapping::SharedDtor(MessageLite& self) {
  SegmentationModelMetadata_DiscreteMapping& this_ = static_cast<SegmentationModelMetadata_DiscreteMapping&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SegmentationModelMetadata_DiscreteMapping_class_data_ =
    SegmentationModelMetadata_DiscreteMapping::InternalGenerateClassData_(SegmentationModelMetadata_DiscreteMapping_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SegmentationModelMetadata_DiscreteMapping::GetClassData() const {
  return SegmentationModelMetadata_DiscreteMapping_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SegmentationModelMetadata_DiscreteMapping::GetClassData() const {
  return SegmentationModelMetadata_DiscreteMapping_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SegmentationModelMetadata_DiscreteMapping::ParseTableT_
    SegmentationModelMetadata_DiscreteMapping::_table_ =
        SegmentationModelMetadata_DiscreteMapping::InternalGenerateParseTable_(SegmentationModelMetadata_DiscreteMapping_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SegmentationModelMetadata_DiscreteMapping::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _impl_.entries_.Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SegmentationModelMetadata_DiscreteMapping::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SegmentationModelMetadata_DiscreteMapping& this_ = static_cast<const SegmentationModelMetadata_DiscreteMapping&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SegmentationModelMetadata_DiscreteMapping::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SegmentationModelMetadata_DiscreteMapping& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry entries = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_entries_size());
         i < n; i++) {
      const auto& repfield = this_._internal_entries().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SegmentationModelMetadata_DiscreteMapping::ByteSizeLong(const MessageLite& base) {
  const SegmentationModelMetadata_DiscreteMapping& this_ = static_cast<const SegmentationModelMetadata_DiscreteMapping&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SegmentationModelMetadata_DiscreteMapping::ByteSizeLong() const {
  const SegmentationModelMetadata_DiscreteMapping& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
   {
    // repeated .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping.Entry entries = 1;
    cached_has_bits = this_._impl_._has_bits_[0];
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_entries_size();
      for (const auto& msg : this_._internal_entries()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SegmentationModelMetadata_DiscreteMapping::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SegmentationModelMetadata_DiscreteMapping*>(&to_msg);
  auto& from = static_cast<const SegmentationModelMetadata_DiscreteMapping&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    _this->_internal_mutable_entries()->InternalMergeFromWithArena(
        ::google::protobuf::MessageLite::internal_visibility(), arena,
        from._internal_entries());
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SegmentationModelMetadata_DiscreteMapping::CopyFrom(const SegmentationModelMetadata_DiscreteMapping& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


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

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

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

void SegmentationModelMetadata::clear_output_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.output_config_ != nullptr) _impl_.output_config_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
SegmentationModelMetadata::SegmentationModelMetadata(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SegmentationModelMetadata_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:segmentation_platform.proto.SegmentationModelMetadata)
}
PROTOBUF_NDEBUG_INLINE SegmentationModelMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::segmentation_platform::proto::SegmentationModelMetadata& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        features_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SegmentationModelMetadata,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.features_)>()
          , from.features_
        }
        ,
        input_features_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SegmentationModelMetadata,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.input_features_)>()
          , from.input_features_
        }
        ,
        default_discrete_mapping_(arena, from.default_discrete_mapping_),
        discrete_mappings_ {
          visibility, ::_pbi::InternalMetadataOffset::Build<
              ::segmentation_platform::proto::SegmentationModelMetadata,
              PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.discrete_mappings_)>()
          , from.discrete_mappings_
        }
     {}

SegmentationModelMetadata::SegmentationModelMetadata(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SegmentationModelMetadata& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SegmentationModelMetadata_get_class_data()) {

#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SegmentationModelMetadata* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.version_info_ = (CheckHasBit(cached_has_bits, 0x00000008U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.version_info_)
                : nullptr;
  _impl_.training_outputs_ = (CheckHasBit(cached_has_bits, 0x00000010U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.training_outputs_)
                : nullptr;
  _impl_.output_config_ = (CheckHasBit(cached_has_bits, 0x00000020U))
                ? ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.output_config_)
                : nullptr;
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, bucket_duration_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, bucket_duration_),
           offsetof(Impl_, return_type_) -
               offsetof(Impl_, bucket_duration_) +
               sizeof(Impl_::return_type_));

  // @@protoc_insertion_point(copy_constructor:segmentation_platform.proto.SegmentationModelMetadata)
}
PROTOBUF_NDEBUG_INLINE SegmentationModelMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        features_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.features_)>()
         }
        ,
        input_features_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.input_features_)>()
         }
        ,
        default_discrete_mapping_(arena),
        discrete_mappings_ { visibility, ::_pbi::InternalMetadataOffset::Build<
            ::segmentation_platform::proto::SegmentationModelMetadata,
            PROTOBUF_FIELD_OFFSET(::segmentation_platform::proto::SegmentationModelMetadata, _impl_.discrete_mappings_)>()
         }
     {}

inline void SegmentationModelMetadata::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, version_info_),
           0,
           offsetof(Impl_, return_type_) -
               offsetof(Impl_, version_info_) +
               sizeof(Impl_::return_type_));
}
SegmentationModelMetadata::~SegmentationModelMetadata() {
  // @@protoc_insertion_point(destructor:segmentation_platform.proto.SegmentationModelMetadata)
  SharedDtor(*this);
}
inline void SegmentationModelMetadata::SharedDtor(MessageLite& self) {
  SegmentationModelMetadata& this_ = static_cast<SegmentationModelMetadata&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::std::string>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.default_discrete_mapping_.Destroy();
  delete this_._impl_.version_info_;
  delete this_._impl_.training_outputs_;
  delete this_._impl_.output_config_;
  this_._impl_.~Impl_();
}

#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataLite SegmentationModelMetadata_class_data_ =
    SegmentationModelMetadata::InternalGenerateClassData_(SegmentationModelMetadata_globals_._default);

PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SegmentationModelMetadata::GetClassData() const {
  return SegmentationModelMetadata_class_data_.base();
}
#else
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SegmentationModelMetadata::GetClassData() const {
  return SegmentationModelMetadata_globals_.GetClassData();
}
#endif  // !PROTOBUF_MESSAGE_GLOBALS
#ifndef PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const SegmentationModelMetadata::ParseTableT_
    SegmentationModelMetadata::_table_ =
        SegmentationModelMetadata::InternalGenerateParseTable_(SegmentationModelMetadata_class_data_.base());
#endif  // !PROTOBUF_MESSAGE_GLOBALS
PROTOBUF_NOINLINE void SegmentationModelMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:segmentation_platform.proto.SegmentationModelMetadata)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::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 (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _impl_.features_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _impl_.input_features_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _impl_.default_discrete_mapping_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(_impl_.version_info_ != nullptr);
      _impl_.version_info_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      ABSL_DCHECK(_impl_.training_outputs_ != nullptr);
      _impl_.training_outputs_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      ABSL_DCHECK(_impl_.output_config_ != nullptr);
      _impl_.output_config_->Clear();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x000000c0U)) {
    ::memset(&_impl_.bucket_duration_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.signal_storage_length_) -
        reinterpret_cast<char*>(&_impl_.bucket_duration_)) + sizeof(_impl_.signal_storage_length_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00007f00U)) {
    ::memset(&_impl_.min_signal_collection_length_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.return_type_) -
        reinterpret_cast<char*>(&_impl_.min_signal_collection_length_)) + sizeof(_impl_.return_type_));
    if (CheckHasBit(cached_has_bits, 0x00004000U)) {
      _impl_.discrete_mappings_.Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::std::string>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SegmentationModelMetadata::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SegmentationModelMetadata& this_ = static_cast<const SegmentationModelMetadata&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SegmentationModelMetadata::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SegmentationModelMetadata& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:segmentation_platform.proto.SegmentationModelMetadata)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = this_._impl_._has_bits_[0];
  // repeated .segmentation_platform.proto.UMAFeature features = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_features_size());
         i < n; i++) {
      const auto& repfield = this_._internal_features().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              1, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional .segmentation_platform.proto.TimeUnit time_unit = 2;
  if (CheckHasBit(cached_has_bits, 0x00000400U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this_._internal_time_unit(), target);
  }

  // optional uint64 bucket_duration = 3;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt64ToArray(
        3, this_._internal_bucket_duration(), target);
  }

  // optional int64 signal_storage_length = 4;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>(
            stream, this_._internal_signal_storage_length(), target);
  }

  // optional int64 min_signal_collection_length = 5;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<5>(
            stream, this_._internal_min_signal_collection_length(), target);
  }

  // optional int64 result_time_to_live = 6;
  if (CheckHasBit(cached_has_bits, 0x00000200U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<6>(
            stream, this_._internal_result_time_to_live(), target);
  }

  // map<string, .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping> discrete_mappings = 7;
  if (CheckHasBit(cached_has_bits, 0x00004000U)) {
    if (!this_._internal_discrete_mappings().empty()) {
      using MapType = ::google::protobuf::Map<::std::string, ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping>;
      using WireHelper = _pbi::MapEntryFuncs<::std::string, ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping,
                                     _pbi::WireFormatLite::TYPE_STRING,
                                     _pbi::WireFormatLite::TYPE_MESSAGE>;
      const auto& field = this_._internal_discrete_mappings();

      if (stream->IsSerializationDeterministic() && field.size() > 1) {
        for (const auto& entry : ::google::protobuf::internal::MapSorterPtr<MapType>(field)) {
          target = WireHelper::InternalSerialize(
              7, entry.first, entry.second, target, stream);
        }
      } else {
        for (const auto& entry : field) {
          target = WireHelper::InternalSerialize(
              7, entry.first, entry.second, target, stream);
        }
      }
    }
  }

  // optional string default_discrete_mapping = 8;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    const ::std::string& _s = this_._internal_default_discrete_mapping();
    target = stream->WriteStringMaybeAliased(8, _s, target);
  }

  // optional .segmentation_platform.proto.VersionInfo version_info = 9;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        9, *this_._impl_.version_info_, this_._impl_.version_info_->GetCachedSize(), target,
        stream);
  }

  // repeated .segmentation_platform.proto.InputFeature input_features = 10;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_input_features_size());
         i < n; i++) {
      const auto& repfield = this_._internal_input_features().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              10, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }

  // optional .segmentation_platform.proto.TrainingOutputs training_outputs = 11;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        11, *this_._impl_.training_outputs_, this_._impl_.training_outputs_->GetCachedSize(), target,
        stream);
  }

  // optional bool upload_tensors = 13;
  if (CheckHasBit(cached_has_bits, 0x00000800U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        13, this_._internal_upload_tensors(), target);
  }

  // optional .segmentation_platform.proto.SegmentationModelMetadata.OutputDescription return_type = 14;
  if (CheckHasBit(cached_has_bits, 0x00002000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        14, this_._internal_return_type(), target);
  }

  // optional .segmentation_platform.proto.OutputConfig output_config = 16;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        16, *this_._impl_.output_config_, this_._impl_.output_config_->GetCachedSize(), target,
        stream);
  }

  // optional int64 fixed_prediction_timestamp = 17;
  if (CheckHasBit(cached_has_bits, 0x00001000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
        17, this_._internal_fixed_prediction_timestamp(), target);
  }

  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:segmentation_platform.proto.SegmentationModelMetadata)
  return target;
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SegmentationModelMetadata::ByteSizeLong(const MessageLite& base) {
  const SegmentationModelMetadata& this_ = static_cast<const SegmentationModelMetadata&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SegmentationModelMetadata::ByteSizeLong() const {
  const SegmentationModelMetadata& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:segmentation_platform.proto.SegmentationModelMetadata)
  ::size_t total_size = 0;

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

  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000800U & cached_has_bits) * 2;
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    // repeated .segmentation_platform.proto.UMAFeature features = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_features_size();
      for (const auto& msg : this_._internal_features()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .segmentation_platform.proto.InputFeature input_features = 10;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1UL * this_._internal_input_features_size();
      for (const auto& msg : this_._internal_input_features()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional string default_discrete_mapping = 8;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_default_discrete_mapping());
    }
    // optional .segmentation_platform.proto.VersionInfo version_info = 9;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.version_info_);
    }
    // optional .segmentation_platform.proto.TrainingOutputs training_outputs = 11;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.training_outputs_);
    }
    // optional .segmentation_platform.proto.OutputConfig output_config = 16;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += 2 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.output_config_);
    }
    // optional uint64 bucket_duration = 3;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(
          this_._internal_bucket_duration());
    }
    // optional int64 signal_storage_length = 4;
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_signal_storage_length());
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00007700U)) {
    // optional int64 min_signal_collection_length = 5;
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_min_signal_collection_length());
    }
    // optional int64 result_time_to_live = 6;
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_result_time_to_live());
    }
    // optional .segmentation_platform.proto.TimeUnit time_unit = 2;
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_time_unit());
    }
    // optional int64 fixed_prediction_timestamp = 17;
    if (CheckHasBit(cached_has_bits, 0x00001000U)) {
      total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
                                      this_._internal_fixed_prediction_timestamp());
    }
    // optional .segmentation_platform.proto.SegmentationModelMetadata.OutputDescription return_type = 14;
    if (CheckHasBit(cached_has_bits, 0x00002000U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_return_type());
    }
    // map<string, .segmentation_platform.proto.SegmentationModelMetadata.DiscreteMapping> discrete_mappings = 7;
    if (CheckHasBit(cached_has_bits, 0x00004000U)) {
      total_size +=
          1 * ::google::protobuf::internal::FromIntSize(this_._internal_discrete_mappings_size());
      for (const auto& entry : this_._internal_discrete_mappings()) {
        total_size += _pbi::MapEntryFuncs<::std::string, ::segmentation_platform::proto::SegmentationModelMetadata_DiscreteMapping,
                                       _pbi::WireFormatLite::TYPE_STRING,
                                       _pbi::WireFormatLite::TYPE_MESSAGE>::ByteSizeLong(entry.first, entry.second);
      }
    }
  }
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    total_size += this_._internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SegmentationModelMetadata::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SegmentationModelMetadata*>(&to_msg);
  auto& from = static_cast<const SegmentationModelMetadata&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:segmentation_platform.proto.SegmentationModelMetadata)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_features()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_features());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_input_features()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_input_features());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_internal_set_default_discrete_mapping(from._internal_default_discrete_mapping());
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      ABSL_DCHECK(from._impl_.version_info_ != nullptr);
      if (_this->_impl_.version_info_ == nullptr) {
        _this->_impl_.version_info_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.version_info_);
      } else {
        _this->_impl_.version_info_->MergeFrom(*from._impl_.version_info_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      ABSL_DCHECK(from._impl_.training_outputs_ != nullptr);
      if (_this->_impl_.training_outputs_ == nullptr) {
        _this->_impl_.training_outputs_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.training_outputs_);
      } else {
        _this->_impl_.training_outputs_->MergeFrom(*from._impl_.training_outputs_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      ABSL_DCHECK(from._impl_.output_config_ != nullptr);
      if (_this->_impl_.output_config_ == nullptr) {
        _this->_impl_.output_config_ = ::google::protobuf::MessageLite::CopyConstruct(arena, *from._impl_.output_config_);
      } else {
        _this->_impl_.output_config_->MergeFrom(*from._impl_.output_config_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.bucket_duration_ = from._impl_.bucket_duration_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.signal_storage_length_ = from._impl_.signal_storage_length_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00007f00U)) {
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      _this->_impl_.min_signal_collection_length_ = from._impl_.min_signal_collection_length_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      _this->_impl_.result_time_to_live_ = from._impl_.result_time_to_live_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      _this->_impl_.time_unit_ = from._impl_.time_unit_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      _this->_impl_.upload_tensors_ = from._impl_.upload_tensors_;
    }
    if (CheckHasBit(cached_has_bits, 0x00001000U)) {
      _this->_impl_.fixed_prediction_timestamp_ = from._impl_.fixed_prediction_timestamp_;
    }
    if (CheckHasBit(cached_has_bits, 0x00002000U)) {
      _this->_impl_.return_type_ = from._impl_.return_type_;
    }
    if (CheckHasBit(cached_has_bits, 0x00004000U)) {
      _this->_impl_.discrete_mappings_.MergeFrom(from._impl_.discrete_mappings_);
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::std::string>(
      from._internal_metadata_);
}

void SegmentationModelMetadata::CopyFrom(const SegmentationModelMetadata& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:segmentation_platform.proto.SegmentationModelMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void SegmentationModelMetadata::InternalSwap(SegmentationModelMetadata* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.features_.InternalSwap(&other->_impl_.features_);
  _impl_.input_features_.InternalSwap(&other->_impl_.input_features_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.default_discrete_mapping_, &other->_impl_.default_discrete_mapping_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.return_type_)
      + sizeof(SegmentationModelMetadata::_impl_.return_type_)
      - PROTOBUF_FIELD_OFFSET(SegmentationModelMetadata, _impl_.version_info_)>(
          reinterpret_cast<char*>(&_impl_.version_info_),
          reinterpret_cast<char*>(&other->_impl_.version_info_));
  _impl_.discrete_mappings_.InternalSwap(&other->_impl_.discrete_mappings_);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace segmentation_platform
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"