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

#include "components/sync/protocol/sync_enums.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 sync_pb {
class SyncEnums::_Internal {
 public:
};

constexpr SyncEnums::ParseTableT_ SyncEnums::InternalGenerateParseTable_(const ::_pbi::ClassData* class_data) {
  return ParseTableT_{
    {
      PROTOBUF_FIELD_OFFSET(SyncEnums,
                            _impl_._cached_size_),  // no hasbits
      0, // no _extensions_
      0, 0,  // max_field_number, fast_idx_mask
      offsetof(ParseTableT_, field_lookup_table),
      4294967295,  // skipmap
      offsetof(ParseTableT_, field_names),  // no field_entries
      0,  // 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<::sync_pb::SyncEnums>(),  // to_prefetch
      #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
    }, {{
      {::_pbi::TcParser::MiniParse, {}},
    }}, {{
      65535, 65535
    }}, // no field_entries, or aux_entries
    {{
    }},
  };
}


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

template <typename>
constexpr SyncEnums::SyncEnums(::_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 SyncEnums::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SyncEnums(arena);
}
constexpr auto SyncEnums::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SyncEnums), alignof(SyncEnums));
}
constexpr auto SyncEnums::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
          &SyncEnums::MergeImpl,
          ::google::protobuf::MessageLite::GetNewImpl<SyncEnums>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SyncEnums::SharedDtor,
          ::google::protobuf::MessageLite::GetClearImpl<SyncEnums>(), &SyncEnums::ByteSizeLong,
              &SyncEnums::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SyncEnums, _impl_._cached_size_),
          true,
      },
      "sync_pb.SyncEnums",
  };
}
struct SyncEnumsGlobalsTypeInternal : ::_pbi::MessageGlobalsBase {
  constexpr SyncEnumsGlobalsTypeInternal()
      :
#ifndef PROTOBUF_MESSAGE_GLOBALS
        _default(::_pbi::ConstantInitialized{},
                 SyncEnums_class_data_.base())
#else   // !PROTOBUF_MESSAGE_GLOBALS
        MessageGlobalsBase(SyncEnums::InternalGenerateClassData_(
            _default, &SyncEnums_globals_._table.header)),
        _default(::_pbi::ConstantInitialized{}, GetClassData()),
        _table(::_pbi::PrivateAccess::GenerateParseTable<SyncEnums>(
            GetClassData()))
#endif  // PROTOBUF_MESSAGE_GLOBALS
  {
  }
  ~SyncEnumsGlobalsTypeInternal() {}
  union {
    alignas(::_pbi::kMaxMessageAlignment) SyncEnums _default;
  };
#ifdef PROTOBUF_MESSAGE_GLOBALS
  decltype(::_pbi::PrivateAccess::GenerateParseTable<SyncEnums>(
      ::std::declval<const ::_pbi::ClassData*>())) _table;
#endif
};
#ifdef PROTOBUF_MESSAGE_GLOBALS
static_assert(PROTOBUF_FIELD_OFFSET(SyncEnumsGlobalsTypeInternal, _default) ==
              ::_pbi::MessageGlobalsBase::OffsetToDefault());
#endif  // PROTOBUF_MESSAGE_GLOBALS

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PROTOBUF_MESSAGE_GLOBALS_CONST SyncEnumsGlobalsTypeInternal SyncEnums_globals_
        PROTOBUF_MESSAGE_GLOBALS_SECTION(.data.rel.ro);
#if defined(PROTOBUF_CUSTOM_VTABLE)
namespace {
const ::_pbi::ClassData* SyncEnums_get_class_data() {
#ifdef PROTOBUF_MESSAGE_GLOBALS
  return SyncEnums_globals_.GetClassData();
#else
  return SyncEnums_class_data_.base();
#endif  // PROTOBUF_MESSAGE_GLOBALS
}
}  // namespace
#endif  // PROTOBUF_CUSTOM_VTABLE
}  // namespace sync_pb
namespace sync_pb {
PROTOBUF_CONSTINIT const uint32_t SyncEnums_SingletonDebugEventType_internal_data_[] = {
    393217u, 32u, 510u, };
static const char SyncEnums_SingletonDebugEventType_names[] = {
    "ACTIONABLE_ERROR"
    "CONFIGURE_COMPLETE"
    "CONNECTION_STATUS_CHANGE"
    "DEPRECATED_BOOTSTRAP_TOKEN_UPDATED"
    "DEPRECATED_KEYSTORE_TOKEN_UPDATED"
    "ENCRYPTED_TYPES_CHANGED"
    "INITIALIZATION_COMPLETE"
    "PASSPHRASE_ACCEPTED"
    "PASSPHRASE_REQUIRED"
    "PASSPHRASE_TYPE_CHANGED"
    "STOP_SYNCING_PERMANENTLY"
    "TRUSTED_VAULT_KEY_ACCEPTED"
    "TRUSTED_VAULT_KEY_REQUIRED"
    "UPDATED_TOKEN"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_SingletonDebugEventType_entries[] = {
    {{&SyncEnums_SingletonDebugEventType_names[0], 16}, 8},
    {{&SyncEnums_SingletonDebugEventType_names[16], 18}, 12},
    {{&SyncEnums_SingletonDebugEventType_names[34], 24}, 1},
    {{&SyncEnums_SingletonDebugEventType_names[58], 34}, 13},
    {{&SyncEnums_SingletonDebugEventType_names[92], 33}, 11},
    {{&SyncEnums_SingletonDebugEventType_names[125], 23}, 9},
    {{&SyncEnums_SingletonDebugEventType_names[148], 23}, 5},
    {{&SyncEnums_SingletonDebugEventType_names[171], 19}, 4},
    {{&SyncEnums_SingletonDebugEventType_names[190], 19}, 3},
    {{&SyncEnums_SingletonDebugEventType_names[209], 23}, 10},
    {{&SyncEnums_SingletonDebugEventType_names[232], 24}, 6},
    {{&SyncEnums_SingletonDebugEventType_names[256], 26}, 15},
    {{&SyncEnums_SingletonDebugEventType_names[282], 26}, 14},
    {{&SyncEnums_SingletonDebugEventType_names[308], 13}, 2},
};

static const int SyncEnums_SingletonDebugEventType_entries_by_number[] = {
    2,  // 1 -> CONNECTION_STATUS_CHANGE
    13,  // 2 -> UPDATED_TOKEN
    8,  // 3 -> PASSPHRASE_REQUIRED
    7,  // 4 -> PASSPHRASE_ACCEPTED
    6,  // 5 -> INITIALIZATION_COMPLETE
    10,  // 6 -> STOP_SYNCING_PERMANENTLY
    0,  // 8 -> ACTIONABLE_ERROR
    5,  // 9 -> ENCRYPTED_TYPES_CHANGED
    9,  // 10 -> PASSPHRASE_TYPE_CHANGED
    4,  // 11 -> DEPRECATED_KEYSTORE_TOKEN_UPDATED
    1,  // 12 -> CONFIGURE_COMPLETE
    3,  // 13 -> DEPRECATED_BOOTSTRAP_TOKEN_UPDATED
    12,  // 14 -> TRUSTED_VAULT_KEY_REQUIRED
    11,  // 15 -> TRUSTED_VAULT_KEY_ACCEPTED
};

bool SyncEnums_SingletonDebugEventType_Parse(::absl::string_view name,
                                  SyncEnums_SingletonDebugEventType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_SingletonDebugEventType_entries, 14, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_SingletonDebugEventType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_SingletonDebugEventType_strings[14] = {};

const ::std::string& SyncEnums_SingletonDebugEventType_Name(SyncEnums_SingletonDebugEventType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_SingletonDebugEventType_entries, SyncEnums_SingletonDebugEventType_entries_by_number, 14,
      SyncEnums_SingletonDebugEventType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_SingletonDebugEventType_entries,
                                  SyncEnums_SingletonDebugEventType_entries_by_number,
                                  14, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_SingletonDebugEventType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_PageTransition_internal_data_[] = {
    720896u, 0u, };
static const char SyncEnums_PageTransition_names[] = {
    "AUTO_BOOKMARK"
    "AUTO_SUBFRAME"
    "AUTO_TOPLEVEL"
    "FORM_SUBMIT"
    "GENERATED"
    "KEYWORD"
    "KEYWORD_GENERATED"
    "LINK"
    "MANUAL_SUBFRAME"
    "RELOAD"
    "TYPED"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_PageTransition_entries[] = {
    {{&SyncEnums_PageTransition_names[0], 13}, 2},
    {{&SyncEnums_PageTransition_names[13], 13}, 3},
    {{&SyncEnums_PageTransition_names[26], 13}, 6},
    {{&SyncEnums_PageTransition_names[39], 11}, 7},
    {{&SyncEnums_PageTransition_names[50], 9}, 5},
    {{&SyncEnums_PageTransition_names[59], 7}, 9},
    {{&SyncEnums_PageTransition_names[66], 17}, 10},
    {{&SyncEnums_PageTransition_names[83], 4}, 0},
    {{&SyncEnums_PageTransition_names[87], 15}, 4},
    {{&SyncEnums_PageTransition_names[102], 6}, 8},
    {{&SyncEnums_PageTransition_names[108], 5}, 1},
};

static const int SyncEnums_PageTransition_entries_by_number[] = {
    7,  // 0 -> LINK
    10,  // 1 -> TYPED
    0,  // 2 -> AUTO_BOOKMARK
    1,  // 3 -> AUTO_SUBFRAME
    8,  // 4 -> MANUAL_SUBFRAME
    4,  // 5 -> GENERATED
    2,  // 6 -> AUTO_TOPLEVEL
    3,  // 7 -> FORM_SUBMIT
    9,  // 8 -> RELOAD
    5,  // 9 -> KEYWORD
    6,  // 10 -> KEYWORD_GENERATED
};

bool SyncEnums_PageTransition_Parse(::absl::string_view name,
                                  SyncEnums_PageTransition* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_PageTransition_entries, 11, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_PageTransition>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_PageTransition_strings[11] = {};

const ::std::string& SyncEnums_PageTransition_Name(SyncEnums_PageTransition value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_PageTransition_entries, SyncEnums_PageTransition_entries_by_number, 11,
      SyncEnums_PageTransition_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_PageTransition_entries,
                                  SyncEnums_PageTransition_entries_by_number,
                                  11, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_PageTransition_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_PageTransitionRedirectType_internal_data_[] = {
    131073u, 0u, };
static const char SyncEnums_PageTransitionRedirectType_names[] = {
    "CLIENT_REDIRECT"
    "SERVER_REDIRECT"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_PageTransitionRedirectType_entries[] = {
    {{&SyncEnums_PageTransitionRedirectType_names[0], 15}, 1},
    {{&SyncEnums_PageTransitionRedirectType_names[15], 15}, 2},
};

static const int SyncEnums_PageTransitionRedirectType_entries_by_number[] = {
    0,  // 1 -> CLIENT_REDIRECT
    1,  // 2 -> SERVER_REDIRECT
};

bool SyncEnums_PageTransitionRedirectType_Parse(::absl::string_view name,
                                  SyncEnums_PageTransitionRedirectType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_PageTransitionRedirectType_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_PageTransitionRedirectType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_PageTransitionRedirectType_strings[2] = {};

const ::std::string& SyncEnums_PageTransitionRedirectType_Name(SyncEnums_PageTransitionRedirectType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_PageTransitionRedirectType_entries, SyncEnums_PageTransitionRedirectType_entries_by_number, 2,
      SyncEnums_PageTransitionRedirectType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_PageTransitionRedirectType_entries,
                                  SyncEnums_PageTransitionRedirectType_entries_by_number,
                                  2, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_PageTransitionRedirectType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_ErrorType_internal_data_[] = {
    65536u, 65568u, 15238u, 100u, };
static const char SyncEnums_ErrorType_names[] = {
    "CLIENT_DATA_OBSOLETE"
    "DISABLED_BY_ADMIN"
    "ENCRYPTION_OBSOLETE"
    "MIGRATION_DONE"
    "NOT_MY_BIRTHDAY"
    "PARTIAL_FAILURE"
    "SUCCESS"
    "THROTTLED"
    "TRANSIENT_ERROR"
    "UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_ErrorType_entries[] = {
    {{&SyncEnums_ErrorType_names[0], 20}, 13},
    {{&SyncEnums_ErrorType_names[20], 17}, 10},
    {{&SyncEnums_ErrorType_names[37], 19}, 14},
    {{&SyncEnums_ErrorType_names[56], 14}, 9},
    {{&SyncEnums_ErrorType_names[70], 15}, 2},
    {{&SyncEnums_ErrorType_names[85], 15}, 12},
    {{&SyncEnums_ErrorType_names[100], 7}, 0},
    {{&SyncEnums_ErrorType_names[107], 9}, 3},
    {{&SyncEnums_ErrorType_names[116], 15}, 8},
    {{&SyncEnums_ErrorType_names[131], 7}, 100},
};

static const int SyncEnums_ErrorType_entries_by_number[] = {
    6,  // 0 -> SUCCESS
    4,  // 2 -> NOT_MY_BIRTHDAY
    7,  // 3 -> THROTTLED
    8,  // 8 -> TRANSIENT_ERROR
    3,  // 9 -> MIGRATION_DONE
    1,  // 10 -> DISABLED_BY_ADMIN
    5,  // 12 -> PARTIAL_FAILURE
    0,  // 13 -> CLIENT_DATA_OBSOLETE
    2,  // 14 -> ENCRYPTION_OBSOLETE
    9,  // 100 -> UNKNOWN
};

bool SyncEnums_ErrorType_Parse(::absl::string_view name,
                                  SyncEnums_ErrorType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_ErrorType_entries, 10, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_ErrorType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_ErrorType_strings[10] = {};

const ::std::string& SyncEnums_ErrorType_Name(SyncEnums_ErrorType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_ErrorType_entries, SyncEnums_ErrorType_entries_by_number, 10,
      SyncEnums_ErrorType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_ErrorType_entries,
                                  SyncEnums_ErrorType_entries_by_number,
                                  10, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_ErrorType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_Action_internal_data_[] = {
    65536u, 32u, 16u, };
static const char SyncEnums_Action_names[] = {
    "UNKNOWN_ACTION"
    "UPGRADE_CLIENT"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_Action_entries[] = {
    {{&SyncEnums_Action_names[0], 14}, 5},
    {{&SyncEnums_Action_names[14], 14}, 0},
};

static const int SyncEnums_Action_entries_by_number[] = {
    1,  // 0 -> UPGRADE_CLIENT
    0,  // 5 -> UNKNOWN_ACTION
};

bool SyncEnums_Action_Parse(::absl::string_view name,
                                  SyncEnums_Action* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_Action_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_Action>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_Action_strings[2] = {};

const ::std::string& SyncEnums_Action_Name(SyncEnums_Action value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_Action_entries, SyncEnums_Action_entries_by_number, 2,
      SyncEnums_Action_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_Action_entries,
                                  SyncEnums_Action_entries_by_number,
                                  2, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_Action_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_DeviceType_internal_data_[] = {
    524288u, 0u, };
static const char SyncEnums_DeviceType_names[] = {
    "TYPE_CROS"
    "TYPE_LINUX"
    "TYPE_MAC"
    "TYPE_OTHER"
    "TYPE_PHONE"
    "TYPE_TABLET"
    "TYPE_UNSET"
    "TYPE_WIN"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_DeviceType_entries[] = {
    {{&SyncEnums_DeviceType_names[0], 9}, 4},
    {{&SyncEnums_DeviceType_names[9], 10}, 3},
    {{&SyncEnums_DeviceType_names[19], 8}, 2},
    {{&SyncEnums_DeviceType_names[27], 10}, 5},
    {{&SyncEnums_DeviceType_names[37], 10}, 6},
    {{&SyncEnums_DeviceType_names[47], 11}, 7},
    {{&SyncEnums_DeviceType_names[58], 10}, 0},
    {{&SyncEnums_DeviceType_names[68], 8}, 1},
};

static const int SyncEnums_DeviceType_entries_by_number[] = {
    6,  // 0 -> TYPE_UNSET
    7,  // 1 -> TYPE_WIN
    2,  // 2 -> TYPE_MAC
    1,  // 3 -> TYPE_LINUX
    0,  // 4 -> TYPE_CROS
    3,  // 5 -> TYPE_OTHER
    4,  // 6 -> TYPE_PHONE
    5,  // 7 -> TYPE_TABLET
};

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

const ::std::string& SyncEnums_DeviceType_Name(SyncEnums_DeviceType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_DeviceType_entries, SyncEnums_DeviceType_entries_by_number, 8,
      SyncEnums_DeviceType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_DeviceType_entries,
                                  SyncEnums_DeviceType_entries_by_number,
                                  8, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_DeviceType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_OsType_internal_data_[] = {
    589824u, 0u, };
static const char SyncEnums_OsType_names[] = {
    "OS_TYPE_ANDROID"
    "OS_TYPE_CHROME_OS_ASH"
    "OS_TYPE_CHROME_OS_LACROS"
    "OS_TYPE_FUCHSIA"
    "OS_TYPE_IOS"
    "OS_TYPE_LINUX"
    "OS_TYPE_MAC"
    "OS_TYPE_UNSPECIFIED"
    "OS_TYPE_WINDOWS"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_OsType_entries[] = {
    {{&SyncEnums_OsType_names[0], 15}, 5},
    {{&SyncEnums_OsType_names[15], 21}, 4},
    {{&SyncEnums_OsType_names[36], 24}, 7},
    {{&SyncEnums_OsType_names[60], 15}, 8},
    {{&SyncEnums_OsType_names[75], 11}, 6},
    {{&SyncEnums_OsType_names[86], 13}, 3},
    {{&SyncEnums_OsType_names[99], 11}, 2},
    {{&SyncEnums_OsType_names[110], 19}, 0},
    {{&SyncEnums_OsType_names[129], 15}, 1},
};

static const int SyncEnums_OsType_entries_by_number[] = {
    7,  // 0 -> OS_TYPE_UNSPECIFIED
    8,  // 1 -> OS_TYPE_WINDOWS
    6,  // 2 -> OS_TYPE_MAC
    5,  // 3 -> OS_TYPE_LINUX
    1,  // 4 -> OS_TYPE_CHROME_OS_ASH
    0,  // 5 -> OS_TYPE_ANDROID
    4,  // 6 -> OS_TYPE_IOS
    2,  // 7 -> OS_TYPE_CHROME_OS_LACROS
    3,  // 8 -> OS_TYPE_FUCHSIA
};

bool SyncEnums_OsType_Parse(::absl::string_view name,
                                  SyncEnums_OsType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_OsType_entries, 9, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_OsType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_OsType_strings[9] = {};

const ::std::string& SyncEnums_OsType_Name(SyncEnums_OsType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_OsType_entries, SyncEnums_OsType_entries_by_number, 9,
      SyncEnums_OsType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_OsType_entries,
                                  SyncEnums_OsType_entries_by_number,
                                  9, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_OsType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_DeviceFormFactor_internal_data_[] = {
    458752u, 0u, };
static const char SyncEnums_DeviceFormFactor_names[] = {
    "DEVICE_FORM_FACTOR_AUTOMOTIVE"
    "DEVICE_FORM_FACTOR_DESKTOP"
    "DEVICE_FORM_FACTOR_PHONE"
    "DEVICE_FORM_FACTOR_TABLET"
    "DEVICE_FORM_FACTOR_TV"
    "DEVICE_FORM_FACTOR_UNSPECIFIED"
    "DEVICE_FORM_FACTOR_WEARABLE"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_DeviceFormFactor_entries[] = {
    {{&SyncEnums_DeviceFormFactor_names[0], 29}, 4},
    {{&SyncEnums_DeviceFormFactor_names[29], 26}, 1},
    {{&SyncEnums_DeviceFormFactor_names[55], 24}, 2},
    {{&SyncEnums_DeviceFormFactor_names[79], 25}, 3},
    {{&SyncEnums_DeviceFormFactor_names[104], 21}, 6},
    {{&SyncEnums_DeviceFormFactor_names[125], 30}, 0},
    {{&SyncEnums_DeviceFormFactor_names[155], 27}, 5},
};

static const int SyncEnums_DeviceFormFactor_entries_by_number[] = {
    5,  // 0 -> DEVICE_FORM_FACTOR_UNSPECIFIED
    1,  // 1 -> DEVICE_FORM_FACTOR_DESKTOP
    2,  // 2 -> DEVICE_FORM_FACTOR_PHONE
    3,  // 3 -> DEVICE_FORM_FACTOR_TABLET
    0,  // 4 -> DEVICE_FORM_FACTOR_AUTOMOTIVE
    6,  // 5 -> DEVICE_FORM_FACTOR_WEARABLE
    4,  // 6 -> DEVICE_FORM_FACTOR_TV
};

bool SyncEnums_DeviceFormFactor_Parse(::absl::string_view name,
                                  SyncEnums_DeviceFormFactor* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_DeviceFormFactor_entries, 7, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_DeviceFormFactor>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_DeviceFormFactor_strings[7] = {};

const ::std::string& SyncEnums_DeviceFormFactor_Name(SyncEnums_DeviceFormFactor value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_DeviceFormFactor_entries, SyncEnums_DeviceFormFactor_entries_by_number, 7,
      SyncEnums_DeviceFormFactor_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_DeviceFormFactor_entries,
                                  SyncEnums_DeviceFormFactor_entries_by_number,
                                  7, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_DeviceFormFactor_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_BrowserType_internal_data_[] = {
    327680u, 0u, };
static const char SyncEnums_BrowserType_names[] = {
    "BROWSER_TYPE_UNKNOWN"
    "TYPE_AUTH_TAB"
    "TYPE_CUSTOM_TAB"
    "TYPE_POPUP"
    "TYPE_TABBED"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_BrowserType_entries[] = {
    {{&SyncEnums_BrowserType_names[0], 20}, 0},
    {{&SyncEnums_BrowserType_names[20], 13}, 4},
    {{&SyncEnums_BrowserType_names[33], 15}, 3},
    {{&SyncEnums_BrowserType_names[48], 10}, 2},
    {{&SyncEnums_BrowserType_names[58], 11}, 1},
};

static const int SyncEnums_BrowserType_entries_by_number[] = {
    0,  // 0 -> BROWSER_TYPE_UNKNOWN
    4,  // 1 -> TYPE_TABBED
    3,  // 2 -> TYPE_POPUP
    2,  // 3 -> TYPE_CUSTOM_TAB
    1,  // 4 -> TYPE_AUTH_TAB
};

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

const ::std::string& SyncEnums_BrowserType_Name(SyncEnums_BrowserType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_BrowserType_entries, SyncEnums_BrowserType_entries_by_number, 5,
      SyncEnums_BrowserType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_BrowserType_entries,
                                  SyncEnums_BrowserType_entries_by_number,
                                  5, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_BrowserType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_PasswordState_internal_data_[] = {
    196608u, 0u, };
static const char SyncEnums_PasswordState_names[] = {
    "HAS_PASSWORD_FIELD"
    "NO_PASSWORD_FIELD"
    "PASSWORD_STATE_UNKNOWN"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_PasswordState_entries[] = {
    {{&SyncEnums_PasswordState_names[0], 18}, 2},
    {{&SyncEnums_PasswordState_names[18], 17}, 1},
    {{&SyncEnums_PasswordState_names[35], 22}, 0},
};

static const int SyncEnums_PasswordState_entries_by_number[] = {
    2,  // 0 -> PASSWORD_STATE_UNKNOWN
    1,  // 1 -> NO_PASSWORD_FIELD
    0,  // 2 -> HAS_PASSWORD_FIELD
};

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

const ::std::string& SyncEnums_PasswordState_Name(SyncEnums_PasswordState value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_PasswordState_entries, SyncEnums_PasswordState_entries_by_number, 3,
      SyncEnums_PasswordState_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_PasswordState_entries,
                                  SyncEnums_PasswordState_entries_by_number,
                                  3, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_PasswordState_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_GetUpdatesOrigin_internal_data_[] = {
    65536u, 32u, 27592u, };
static const char SyncEnums_GetUpdatesOrigin_names[] = {
    "DEVICE_STATISTICS_METRICS"
    "GU_TRIGGER"
    "MIGRATION"
    "NEWLY_SUPPORTED_DATATYPE"
    "NEW_CLIENT"
    "PERIODIC"
    "PROGRAMMATIC"
    "RECONFIGURATION"
    "UNKNOWN_ORIGIN"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_GetUpdatesOrigin_entries[] = {
    {{&SyncEnums_GetUpdatesOrigin_names[0], 25}, 15},
    {{&SyncEnums_GetUpdatesOrigin_names[25], 10}, 12},
    {{&SyncEnums_GetUpdatesOrigin_names[35], 9}, 8},
    {{&SyncEnums_GetUpdatesOrigin_names[44], 24}, 7},
    {{&SyncEnums_GetUpdatesOrigin_names[68], 10}, 9},
    {{&SyncEnums_GetUpdatesOrigin_names[78], 8}, 4},
    {{&SyncEnums_GetUpdatesOrigin_names[86], 12}, 14},
    {{&SyncEnums_GetUpdatesOrigin_names[98], 15}, 10},
    {{&SyncEnums_GetUpdatesOrigin_names[113], 14}, 0},
};

static const int SyncEnums_GetUpdatesOrigin_entries_by_number[] = {
    8,  // 0 -> UNKNOWN_ORIGIN
    5,  // 4 -> PERIODIC
    3,  // 7 -> NEWLY_SUPPORTED_DATATYPE
    2,  // 8 -> MIGRATION
    4,  // 9 -> NEW_CLIENT
    7,  // 10 -> RECONFIGURATION
    1,  // 12 -> GU_TRIGGER
    6,  // 14 -> PROGRAMMATIC
    0,  // 15 -> DEVICE_STATISTICS_METRICS
};

bool SyncEnums_GetUpdatesOrigin_Parse(::absl::string_view name,
                                  SyncEnums_GetUpdatesOrigin* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_GetUpdatesOrigin_entries, 9, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_GetUpdatesOrigin>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_GetUpdatesOrigin_strings[9] = {};

const ::std::string& SyncEnums_GetUpdatesOrigin_Name(SyncEnums_GetUpdatesOrigin value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_GetUpdatesOrigin_entries, SyncEnums_GetUpdatesOrigin_entries_by_number, 9,
      SyncEnums_GetUpdatesOrigin_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_GetUpdatesOrigin_entries,
                                  SyncEnums_GetUpdatesOrigin_entries_by_number,
                                  9, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_GetUpdatesOrigin_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_SendTabReceivingType_internal_data_[] = {
    131072u, 0u, };
static const char SyncEnums_SendTabReceivingType_names[] = {
    "SEND_TAB_RECEIVING_TYPE_CHROME_AND_PUSH_NOTIFICATION"
    "SEND_TAB_RECEIVING_TYPE_CHROME_OR_UNSPECIFIED"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_SendTabReceivingType_entries[] = {
    {{&SyncEnums_SendTabReceivingType_names[0], 52}, 1},
    {{&SyncEnums_SendTabReceivingType_names[52], 45}, 0},
};

static const int SyncEnums_SendTabReceivingType_entries_by_number[] = {
    1,  // 0 -> SEND_TAB_RECEIVING_TYPE_CHROME_OR_UNSPECIFIED
    0,  // 1 -> SEND_TAB_RECEIVING_TYPE_CHROME_AND_PUSH_NOTIFICATION
};

bool SyncEnums_SendTabReceivingType_Parse(::absl::string_view name,
                                  SyncEnums_SendTabReceivingType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_SendTabReceivingType_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_SendTabReceivingType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_SendTabReceivingType_strings[2] = {};

const ::std::string& SyncEnums_SendTabReceivingType_Name(SyncEnums_SendTabReceivingType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_SendTabReceivingType_entries, SyncEnums_SendTabReceivingType_entries_by_number, 2,
      SyncEnums_SendTabReceivingType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_SendTabReceivingType_entries,
                                  SyncEnums_SendTabReceivingType_entries_by_number,
                                  2, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_SendTabReceivingType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_MobilePromoOnDesktopPromoType_internal_data_[] = {
    393216u, 0u, };
static const char SyncEnums_MobilePromoOnDesktopPromoType_names[] = {
    "PROMO_TYPE_ALL"
    "PROMO_TYPE_AUTOFILL"
    "PROMO_TYPE_ESB"
    "PROMO_TYPE_LENS"
    "PROMO_TYPE_PRICE_TRACKING"
    "PROMO_TYPE_TAB_GROUPS"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_MobilePromoOnDesktopPromoType_entries[] = {
    {{&SyncEnums_MobilePromoOnDesktopPromoType_names[0], 14}, 0},
    {{&SyncEnums_MobilePromoOnDesktopPromoType_names[14], 19}, 3},
    {{&SyncEnums_MobilePromoOnDesktopPromoType_names[33], 14}, 2},
    {{&SyncEnums_MobilePromoOnDesktopPromoType_names[47], 15}, 1},
    {{&SyncEnums_MobilePromoOnDesktopPromoType_names[62], 25}, 5},
    {{&SyncEnums_MobilePromoOnDesktopPromoType_names[87], 21}, 4},
};

static const int SyncEnums_MobilePromoOnDesktopPromoType_entries_by_number[] = {
    0,  // 0 -> PROMO_TYPE_ALL
    3,  // 1 -> PROMO_TYPE_LENS
    2,  // 2 -> PROMO_TYPE_ESB
    1,  // 3 -> PROMO_TYPE_AUTOFILL
    5,  // 4 -> PROMO_TYPE_TAB_GROUPS
    4,  // 5 -> PROMO_TYPE_PRICE_TRACKING
};

bool SyncEnums_MobilePromoOnDesktopPromoType_Parse(::absl::string_view name,
                                  SyncEnums_MobilePromoOnDesktopPromoType* PROTOBUF_NONNULL value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SyncEnums_MobilePromoOnDesktopPromoType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<SyncEnums_MobilePromoOnDesktopPromoType>(int_value);
  }
  return success;
}
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
    SyncEnums_MobilePromoOnDesktopPromoType_strings[6] = {};

const ::std::string& SyncEnums_MobilePromoOnDesktopPromoType_Name(SyncEnums_MobilePromoOnDesktopPromoType value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_MobilePromoOnDesktopPromoType_entries, SyncEnums_MobilePromoOnDesktopPromoType_entries_by_number, 6,
      SyncEnums_MobilePromoOnDesktopPromoType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(SyncEnums_MobilePromoOnDesktopPromoType_entries,
                                  SyncEnums_MobilePromoOnDesktopPromoType_entries_by_number,
                                  6, value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncEnums_MobilePromoOnDesktopPromoType_strings[idx].get();
}
PROTOBUF_CONSTINIT const uint32_t SyncEnums_GlicExperimentalTriggeringState_internal_data_[] = {
    196608u, 0u, };
static const char SyncEnums_GlicExperimentalTriggeringState_names[] = {
    "NEEDS_OPT_IN"
    "READY"
    "UNAVAILABLE"
};

static const ::google::protobuf::internal::EnumEntry SyncEnums_GlicExperimentalTriggeringState_entries[] = {
    {{&SyncEnums_GlicExperimentalTriggeringState_names[0], 12}, 1},
    {{&SyncEnums_GlicExperimentalTriggeringState_names[12], 5}, 2},
    {{&SyncEnums_GlicExperimentalTriggeringState_names[17], 11}, 0},
};

static const int SyncEnums_GlicExperimentalTriggeringState_entries_by_number[] = {
    2,  // 0 -> UNAVAILABLE
    0,  // 1 -> NEEDS_OPT_IN
    1,  // 2 -> READY
};

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

const ::std::string& SyncEnums_GlicExperimentalTriggeringState_Name(SyncEnums_GlicExperimentalTriggeringState value) {
  static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
      SyncEnums_GlicExperimentalTriggeringState_entries, SyncEnums_GlicExperimentalTriggeringState_entries_by_number, 3,
      SyncEnums_GlicExperimentalTriggeringState_strings);
  (void)kDummy;

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

SyncEnums::SyncEnums(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SyncEnums_get_class_data()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::MessageLite(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:sync_pb.SyncEnums)
}
SyncEnums::SyncEnums(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SyncEnums& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::MessageLite(arena, SyncEnums_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 SyncEnums::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}

inline void SyncEnums::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
SyncEnums::~SyncEnums() {
  // @@protoc_insertion_point(destructor:sync_pb.SyncEnums)
  SharedDtor(*this);
}
inline void SyncEnums::SharedDtor(MessageLite& self) {
  SyncEnums& this_ = static_cast<SyncEnums&>(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 SyncEnums_class_data_ =
    SyncEnums::InternalGenerateClassData_(SyncEnums_globals_._default);

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

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

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

  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:sync_pb.SyncEnums)
  return target;
}

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

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

  if (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 SyncEnums::MergeImpl(::google::protobuf::MessageLite& to_msg,
                      const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this = static_cast<SyncEnums*>(&to_msg);
  auto& from = static_cast<const SyncEnums&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.SyncEnums)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

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

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


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

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