/src/gdal/frmts/icechunk/generated/repo_generated.h

Source
// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_REPO_GENERATED_H_
#define FLATBUFFERS_GENERATED_REPO_GENERATED_H_

#include "flatbuffers/flatbuffers.h"
#include "flatbuffers/flexbuffers.h"
#include "flatbuffers/flex_flat_util.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
              FLATBUFFERS_VERSION_MINOR == 0 &&
              FLATBUFFERS_VERSION_REVISION == 8,
             "Non-compatible flatbuffers version included");

#include "common_generated.h"

namespace generated {

struct Ref;
struct RefBuilder;

struct SnapshotInfo;
struct SnapshotInfoBuilder;

struct RepoStatus;
struct RepoStatusBuilder;

struct RepoInitializedUpdate;
struct RepoInitializedUpdateBuilder;

struct RepoMigratedUpdate;
struct RepoMigratedUpdateBuilder;

struct RepoStatusChangedUpdate;
struct RepoStatusChangedUpdateBuilder;

struct ConfigChangedUpdate;
struct ConfigChangedUpdateBuilder;

struct MetadataChangedUpdate;
struct MetadataChangedUpdateBuilder;

struct TagCreatedUpdate;
struct TagCreatedUpdateBuilder;

struct TagDeletedUpdate;
struct TagDeletedUpdateBuilder;

struct BranchCreatedUpdate;
struct BranchCreatedUpdateBuilder;

struct BranchDeletedUpdate;
struct BranchDeletedUpdateBuilder;

struct BranchResetUpdate;
struct BranchResetUpdateBuilder;

struct NewCommitUpdate;
struct NewCommitUpdateBuilder;

struct CommitAmendedUpdate;
struct CommitAmendedUpdateBuilder;

struct NewDetachedSnapshotUpdate;
struct NewDetachedSnapshotUpdateBuilder;

struct GCRanUpdate;
struct GCRanUpdateBuilder;

struct ExpirationRanUpdate;
struct ExpirationRanUpdateBuilder;

struct FeatureFlagChangedUpdate;
struct FeatureFlagChangedUpdateBuilder;

struct Update;
struct UpdateBuilder;

struct Repo;
struct RepoBuilder;

enum class RepoAvailability : uint8_t {
  Online = 0,
  ReadOnly = 1,
  Offline = 2,
  MIN = Online,
  MAX = Offline
};

inline const RepoAvailability (&EnumValuesRepoAvailability())[3] {
  static const RepoAvailability values[] = {
    RepoAvailability::Online,
    RepoAvailability::ReadOnly,
    RepoAvailability::Offline
  };
  return values;
}

inline const char * const *EnumNamesRepoAvailability() {
  static const char * const names[4] = {
    "Online",
    "ReadOnly",
    "Offline",
    nullptr
  };
  return names;
}

inline const char *EnumNameRepoAvailability(RepoAvailability e) {
  if (flatbuffers::IsOutRange(e, RepoAvailability::Online, RepoAvailability::Offline)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesRepoAvailability()[index];
}

enum class UpdateType : uint8_t {
  NONE = 0,
  RepoInitializedUpdate = 1,
  RepoMigratedUpdate = 2,
  ConfigChangedUpdate = 3,
  MetadataChangedUpdate = 4,
  TagCreatedUpdate = 5,
  TagDeletedUpdate = 6,
  BranchCreatedUpdate = 7,
  BranchDeletedUpdate = 8,
  BranchResetUpdate = 9,
  NewCommitUpdate = 10,
  CommitAmendedUpdate = 11,
  NewDetachedSnapshotUpdate = 12,
  GCRanUpdate = 13,
  ExpirationRanUpdate = 14,
  FeatureFlagChangedUpdate = 15,
  RepoStatusChangedUpdate = 16,
  MIN = NONE,
  MAX = RepoStatusChangedUpdate
};

inline const UpdateType (&EnumValuesUpdateType())[17] {
  static const UpdateType values[] = {
    UpdateType::NONE,
    UpdateType::RepoInitializedUpdate,
    UpdateType::RepoMigratedUpdate,
    UpdateType::ConfigChangedUpdate,
    UpdateType::MetadataChangedUpdate,
    UpdateType::TagCreatedUpdate,
    UpdateType::TagDeletedUpdate,
    UpdateType::BranchCreatedUpdate,
    UpdateType::BranchDeletedUpdate,
    UpdateType::BranchResetUpdate,
    UpdateType::NewCommitUpdate,
    UpdateType::CommitAmendedUpdate,
    UpdateType::NewDetachedSnapshotUpdate,
    UpdateType::GCRanUpdate,
    UpdateType::ExpirationRanUpdate,
    UpdateType::FeatureFlagChangedUpdate,
    UpdateType::RepoStatusChangedUpdate
  };
  return values;
}

inline const char * const *EnumNamesUpdateType() {
  static const char * const names[18] = {
    "NONE",
    "RepoInitializedUpdate",
    "RepoMigratedUpdate",
    "ConfigChangedUpdate",
    "MetadataChangedUpdate",
    "TagCreatedUpdate",
    "TagDeletedUpdate",
    "BranchCreatedUpdate",
    "BranchDeletedUpdate",
    "BranchResetUpdate",
    "NewCommitUpdate",
    "CommitAmendedUpdate",
    "NewDetachedSnapshotUpdate",
    "GCRanUpdate",
    "ExpirationRanUpdate",
    "FeatureFlagChangedUpdate",
    "RepoStatusChangedUpdate",
    nullptr
  };
  return names;
}

inline const char *EnumNameUpdateType(UpdateType e) {
  if (flatbuffers::IsOutRange(e, UpdateType::NONE, UpdateType::RepoStatusChangedUpdate)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesUpdateType()[index];
}

template<typename T> struct UpdateTypeTraits {
  static const UpdateType enum_value = UpdateType::NONE;
};

template<> struct UpdateTypeTraits<generated::RepoInitializedUpdate> {
  static const UpdateType enum_value = UpdateType::RepoInitializedUpdate;
};

template<> struct UpdateTypeTraits<generated::RepoMigratedUpdate> {
  static const UpdateType enum_value = UpdateType::RepoMigratedUpdate;
};

template<> struct UpdateTypeTraits<generated::ConfigChangedUpdate> {
  static const UpdateType enum_value = UpdateType::ConfigChangedUpdate;
};

template<> struct UpdateTypeTraits<generated::MetadataChangedUpdate> {
  static const UpdateType enum_value = UpdateType::MetadataChangedUpdate;
};

template<> struct UpdateTypeTraits<generated::TagCreatedUpdate> {
  static const UpdateType enum_value = UpdateType::TagCreatedUpdate;
};

template<> struct UpdateTypeTraits<generated::TagDeletedUpdate> {
  static const UpdateType enum_value = UpdateType::TagDeletedUpdate;
};

template<> struct UpdateTypeTraits<generated::BranchCreatedUpdate> {
  static const UpdateType enum_value = UpdateType::BranchCreatedUpdate;
};

template<> struct UpdateTypeTraits<generated::BranchDeletedUpdate> {
  static const UpdateType enum_value = UpdateType::BranchDeletedUpdate;
};

template<> struct UpdateTypeTraits<generated::BranchResetUpdate> {
  static const UpdateType enum_value = UpdateType::BranchResetUpdate;
};

template<> struct UpdateTypeTraits<generated::NewCommitUpdate> {
  static const UpdateType enum_value = UpdateType::NewCommitUpdate;
};

template<> struct UpdateTypeTraits<generated::CommitAmendedUpdate> {
  static const UpdateType enum_value = UpdateType::CommitAmendedUpdate;
};

template<> struct UpdateTypeTraits<generated::NewDetachedSnapshotUpdate> {
  static const UpdateType enum_value = UpdateType::NewDetachedSnapshotUpdate;
};

template<> struct UpdateTypeTraits<generated::GCRanUpdate> {
  static const UpdateType enum_value = UpdateType::GCRanUpdate;
};

template<> struct UpdateTypeTraits<generated::ExpirationRanUpdate> {
  static const UpdateType enum_value = UpdateType::ExpirationRanUpdate;
};

template<> struct UpdateTypeTraits<generated::FeatureFlagChangedUpdate> {
  static const UpdateType enum_value = UpdateType::FeatureFlagChangedUpdate;
};

template<> struct UpdateTypeTraits<generated::RepoStatusChangedUpdate> {
  static const UpdateType enum_value = UpdateType::RepoStatusChangedUpdate;
};

bool VerifyUpdateType(flatbuffers::Verifier &verifier, const void *obj, UpdateType type);
bool VerifyUpdateTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<UpdateType> *types);

struct Ref FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_SNAPSHOT_INDEX = 6
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  uint32_t snapshot_index() const {
    return GetField<uint32_t>(VT_SNAPSHOT_INDEX, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint32_t>(verifier, VT_SNAPSHOT_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct RefBuilder {
  typedef Ref Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(Ref::VT_NAME, name);
  }
  void add_snapshot_index(uint32_t snapshot_index) {
    fbb_.AddElement<uint32_t>(Ref::VT_SNAPSHOT_INDEX, snapshot_index, 0);
  }
  explicit RefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<Ref> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Ref>(end);
    fbb_.Required(o, Ref::VT_NAME);
    return o;
  }
};

inline flatbuffers::Offset<Ref> CreateRef(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    uint32_t snapshot_index = 0) {
  RefBuilder builder_(_fbb);
  builder_.add_snapshot_index(snapshot_index);
  builder_.add_name(name);
  return builder_.Finish();
}

struct Ref::Traits {
  using type = Ref;
  static auto constexpr Create = CreateRef;
};

inline flatbuffers::Offset<Ref> CreateRefDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    uint32_t snapshot_index = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateRef(
      _fbb,
      name__,
      snapshot_index);
}

struct SnapshotInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SnapshotInfoBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_PARENT_OFFSET = 6,
    VT_FLUSHED_AT = 8,
    VT_MESSAGE = 10,
    VT_METADATA = 12
  };
  const generated::ObjectId12 *id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_ID);
  }
  int32_t parent_offset() const {
    return GetField<int32_t>(VT_PARENT_OFFSET, 0);
  }
  uint64_t flushed_at() const {
    return GetField<uint64_t>(VT_FLUSHED_AT, 0);
  }
  const flatbuffers::String *message() const {
    return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>> *metadata() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>> *>(VT_METADATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_ID, 1) &&
           VerifyField<int32_t>(verifier, VT_PARENT_OFFSET, 4) &&
           VerifyField<uint64_t>(verifier, VT_FLUSHED_AT, 8) &&
           VerifyOffsetRequired(verifier, VT_MESSAGE) &&
           verifier.VerifyString(message()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyVector(metadata()) &&
           verifier.VerifyVectorOfTables(metadata()) &&
           verifier.EndTable();
  }
};

struct SnapshotInfoBuilder {
  typedef SnapshotInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(const generated::ObjectId12 *id) {
    fbb_.AddStruct(SnapshotInfo::VT_ID, id);
  }
  void add_parent_offset(int32_t parent_offset) {
    fbb_.AddElement<int32_t>(SnapshotInfo::VT_PARENT_OFFSET, parent_offset, 0);
  }
  void add_flushed_at(uint64_t flushed_at) {
    fbb_.AddElement<uint64_t>(SnapshotInfo::VT_FLUSHED_AT, flushed_at, 0);
  }
  void add_message(flatbuffers::Offset<flatbuffers::String> message) {
    fbb_.AddOffset(SnapshotInfo::VT_MESSAGE, message);
  }
  void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>>> metadata) {
    fbb_.AddOffset(SnapshotInfo::VT_METADATA, metadata);
  }
  explicit SnapshotInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SnapshotInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SnapshotInfo>(end);
    fbb_.Required(o, SnapshotInfo::VT_ID);
    fbb_.Required(o, SnapshotInfo::VT_MESSAGE);
    return o;
  }
};

inline flatbuffers::Offset<SnapshotInfo> CreateSnapshotInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *id = nullptr,
    int32_t parent_offset = 0,
    uint64_t flushed_at = 0,
    flatbuffers::Offset<flatbuffers::String> message = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>>> metadata = 0) {
  SnapshotInfoBuilder builder_(_fbb);
  builder_.add_flushed_at(flushed_at);
  builder_.add_metadata(metadata);
  builder_.add_message(message);
  builder_.add_parent_offset(parent_offset);
  builder_.add_id(id);
  return builder_.Finish();
}

struct SnapshotInfo::Traits {
  using type = SnapshotInfo;
  static auto constexpr Create = CreateSnapshotInfo;
};

inline flatbuffers::Offset<SnapshotInfo> CreateSnapshotInfoDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *id = nullptr,
    int32_t parent_offset = 0,
    uint64_t flushed_at = 0,
    const char *message = nullptr,
    const std::vector<flatbuffers::Offset<generated::MetadataItem>> *metadata = nullptr) {
  auto message__ = message ? _fbb.CreateString(message) : 0;
  auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<generated::MetadataItem>>(*metadata) : 0;
  return generated::CreateSnapshotInfo(
      _fbb,
      id,
      parent_offset,
      flushed_at,
      message__,
      metadata__);
}

struct RepoStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RepoStatusBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_AVAILABILITY = 4,
    VT_SET_AT = 6,
    VT_LIMITED_AVAILABILITY_REASON = 8
  };
  generated::RepoAvailability availability() const {
    return static_cast<generated::RepoAvailability>(GetField<uint8_t>(VT_AVAILABILITY, 0));
  }
  uint64_t set_at() const {
    return GetField<uint64_t>(VT_SET_AT, 0);
  }
  const flatbuffers::String *limited_availability_reason() const {
    return GetPointer<const flatbuffers::String *>(VT_LIMITED_AVAILABILITY_REASON);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_AVAILABILITY, 1) &&
           VerifyField<uint64_t>(verifier, VT_SET_AT, 8) &&
           VerifyOffset(verifier, VT_LIMITED_AVAILABILITY_REASON) &&
           verifier.VerifyString(limited_availability_reason()) &&
           verifier.EndTable();
  }
};

struct RepoStatusBuilder {
  typedef RepoStatus Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_availability(generated::RepoAvailability availability) {
    fbb_.AddElement<uint8_t>(RepoStatus::VT_AVAILABILITY, static_cast<uint8_t>(availability), 0);
  }
  void add_set_at(uint64_t set_at) {
    fbb_.AddElement<uint64_t>(RepoStatus::VT_SET_AT, set_at, 0);
  }
  void add_limited_availability_reason(flatbuffers::Offset<flatbuffers::String> limited_availability_reason) {
    fbb_.AddOffset(RepoStatus::VT_LIMITED_AVAILABILITY_REASON, limited_availability_reason);
  }
  explicit RepoStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RepoStatus> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RepoStatus>(end);
    return o;
  }
};

inline flatbuffers::Offset<RepoStatus> CreateRepoStatus(
    flatbuffers::FlatBufferBuilder &_fbb,
    generated::RepoAvailability availability = generated::RepoAvailability::Online,
    uint64_t set_at = 0,
    flatbuffers::Offset<flatbuffers::String> limited_availability_reason = 0) {
  RepoStatusBuilder builder_(_fbb);
  builder_.add_set_at(set_at);
  builder_.add_limited_availability_reason(limited_availability_reason);
  builder_.add_availability(availability);
  return builder_.Finish();
}

struct RepoStatus::Traits {
  using type = RepoStatus;
  static auto constexpr Create = CreateRepoStatus;
};

inline flatbuffers::Offset<RepoStatus> CreateRepoStatusDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    generated::RepoAvailability availability = generated::RepoAvailability::Online,
    uint64_t set_at = 0,
    const char *limited_availability_reason = nullptr) {
  auto limited_availability_reason__ = limited_availability_reason ? _fbb.CreateString(limited_availability_reason) : 0;
  return generated::CreateRepoStatus(
      _fbb,
      availability,
      set_at,
      limited_availability_reason__);
}

struct RepoInitializedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RepoInitializedUpdateBuilder Builder;
  struct Traits;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct RepoInitializedUpdateBuilder {
  typedef RepoInitializedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit RepoInitializedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RepoInitializedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RepoInitializedUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<RepoInitializedUpdate> CreateRepoInitializedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb) {
  RepoInitializedUpdateBuilder builder_(_fbb);
  return builder_.Finish();
}

struct RepoInitializedUpdate::Traits {
  using type = RepoInitializedUpdate;
  static auto constexpr Create = CreateRepoInitializedUpdate;
};

struct RepoMigratedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RepoMigratedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FROM_VERSION = 4,
    VT_TO_VERSION = 6
  };
  uint8_t from_version() const {
    return GetField<uint8_t>(VT_FROM_VERSION, 0);
  }
  uint8_t to_version() const {
    return GetField<uint8_t>(VT_TO_VERSION, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_FROM_VERSION, 1) &&
           VerifyField<uint8_t>(verifier, VT_TO_VERSION, 1) &&
           verifier.EndTable();
  }
};

struct RepoMigratedUpdateBuilder {
  typedef RepoMigratedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_from_version(uint8_t from_version) {
    fbb_.AddElement<uint8_t>(RepoMigratedUpdate::VT_FROM_VERSION, from_version, 0);
  }
  void add_to_version(uint8_t to_version) {
    fbb_.AddElement<uint8_t>(RepoMigratedUpdate::VT_TO_VERSION, to_version, 0);
  }
  explicit RepoMigratedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RepoMigratedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RepoMigratedUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<RepoMigratedUpdate> CreateRepoMigratedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t from_version = 0,
    uint8_t to_version = 0) {
  RepoMigratedUpdateBuilder builder_(_fbb);
  builder_.add_to_version(to_version);
  builder_.add_from_version(from_version);
  return builder_.Finish();
}

struct RepoMigratedUpdate::Traits {
  using type = RepoMigratedUpdate;
  static auto constexpr Create = CreateRepoMigratedUpdate;
};

struct RepoStatusChangedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RepoStatusChangedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STATUS = 4
  };
  const generated::RepoStatus *status() const {
    return GetPointer<const generated::RepoStatus *>(VT_STATUS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_STATUS) &&
           verifier.VerifyTable(status()) &&
           verifier.EndTable();
  }
};

struct RepoStatusChangedUpdateBuilder {
  typedef RepoStatusChangedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_status(flatbuffers::Offset<generated::RepoStatus> status) {
    fbb_.AddOffset(RepoStatusChangedUpdate::VT_STATUS, status);
  }
  explicit RepoStatusChangedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RepoStatusChangedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RepoStatusChangedUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<RepoStatusChangedUpdate> CreateRepoStatusChangedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<generated::RepoStatus> status = 0) {
  RepoStatusChangedUpdateBuilder builder_(_fbb);
  builder_.add_status(status);
  return builder_.Finish();
}

struct RepoStatusChangedUpdate::Traits {
  using type = RepoStatusChangedUpdate;
  static auto constexpr Create = CreateRepoStatusChangedUpdate;
};

struct ConfigChangedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ConfigChangedUpdateBuilder Builder;
  struct Traits;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ConfigChangedUpdateBuilder {
  typedef ConfigChangedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit ConfigChangedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ConfigChangedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ConfigChangedUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<ConfigChangedUpdate> CreateConfigChangedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb) {
  ConfigChangedUpdateBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ConfigChangedUpdate::Traits {
  using type = ConfigChangedUpdate;
  static auto constexpr Create = CreateConfigChangedUpdate;
};

struct MetadataChangedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MetadataChangedUpdateBuilder Builder;
  struct Traits;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct MetadataChangedUpdateBuilder {
  typedef MetadataChangedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit MetadataChangedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<MetadataChangedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<MetadataChangedUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<MetadataChangedUpdate> CreateMetadataChangedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb) {
  MetadataChangedUpdateBuilder builder_(_fbb);
  return builder_.Finish();
}

struct MetadataChangedUpdate::Traits {
  using type = MetadataChangedUpdate;
  static auto constexpr Create = CreateMetadataChangedUpdate;
};

struct TagCreatedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TagCreatedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};

struct TagCreatedUpdateBuilder {
  typedef TagCreatedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(TagCreatedUpdate::VT_NAME, name);
  }
  explicit TagCreatedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<TagCreatedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TagCreatedUpdate>(end);
    fbb_.Required(o, TagCreatedUpdate::VT_NAME);
    return o;
  }
};

inline flatbuffers::Offset<TagCreatedUpdate> CreateTagCreatedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0) {
  TagCreatedUpdateBuilder builder_(_fbb);
  builder_.add_name(name);
  return builder_.Finish();
}

struct TagCreatedUpdate::Traits {
  using type = TagCreatedUpdate;
  static auto constexpr Create = CreateTagCreatedUpdate;
};

inline flatbuffers::Offset<TagCreatedUpdate> CreateTagCreatedUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateTagCreatedUpdate(
      _fbb,
      name__);
}

struct TagDeletedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TagDeletedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_PREVIOUS_SNAP_ID = 6
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  const generated::ObjectId12 *previous_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_PREVIOUS_SNAP_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_PREVIOUS_SNAP_ID, 1) &&
           verifier.EndTable();
  }
};

struct TagDeletedUpdateBuilder {
  typedef TagDeletedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(TagDeletedUpdate::VT_NAME, name);
  }
  void add_previous_snap_id(const generated::ObjectId12 *previous_snap_id) {
    fbb_.AddStruct(TagDeletedUpdate::VT_PREVIOUS_SNAP_ID, previous_snap_id);
  }
  explicit TagDeletedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<TagDeletedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TagDeletedUpdate>(end);
    fbb_.Required(o, TagDeletedUpdate::VT_NAME);
    fbb_.Required(o, TagDeletedUpdate::VT_PREVIOUS_SNAP_ID);
    return o;
  }
};

inline flatbuffers::Offset<TagDeletedUpdate> CreateTagDeletedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    const generated::ObjectId12 *previous_snap_id = nullptr) {
  TagDeletedUpdateBuilder builder_(_fbb);
  builder_.add_previous_snap_id(previous_snap_id);
  builder_.add_name(name);
  return builder_.Finish();
}

struct TagDeletedUpdate::Traits {
  using type = TagDeletedUpdate;
  static auto constexpr Create = CreateTagDeletedUpdate;
};

inline flatbuffers::Offset<TagDeletedUpdate> CreateTagDeletedUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const generated::ObjectId12 *previous_snap_id = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateTagDeletedUpdate(
      _fbb,
      name__,
      previous_snap_id);
}

struct BranchCreatedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BranchCreatedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};

struct BranchCreatedUpdateBuilder {
  typedef BranchCreatedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(BranchCreatedUpdate::VT_NAME, name);
  }
  explicit BranchCreatedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BranchCreatedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BranchCreatedUpdate>(end);
    fbb_.Required(o, BranchCreatedUpdate::VT_NAME);
    return o;
  }
};

inline flatbuffers::Offset<BranchCreatedUpdate> CreateBranchCreatedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0) {
  BranchCreatedUpdateBuilder builder_(_fbb);
  builder_.add_name(name);
  return builder_.Finish();
}

struct BranchCreatedUpdate::Traits {
  using type = BranchCreatedUpdate;
  static auto constexpr Create = CreateBranchCreatedUpdate;
};

inline flatbuffers::Offset<BranchCreatedUpdate> CreateBranchCreatedUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateBranchCreatedUpdate(
      _fbb,
      name__);
}

struct BranchDeletedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BranchDeletedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_PREVIOUS_SNAP_ID = 6
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  const generated::ObjectId12 *previous_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_PREVIOUS_SNAP_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_PREVIOUS_SNAP_ID, 1) &&
           verifier.EndTable();
  }
};

struct BranchDeletedUpdateBuilder {
  typedef BranchDeletedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(BranchDeletedUpdate::VT_NAME, name);
  }
  void add_previous_snap_id(const generated::ObjectId12 *previous_snap_id) {
    fbb_.AddStruct(BranchDeletedUpdate::VT_PREVIOUS_SNAP_ID, previous_snap_id);
  }
  explicit BranchDeletedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BranchDeletedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BranchDeletedUpdate>(end);
    fbb_.Required(o, BranchDeletedUpdate::VT_NAME);
    fbb_.Required(o, BranchDeletedUpdate::VT_PREVIOUS_SNAP_ID);
    return o;
  }
};

inline flatbuffers::Offset<BranchDeletedUpdate> CreateBranchDeletedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    const generated::ObjectId12 *previous_snap_id = nullptr) {
  BranchDeletedUpdateBuilder builder_(_fbb);
  builder_.add_previous_snap_id(previous_snap_id);
  builder_.add_name(name);
  return builder_.Finish();
}

struct BranchDeletedUpdate::Traits {
  using type = BranchDeletedUpdate;
  static auto constexpr Create = CreateBranchDeletedUpdate;
};

inline flatbuffers::Offset<BranchDeletedUpdate> CreateBranchDeletedUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const generated::ObjectId12 *previous_snap_id = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateBranchDeletedUpdate(
      _fbb,
      name__,
      previous_snap_id);
}

struct BranchResetUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BranchResetUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_PREVIOUS_SNAP_ID = 6
  };
  const flatbuffers::String *name() const {
    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
  const generated::ObjectId12 *previous_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_PREVIOUS_SNAP_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_PREVIOUS_SNAP_ID, 1) &&
           verifier.EndTable();
  }
};

struct BranchResetUpdateBuilder {
  typedef BranchResetUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
    fbb_.AddOffset(BranchResetUpdate::VT_NAME, name);
  }
  void add_previous_snap_id(const generated::ObjectId12 *previous_snap_id) {
    fbb_.AddStruct(BranchResetUpdate::VT_PREVIOUS_SNAP_ID, previous_snap_id);
  }
  explicit BranchResetUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BranchResetUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BranchResetUpdate>(end);
    fbb_.Required(o, BranchResetUpdate::VT_NAME);
    fbb_.Required(o, BranchResetUpdate::VT_PREVIOUS_SNAP_ID);
    return o;
  }
};

inline flatbuffers::Offset<BranchResetUpdate> CreateBranchResetUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    const generated::ObjectId12 *previous_snap_id = nullptr) {
  BranchResetUpdateBuilder builder_(_fbb);
  builder_.add_previous_snap_id(previous_snap_id);
  builder_.add_name(name);
  return builder_.Finish();
}

struct BranchResetUpdate::Traits {
  using type = BranchResetUpdate;
  static auto constexpr Create = CreateBranchResetUpdate;
};

inline flatbuffers::Offset<BranchResetUpdate> CreateBranchResetUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const generated::ObjectId12 *previous_snap_id = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return generated::CreateBranchResetUpdate(
      _fbb,
      name__,
      previous_snap_id);
}

struct NewCommitUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NewCommitUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BRANCH = 4,
    VT_NEW_SNAP_ID = 6
  };
  const flatbuffers::String *branch() const {
    return GetPointer<const flatbuffers::String *>(VT_BRANCH);
  }
  const generated::ObjectId12 *new_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_NEW_SNAP_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BRANCH) &&
           verifier.VerifyString(branch()) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_NEW_SNAP_ID, 1) &&
           verifier.EndTable();
  }
};

struct NewCommitUpdateBuilder {
  typedef NewCommitUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_branch(flatbuffers::Offset<flatbuffers::String> branch) {
    fbb_.AddOffset(NewCommitUpdate::VT_BRANCH, branch);
  }
  void add_new_snap_id(const generated::ObjectId12 *new_snap_id) {
    fbb_.AddStruct(NewCommitUpdate::VT_NEW_SNAP_ID, new_snap_id);
  }
  explicit NewCommitUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<NewCommitUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NewCommitUpdate>(end);
    fbb_.Required(o, NewCommitUpdate::VT_BRANCH);
    fbb_.Required(o, NewCommitUpdate::VT_NEW_SNAP_ID);
    return o;
  }
};

inline flatbuffers::Offset<NewCommitUpdate> CreateNewCommitUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> branch = 0,
    const generated::ObjectId12 *new_snap_id = nullptr) {
  NewCommitUpdateBuilder builder_(_fbb);
  builder_.add_new_snap_id(new_snap_id);
  builder_.add_branch(branch);
  return builder_.Finish();
}

struct NewCommitUpdate::Traits {
  using type = NewCommitUpdate;
  static auto constexpr Create = CreateNewCommitUpdate;
};

inline flatbuffers::Offset<NewCommitUpdate> CreateNewCommitUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *branch = nullptr,
    const generated::ObjectId12 *new_snap_id = nullptr) {
  auto branch__ = branch ? _fbb.CreateString(branch) : 0;
  return generated::CreateNewCommitUpdate(
      _fbb,
      branch__,
      new_snap_id);
}

struct CommitAmendedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef CommitAmendedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BRANCH = 4,
    VT_PREVIOUS_SNAP_ID = 6,
    VT_NEW_SNAP_ID = 8
  };
  const flatbuffers::String *branch() const {
    return GetPointer<const flatbuffers::String *>(VT_BRANCH);
  }
  const generated::ObjectId12 *previous_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_PREVIOUS_SNAP_ID);
  }
  const generated::ObjectId12 *new_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_NEW_SNAP_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BRANCH) &&
           verifier.VerifyString(branch()) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_PREVIOUS_SNAP_ID, 1) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_NEW_SNAP_ID, 1) &&
           verifier.EndTable();
  }
};

struct CommitAmendedUpdateBuilder {
  typedef CommitAmendedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_branch(flatbuffers::Offset<flatbuffers::String> branch) {
    fbb_.AddOffset(CommitAmendedUpdate::VT_BRANCH, branch);
  }
  void add_previous_snap_id(const generated::ObjectId12 *previous_snap_id) {
    fbb_.AddStruct(CommitAmendedUpdate::VT_PREVIOUS_SNAP_ID, previous_snap_id);
  }
  void add_new_snap_id(const generated::ObjectId12 *new_snap_id) {
    fbb_.AddStruct(CommitAmendedUpdate::VT_NEW_SNAP_ID, new_snap_id);
  }
  explicit CommitAmendedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<CommitAmendedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<CommitAmendedUpdate>(end);
    fbb_.Required(o, CommitAmendedUpdate::VT_BRANCH);
    fbb_.Required(o, CommitAmendedUpdate::VT_PREVIOUS_SNAP_ID);
    fbb_.Required(o, CommitAmendedUpdate::VT_NEW_SNAP_ID);
    return o;
  }
};

inline flatbuffers::Offset<CommitAmendedUpdate> CreateCommitAmendedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> branch = 0,
    const generated::ObjectId12 *previous_snap_id = nullptr,
    const generated::ObjectId12 *new_snap_id = nullptr) {
  CommitAmendedUpdateBuilder builder_(_fbb);
  builder_.add_new_snap_id(new_snap_id);
  builder_.add_previous_snap_id(previous_snap_id);
  builder_.add_branch(branch);
  return builder_.Finish();
}

struct CommitAmendedUpdate::Traits {
  using type = CommitAmendedUpdate;
  static auto constexpr Create = CreateCommitAmendedUpdate;
};

inline flatbuffers::Offset<CommitAmendedUpdate> CreateCommitAmendedUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *branch = nullptr,
    const generated::ObjectId12 *previous_snap_id = nullptr,
    const generated::ObjectId12 *new_snap_id = nullptr) {
  auto branch__ = branch ? _fbb.CreateString(branch) : 0;
  return generated::CreateCommitAmendedUpdate(
      _fbb,
      branch__,
      previous_snap_id,
      new_snap_id);
}

struct NewDetachedSnapshotUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NewDetachedSnapshotUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NEW_SNAP_ID = 4
  };
  const generated::ObjectId12 *new_snap_id() const {
    return GetStruct<const generated::ObjectId12 *>(VT_NEW_SNAP_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyFieldRequired<generated::ObjectId12>(verifier, VT_NEW_SNAP_ID, 1) &&
           verifier.EndTable();
  }
};

struct NewDetachedSnapshotUpdateBuilder {
  typedef NewDetachedSnapshotUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_new_snap_id(const generated::ObjectId12 *new_snap_id) {
    fbb_.AddStruct(NewDetachedSnapshotUpdate::VT_NEW_SNAP_ID, new_snap_id);
  }
  explicit NewDetachedSnapshotUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<NewDetachedSnapshotUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NewDetachedSnapshotUpdate>(end);
    fbb_.Required(o, NewDetachedSnapshotUpdate::VT_NEW_SNAP_ID);
    return o;
  }
};

inline flatbuffers::Offset<NewDetachedSnapshotUpdate> CreateNewDetachedSnapshotUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    const generated::ObjectId12 *new_snap_id = nullptr) {
  NewDetachedSnapshotUpdateBuilder builder_(_fbb);
  builder_.add_new_snap_id(new_snap_id);
  return builder_.Finish();
}

struct NewDetachedSnapshotUpdate::Traits {
  using type = NewDetachedSnapshotUpdate;
  static auto constexpr Create = CreateNewDetachedSnapshotUpdate;
};

struct GCRanUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GCRanUpdateBuilder Builder;
  struct Traits;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct GCRanUpdateBuilder {
  typedef GCRanUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit GCRanUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GCRanUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GCRanUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<GCRanUpdate> CreateGCRanUpdate(
    flatbuffers::FlatBufferBuilder &_fbb) {
  GCRanUpdateBuilder builder_(_fbb);
  return builder_.Finish();
}

struct GCRanUpdate::Traits {
  using type = GCRanUpdate;
  static auto constexpr Create = CreateGCRanUpdate;
};

struct ExpirationRanUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ExpirationRanUpdateBuilder Builder;
  struct Traits;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ExpirationRanUpdateBuilder {
  typedef ExpirationRanUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit ExpirationRanUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ExpirationRanUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ExpirationRanUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<ExpirationRanUpdate> CreateExpirationRanUpdate(
    flatbuffers::FlatBufferBuilder &_fbb) {
  ExpirationRanUpdateBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ExpirationRanUpdate::Traits {
  using type = ExpirationRanUpdate;
  static auto constexpr Create = CreateExpirationRanUpdate;
};

struct FeatureFlagChangedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef FeatureFlagChangedUpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NEW_VALUE = 6,
    VT_IS_SET = 8
  };
  uint16_t id() const {
    return GetField<uint16_t>(VT_ID, 0);
  }
  bool new_value() const {
    return GetField<uint8_t>(VT_NEW_VALUE, 0) != 0;
  }
  bool is_set() const {
    return GetField<uint8_t>(VT_IS_SET, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_ID, 2) &&
           VerifyField<uint8_t>(verifier, VT_NEW_VALUE, 1) &&
           VerifyField<uint8_t>(verifier, VT_IS_SET, 1) &&
           verifier.EndTable();
  }
};

struct FeatureFlagChangedUpdateBuilder {
  typedef FeatureFlagChangedUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint16_t id) {
    fbb_.AddElement<uint16_t>(FeatureFlagChangedUpdate::VT_ID, id, 0);
  }
  void add_new_value(bool new_value) {
    fbb_.AddElement<uint8_t>(FeatureFlagChangedUpdate::VT_NEW_VALUE, static_cast<uint8_t>(new_value), 0);
  }
  void add_is_set(bool is_set) {
    fbb_.AddElement<uint8_t>(FeatureFlagChangedUpdate::VT_IS_SET, static_cast<uint8_t>(is_set), 0);
  }
  explicit FeatureFlagChangedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<FeatureFlagChangedUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FeatureFlagChangedUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<FeatureFlagChangedUpdate> CreateFeatureFlagChangedUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t id = 0,
    bool new_value = false,
    bool is_set = false) {
  FeatureFlagChangedUpdateBuilder builder_(_fbb);
  builder_.add_id(id);
  builder_.add_is_set(is_set);
  builder_.add_new_value(new_value);
  return builder_.Finish();
}

struct FeatureFlagChangedUpdate::Traits {
  using type = FeatureFlagChangedUpdate;
  static auto constexpr Create = CreateFeatureFlagChangedUpdate;
};

struct Update FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef UpdateBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_UPDATE_TYPE_TYPE = 4,
    VT_UPDATE_TYPE = 6,
    VT_UPDATED_AT = 8,
    VT_BACKUP_PATH = 10
  };
  generated::UpdateType update_type_type() const {
    return static_cast<generated::UpdateType>(GetField<uint8_t>(VT_UPDATE_TYPE_TYPE, 0));
  }
  const void *update_type() const {
    return GetPointer<const void *>(VT_UPDATE_TYPE);
  }
  template<typename T> const T *update_type_as() const;
  const generated::RepoInitializedUpdate *update_type_as_RepoInitializedUpdate() const {
    return update_type_type() == generated::UpdateType::RepoInitializedUpdate ? static_cast<const generated::RepoInitializedUpdate *>(update_type()) : nullptr;
  }
  const generated::RepoMigratedUpdate *update_type_as_RepoMigratedUpdate() const {
    return update_type_type() == generated::UpdateType::RepoMigratedUpdate ? static_cast<const generated::RepoMigratedUpdate *>(update_type()) : nullptr;
  }
  const generated::ConfigChangedUpdate *update_type_as_ConfigChangedUpdate() const {
    return update_type_type() == generated::UpdateType::ConfigChangedUpdate ? static_cast<const generated::ConfigChangedUpdate *>(update_type()) : nullptr;
  }
  const generated::MetadataChangedUpdate *update_type_as_MetadataChangedUpdate() const {
    return update_type_type() == generated::UpdateType::MetadataChangedUpdate ? static_cast<const generated::MetadataChangedUpdate *>(update_type()) : nullptr;
  }
  const generated::TagCreatedUpdate *update_type_as_TagCreatedUpdate() const {
    return update_type_type() == generated::UpdateType::TagCreatedUpdate ? static_cast<const generated::TagCreatedUpdate *>(update_type()) : nullptr;
  }
  const generated::TagDeletedUpdate *update_type_as_TagDeletedUpdate() const {
    return update_type_type() == generated::UpdateType::TagDeletedUpdate ? static_cast<const generated::TagDeletedUpdate *>(update_type()) : nullptr;
  }
  const generated::BranchCreatedUpdate *update_type_as_BranchCreatedUpdate() const {
    return update_type_type() == generated::UpdateType::BranchCreatedUpdate ? static_cast<const generated::BranchCreatedUpdate *>(update_type()) : nullptr;
  }
  const generated::BranchDeletedUpdate *update_type_as_BranchDeletedUpdate() const {
    return update_type_type() == generated::UpdateType::BranchDeletedUpdate ? static_cast<const generated::BranchDeletedUpdate *>(update_type()) : nullptr;
  }
  const generated::BranchResetUpdate *update_type_as_BranchResetUpdate() const {
    return update_type_type() == generated::UpdateType::BranchResetUpdate ? static_cast<const generated::BranchResetUpdate *>(update_type()) : nullptr;
  }
  const generated::NewCommitUpdate *update_type_as_NewCommitUpdate() const {
    return update_type_type() == generated::UpdateType::NewCommitUpdate ? static_cast<const generated::NewCommitUpdate *>(update_type()) : nullptr;
  }
  const generated::CommitAmendedUpdate *update_type_as_CommitAmendedUpdate() const {
    return update_type_type() == generated::UpdateType::CommitAmendedUpdate ? static_cast<const generated::CommitAmendedUpdate *>(update_type()) : nullptr;
  }
  const generated::NewDetachedSnapshotUpdate *update_type_as_NewDetachedSnapshotUpdate() const {
    return update_type_type() == generated::UpdateType::NewDetachedSnapshotUpdate ? static_cast<const generated::NewDetachedSnapshotUpdate *>(update_type()) : nullptr;
  }
  const generated::GCRanUpdate *update_type_as_GCRanUpdate() const {
    return update_type_type() == generated::UpdateType::GCRanUpdate ? static_cast<const generated::GCRanUpdate *>(update_type()) : nullptr;
  }
  const generated::ExpirationRanUpdate *update_type_as_ExpirationRanUpdate() const {
    return update_type_type() == generated::UpdateType::ExpirationRanUpdate ? static_cast<const generated::ExpirationRanUpdate *>(update_type()) : nullptr;
  }
  const generated::FeatureFlagChangedUpdate *update_type_as_FeatureFlagChangedUpdate() const {
    return update_type_type() == generated::UpdateType::FeatureFlagChangedUpdate ? static_cast<const generated::FeatureFlagChangedUpdate *>(update_type()) : nullptr;
  }
  const generated::RepoStatusChangedUpdate *update_type_as_RepoStatusChangedUpdate() const {
    return update_type_type() == generated::UpdateType::RepoStatusChangedUpdate ? static_cast<const generated::RepoStatusChangedUpdate *>(update_type()) : nullptr;
  }
  uint64_t updated_at() const {
    return GetField<uint64_t>(VT_UPDATED_AT, 0);
  }
  const flatbuffers::String *backup_path() const {
    return GetPointer<const flatbuffers::String *>(VT_BACKUP_PATH);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_UPDATE_TYPE_TYPE, 1) &&
           VerifyOffsetRequired(verifier, VT_UPDATE_TYPE) &&
           VerifyUpdateType(verifier, update_type(), update_type_type()) &&
           VerifyField<uint64_t>(verifier, VT_UPDATED_AT, 8) &&
           VerifyOffset(verifier, VT_BACKUP_PATH) &&
           verifier.VerifyString(backup_path()) &&
           verifier.EndTable();
  }
};

template<> inline const generated::RepoInitializedUpdate *Update::update_type_as<generated::RepoInitializedUpdate>() const {
  return update_type_as_RepoInitializedUpdate();
}

template<> inline const generated::RepoMigratedUpdate *Update::update_type_as<generated::RepoMigratedUpdate>() const {
  return update_type_as_RepoMigratedUpdate();
}

template<> inline const generated::ConfigChangedUpdate *Update::update_type_as<generated::ConfigChangedUpdate>() const {
  return update_type_as_ConfigChangedUpdate();
}

template<> inline const generated::MetadataChangedUpdate *Update::update_type_as<generated::MetadataChangedUpdate>() const {
  return update_type_as_MetadataChangedUpdate();
}

template<> inline const generated::TagCreatedUpdate *Update::update_type_as<generated::TagCreatedUpdate>() const {
  return update_type_as_TagCreatedUpdate();
}

template<> inline const generated::TagDeletedUpdate *Update::update_type_as<generated::TagDeletedUpdate>() const {
  return update_type_as_TagDeletedUpdate();
}

template<> inline const generated::BranchCreatedUpdate *Update::update_type_as<generated::BranchCreatedUpdate>() const {
  return update_type_as_BranchCreatedUpdate();
}

template<> inline const generated::BranchDeletedUpdate *Update::update_type_as<generated::BranchDeletedUpdate>() const {
  return update_type_as_BranchDeletedUpdate();
}

template<> inline const generated::BranchResetUpdate *Update::update_type_as<generated::BranchResetUpdate>() const {
  return update_type_as_BranchResetUpdate();
}

template<> inline const generated::NewCommitUpdate *Update::update_type_as<generated::NewCommitUpdate>() const {
  return update_type_as_NewCommitUpdate();
}

template<> inline const generated::CommitAmendedUpdate *Update::update_type_as<generated::CommitAmendedUpdate>() const {
  return update_type_as_CommitAmendedUpdate();
}

template<> inline const generated::NewDetachedSnapshotUpdate *Update::update_type_as<generated::NewDetachedSnapshotUpdate>() const {
  return update_type_as_NewDetachedSnapshotUpdate();
}

template<> inline const generated::GCRanUpdate *Update::update_type_as<generated::GCRanUpdate>() const {
  return update_type_as_GCRanUpdate();
}

template<> inline const generated::ExpirationRanUpdate *Update::update_type_as<generated::ExpirationRanUpdate>() const {
  return update_type_as_ExpirationRanUpdate();
}

template<> inline const generated::FeatureFlagChangedUpdate *Update::update_type_as<generated::FeatureFlagChangedUpdate>() const {
  return update_type_as_FeatureFlagChangedUpdate();
}

template<> inline const generated::RepoStatusChangedUpdate *Update::update_type_as<generated::RepoStatusChangedUpdate>() const {
  return update_type_as_RepoStatusChangedUpdate();
}

struct UpdateBuilder {
  typedef Update Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_update_type_type(generated::UpdateType update_type_type) {
    fbb_.AddElement<uint8_t>(Update::VT_UPDATE_TYPE_TYPE, static_cast<uint8_t>(update_type_type), 0);
  }
  void add_update_type(flatbuffers::Offset<void> update_type) {
    fbb_.AddOffset(Update::VT_UPDATE_TYPE, update_type);
  }
  void add_updated_at(uint64_t updated_at) {
    fbb_.AddElement<uint64_t>(Update::VT_UPDATED_AT, updated_at, 0);
  }
  void add_backup_path(flatbuffers::Offset<flatbuffers::String> backup_path) {
    fbb_.AddOffset(Update::VT_BACKUP_PATH, backup_path);
  }
  explicit UpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<Update> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Update>(end);
    fbb_.Required(o, Update::VT_UPDATE_TYPE);
    return o;
  }
};

inline flatbuffers::Offset<Update> CreateUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    generated::UpdateType update_type_type = generated::UpdateType::NONE,
    flatbuffers::Offset<void> update_type = 0,
    uint64_t updated_at = 0,
    flatbuffers::Offset<flatbuffers::String> backup_path = 0) {
  UpdateBuilder builder_(_fbb);
  builder_.add_updated_at(updated_at);
  builder_.add_backup_path(backup_path);
  builder_.add_update_type(update_type);
  builder_.add_update_type_type(update_type_type);
  return builder_.Finish();
}

struct Update::Traits {
  using type = Update;
  static auto constexpr Create = CreateUpdate;
};

inline flatbuffers::Offset<Update> CreateUpdateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    generated::UpdateType update_type_type = generated::UpdateType::NONE,
    flatbuffers::Offset<void> update_type = 0,
    uint64_t updated_at = 0,
    const char *backup_path = nullptr) {
  auto backup_path__ = backup_path ? _fbb.CreateString(backup_path) : 0;
  return generated::CreateUpdate(
      _fbb,
      update_type_type,
      update_type,
      updated_at,
      backup_path__);
}

struct Repo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RepoBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SPEC_VERSION = 4,
    VT_TAGS = 6,
    VT_BRANCHES = 8,
    VT_DELETED_TAGS = 10,
    VT_SNAPSHOTS = 12,
    VT_STATUS = 14,
    VT_METADATA = 16,
    VT_LATEST_UPDATES = 18,
    VT_REPO_BEFORE_UPDATES = 20,
    VT_CONFIG = 22,
    VT_ENABLED_FEATURE_FLAGS = 24,
    VT_DISABLED_FEATURE_FLAGS = 26,
    VT_EXTRA = 28
  };
  uint8_t spec_version() const {
    return GetField<uint8_t>(VT_SPEC_VERSION, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::Ref>> *tags() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::Ref>> *>(VT_TAGS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::Ref>> *branches() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::Ref>> *>(VT_BRANCHES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *deleted_tags() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DELETED_TAGS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::SnapshotInfo>> *snapshots() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::SnapshotInfo>> *>(VT_SNAPSHOTS);
  }
  const generated::RepoStatus *status() const {
    return GetPointer<const generated::RepoStatus *>(VT_STATUS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>> *metadata() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>> *>(VT_METADATA);
  }
  const flatbuffers::Vector<flatbuffers::Offset<generated::Update>> *latest_updates() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<generated::Update>> *>(VT_LATEST_UPDATES);
  }
  const flatbuffers::String *repo_before_updates() const {
    return GetPointer<const flatbuffers::String *>(VT_REPO_BEFORE_UPDATES);
  }
  const flatbuffers::Vector<uint8_t> *config() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CONFIG);
  }
  flexbuffers::Reference config_flexbuffer_root() const {
    return flexbuffers::GetRoot(config()->Data(), config()->size());
  }
  const flatbuffers::Vector<uint16_t> *enabled_feature_flags() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_ENABLED_FEATURE_FLAGS);
  }
  const flatbuffers::Vector<uint16_t> *disabled_feature_flags() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_DISABLED_FEATURE_FLAGS);
  }
  const flatbuffers::Vector<uint8_t> *extra() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTRA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SPEC_VERSION, 1) &&
           VerifyOffsetRequired(verifier, VT_TAGS) &&
           verifier.VerifyVector(tags()) &&
           verifier.VerifyVectorOfTables(tags()) &&
           VerifyOffsetRequired(verifier, VT_BRANCHES) &&
           verifier.VerifyVector(branches()) &&
           verifier.VerifyVectorOfTables(branches()) &&
           VerifyOffsetRequired(verifier, VT_DELETED_TAGS) &&
           verifier.VerifyVector(deleted_tags()) &&
           verifier.VerifyVectorOfStrings(deleted_tags()) &&
           VerifyOffsetRequired(verifier, VT_SNAPSHOTS) &&
           verifier.VerifyVector(snapshots()) &&
           verifier.VerifyVectorOfTables(snapshots()) &&
           VerifyOffsetRequired(verifier, VT_STATUS) &&
           verifier.VerifyTable(status()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyVector(metadata()) &&
           verifier.VerifyVectorOfTables(metadata()) &&
           VerifyOffsetRequired(verifier, VT_LATEST_UPDATES) &&
           verifier.VerifyVector(latest_updates()) &&
           verifier.VerifyVectorOfTables(latest_updates()) &&
           VerifyOffset(verifier, VT_REPO_BEFORE_UPDATES) &&
           verifier.VerifyString(repo_before_updates()) &&
           VerifyOffset(verifier, VT_CONFIG) &&
           verifier.VerifyVector(config()) &&
           flexbuffers::VerifyNestedFlexBuffer(config(), verifier) &&
           VerifyOffset(verifier, VT_ENABLED_FEATURE_FLAGS) &&
           verifier.VerifyVector(enabled_feature_flags()) &&
           VerifyOffset(verifier, VT_DISABLED_FEATURE_FLAGS) &&
           verifier.VerifyVector(disabled_feature_flags()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.EndTable();
  }
};

struct RepoBuilder {
  typedef Repo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_spec_version(uint8_t spec_version) {
    fbb_.AddElement<uint8_t>(Repo::VT_SPEC_VERSION, spec_version, 0);
  }
  void add_tags(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::Ref>>> tags) {
    fbb_.AddOffset(Repo::VT_TAGS, tags);
  }
  void add_branches(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::Ref>>> branches) {
    fbb_.AddOffset(Repo::VT_BRANCHES, branches);
  }
  void add_deleted_tags(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> deleted_tags) {
    fbb_.AddOffset(Repo::VT_DELETED_TAGS, deleted_tags);
  }
  void add_snapshots(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::SnapshotInfo>>> snapshots) {
    fbb_.AddOffset(Repo::VT_SNAPSHOTS, snapshots);
  }
  void add_status(flatbuffers::Offset<generated::RepoStatus> status) {
    fbb_.AddOffset(Repo::VT_STATUS, status);
  }
  void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>>> metadata) {
    fbb_.AddOffset(Repo::VT_METADATA, metadata);
  }
  void add_latest_updates(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::Update>>> latest_updates) {
    fbb_.AddOffset(Repo::VT_LATEST_UPDATES, latest_updates);
  }
  void add_repo_before_updates(flatbuffers::Offset<flatbuffers::String> repo_before_updates) {
    fbb_.AddOffset(Repo::VT_REPO_BEFORE_UPDATES, repo_before_updates);
  }
  void add_config(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> config) {
    fbb_.AddOffset(Repo::VT_CONFIG, config);
  }
  void add_enabled_feature_flags(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> enabled_feature_flags) {
    fbb_.AddOffset(Repo::VT_ENABLED_FEATURE_FLAGS, enabled_feature_flags);
  }
  void add_disabled_feature_flags(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> disabled_feature_flags) {
    fbb_.AddOffset(Repo::VT_DISABLED_FEATURE_FLAGS, disabled_feature_flags);
  }
  void add_extra(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra) {
    fbb_.AddOffset(Repo::VT_EXTRA, extra);
  }
  explicit RepoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<Repo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Repo>(end);
    fbb_.Required(o, Repo::VT_TAGS);
    fbb_.Required(o, Repo::VT_BRANCHES);
    fbb_.Required(o, Repo::VT_DELETED_TAGS);
    fbb_.Required(o, Repo::VT_SNAPSHOTS);
    fbb_.Required(o, Repo::VT_STATUS);
    fbb_.Required(o, Repo::VT_LATEST_UPDATES);
    return o;
  }
};

inline flatbuffers::Offset<Repo> CreateRepo(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t spec_version = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::Ref>>> tags = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::Ref>>> branches = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> deleted_tags = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::SnapshotInfo>>> snapshots = 0,
    flatbuffers::Offset<generated::RepoStatus> status = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::MetadataItem>>> metadata = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<generated::Update>>> latest_updates = 0,
    flatbuffers::Offset<flatbuffers::String> repo_before_updates = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> config = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> enabled_feature_flags = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> disabled_feature_flags = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extra = 0) {
  RepoBuilder builder_(_fbb);
  builder_.add_extra(extra);
  builder_.add_disabled_feature_flags(disabled_feature_flags);
  builder_.add_enabled_feature_flags(enabled_feature_flags);
  builder_.add_config(config);
  builder_.add_repo_before_updates(repo_before_updates);
  builder_.add_latest_updates(latest_updates);
  builder_.add_metadata(metadata);
  builder_.add_status(status);
  builder_.add_snapshots(snapshots);
  builder_.add_deleted_tags(deleted_tags);
  builder_.add_branches(branches);
  builder_.add_tags(tags);
  builder_.add_spec_version(spec_version);
  return builder_.Finish();
}

struct Repo::Traits {
  using type = Repo;
  static auto constexpr Create = CreateRepo;
};

inline flatbuffers::Offset<Repo> CreateRepoDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t spec_version = 0,
    const std::vector<flatbuffers::Offset<generated::Ref>> *tags = nullptr,
    const std::vector<flatbuffers::Offset<generated::Ref>> *branches = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *deleted_tags = nullptr,
    const std::vector<flatbuffers::Offset<generated::SnapshotInfo>> *snapshots = nullptr,
    flatbuffers::Offset<generated::RepoStatus> status = 0,
    const std::vector<flatbuffers::Offset<generated::MetadataItem>> *metadata = nullptr,
    const std::vector<flatbuffers::Offset<generated::Update>> *latest_updates = nullptr,
    const char *repo_before_updates = nullptr,
    const std::vector<uint8_t> *config = nullptr,
    const std::vector<uint16_t> *enabled_feature_flags = nullptr,
    const std::vector<uint16_t> *disabled_feature_flags = nullptr,
    const std::vector<uint8_t> *extra = nullptr) {
  auto tags__ = tags ? _fbb.CreateVector<flatbuffers::Offset<generated::Ref>>(*tags) : 0;
  auto branches__ = branches ? _fbb.CreateVector<flatbuffers::Offset<generated::Ref>>(*branches) : 0;
  auto deleted_tags__ = deleted_tags ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*deleted_tags) : 0;
  auto snapshots__ = snapshots ? _fbb.CreateVector<flatbuffers::Offset<generated::SnapshotInfo>>(*snapshots) : 0;
  auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<generated::MetadataItem>>(*metadata) : 0;
  auto latest_updates__ = latest_updates ? _fbb.CreateVector<flatbuffers::Offset<generated::Update>>(*latest_updates) : 0;
  auto repo_before_updates__ = repo_before_updates ? _fbb.CreateString(repo_before_updates) : 0;
  auto config__ = config ? _fbb.CreateVector<uint8_t>(*config) : 0;
  auto enabled_feature_flags__ = enabled_feature_flags ? _fbb.CreateVector<uint16_t>(*enabled_feature_flags) : 0;
  auto disabled_feature_flags__ = disabled_feature_flags ? _fbb.CreateVector<uint16_t>(*disabled_feature_flags) : 0;
  auto extra__ = extra ? _fbb.CreateVector<uint8_t>(*extra) : 0;
  return generated::CreateRepo(
      _fbb,
      spec_version,
      tags__,
      branches__,
      deleted_tags__,
      snapshots__,
      status,
      metadata__,
      latest_updates__,
      repo_before_updates__,
      config__,
      enabled_feature_flags__,
      disabled_feature_flags__,
      extra__);
}

inline bool VerifyUpdateType(flatbuffers::Verifier &verifier, const void *obj, UpdateType type) {
  switch (type) {
    case UpdateType::NONE: {
      return true;
    }
    case UpdateType::RepoInitializedUpdate: {
      auto ptr = reinterpret_cast<const generated::RepoInitializedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::RepoMigratedUpdate: {
      auto ptr = reinterpret_cast<const generated::RepoMigratedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::ConfigChangedUpdate: {
      auto ptr = reinterpret_cast<const generated::ConfigChangedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::MetadataChangedUpdate: {
      auto ptr = reinterpret_cast<const generated::MetadataChangedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::TagCreatedUpdate: {
      auto ptr = reinterpret_cast<const generated::TagCreatedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::TagDeletedUpdate: {
      auto ptr = reinterpret_cast<const generated::TagDeletedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::BranchCreatedUpdate: {
      auto ptr = reinterpret_cast<const generated::BranchCreatedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::BranchDeletedUpdate: {
      auto ptr = reinterpret_cast<const generated::BranchDeletedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::BranchResetUpdate: {
      auto ptr = reinterpret_cast<const generated::BranchResetUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::NewCommitUpdate: {
      auto ptr = reinterpret_cast<const generated::NewCommitUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::CommitAmendedUpdate: {
      auto ptr = reinterpret_cast<const generated::CommitAmendedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::NewDetachedSnapshotUpdate: {
      auto ptr = reinterpret_cast<const generated::NewDetachedSnapshotUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::GCRanUpdate: {
      auto ptr = reinterpret_cast<const generated::GCRanUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::ExpirationRanUpdate: {
      auto ptr = reinterpret_cast<const generated::ExpirationRanUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::FeatureFlagChangedUpdate: {
      auto ptr = reinterpret_cast<const generated::FeatureFlagChangedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case UpdateType::RepoStatusChangedUpdate: {
      auto ptr = reinterpret_cast<const generated::RepoStatusChangedUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyUpdateTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<UpdateType> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyUpdateType(
        verifier,  values->Get(i), types->GetEnum<UpdateType>(i))) {
      return false;
    }
  }
  return true;
}

inline const generated::Repo *GetRepo(const void *buf) {
  return flatbuffers::GetRoot<generated::Repo>(buf);
}

inline const generated::Repo *GetSizePrefixedRepo(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<generated::Repo>(buf);
}

inline bool VerifyRepoBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<generated::Repo>(nullptr);
}

inline bool VerifySizePrefixedRepoBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<generated::Repo>(nullptr);
}

inline void FinishRepoBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<generated::Repo> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedRepoBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<generated::Repo> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace generated

#endif  // FLATBUFFERS_GENERATED_REPO_GENERATED_H_

Coverage Report

Created: 2026-08-11 08:26