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


#ifndef FLATBUFFERS_GENERATED_VALUE_IKARUS_VALUE_H_
#define FLATBUFFERS_GENERATED_VALUE_IKARUS_VALUE_H_

#include "flatbuffers/flatbuffers.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 == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 25,
             "Non-compatible flatbuffers version included");

namespace Ikarus {
namespace Value {

struct ToggleDataPoint;
struct ToggleDataPointBuilder;

struct NumberDataPoint;
struct NumberDataPointBuilder;

struct TextDataPoint;
struct TextDataPointBuilder;

struct ConstantSchema;
struct ConstantSchemaBuilder;

struct SimpleSchema;
struct SimpleSchemaBuilder;

struct SimpleData;
struct SimpleDataBuilder;

struct CombinedSchema;
struct CombinedSchemaBuilder;

struct CombinedData;
struct CombinedDataBuilder;

struct ListSchema;
struct ListSchemaBuilder;

struct ListData;
struct ListDataBuilder;

struct NamedSchema;
struct NamedSchemaBuilder;

struct ComplexSchema;
struct ComplexSchemaBuilder;

struct NamedData;
struct NamedDataBuilder;

struct ComplexData;
struct ComplexDataBuilder;

struct Value;
struct ValueBuilder;

enum class Data : uint8_t {
  NONE = 0,
  ToggleDataPoint = 1,
  NumberDataPoint = 2,
  TextDataPoint = 3,
  SimpleData = 4,
  CombinedData = 5,
  ListData = 6,
  ComplexData = 7,
  MIN = NONE,
  MAX = ComplexData
};

inline const Data (&EnumValuesData())[8] {
  static const Data values[] = {
    Data::NONE,
    Data::ToggleDataPoint,
    Data::NumberDataPoint,
    Data::TextDataPoint,
    Data::SimpleData,
    Data::CombinedData,
    Data::ListData,
    Data::ComplexData
  };
  return values;
}

inline const char * const *EnumNamesData() {
  static const char * const names[9] = {
    "NONE",
    "ToggleDataPoint",
    "NumberDataPoint",
    "TextDataPoint",
    "SimpleData",
    "CombinedData",
    "ListData",
    "ComplexData",
    nullptr
  };
  return names;
}

inline const char *EnumNameData(Data e) {
  if (::flatbuffers::IsOutRange(e, Data::NONE, Data::ComplexData)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesData()[index];
}

template<typename T> struct DataTraits {
  static const Data enum_value = Data::NONE;
};

template<> struct DataTraits<Ikarus::Value::ToggleDataPoint> {
  static const Data enum_value = Data::ToggleDataPoint;
};

template<> struct DataTraits<Ikarus::Value::NumberDataPoint> {
  static const Data enum_value = Data::NumberDataPoint;
};

template<> struct DataTraits<Ikarus::Value::TextDataPoint> {
  static const Data enum_value = Data::TextDataPoint;
};

template<> struct DataTraits<Ikarus::Value::SimpleData> {
  static const Data enum_value = Data::SimpleData;
};

template<> struct DataTraits<Ikarus::Value::CombinedData> {
  static const Data enum_value = Data::CombinedData;
};

template<> struct DataTraits<Ikarus::Value::ListData> {
  static const Data enum_value = Data::ListData;
};

template<> struct DataTraits<Ikarus::Value::ComplexData> {
  static const Data enum_value = Data::ComplexData;
};

bool VerifyData(::flatbuffers::Verifier &verifier, const void *obj, Data type);
bool VerifyDataVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Data> *types);

enum class Schema : uint8_t {
  NONE = 0,
  ConstantSchema = 1,
  SimpleSchema = 2,
  CombinedSchema = 3,
  ListSchema = 4,
  ComplexSchema = 5,
  MIN = NONE,
  MAX = ComplexSchema
};

inline const Schema (&EnumValuesSchema())[6] {
  static const Schema values[] = {
    Schema::NONE,
    Schema::ConstantSchema,
    Schema::SimpleSchema,
    Schema::CombinedSchema,
    Schema::ListSchema,
    Schema::ComplexSchema
  };
  return values;
}

inline const char * const *EnumNamesSchema() {
  static const char * const names[7] = {
    "NONE",
    "ConstantSchema",
    "SimpleSchema",
    "CombinedSchema",
    "ListSchema",
    "ComplexSchema",
    nullptr
  };
  return names;
}

inline const char *EnumNameSchema(Schema e) {
  if (::flatbuffers::IsOutRange(e, Schema::NONE, Schema::ComplexSchema)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSchema()[index];
}

template<typename T> struct SchemaTraits {
  static const Schema enum_value = Schema::NONE;
};

template<> struct SchemaTraits<Ikarus::Value::ConstantSchema> {
  static const Schema enum_value = Schema::ConstantSchema;
};

template<> struct SchemaTraits<Ikarus::Value::SimpleSchema> {
  static const Schema enum_value = Schema::SimpleSchema;
};

template<> struct SchemaTraits<Ikarus::Value::CombinedSchema> {
  static const Schema enum_value = Schema::CombinedSchema;
};

template<> struct SchemaTraits<Ikarus::Value::ListSchema> {
  static const Schema enum_value = Schema::ListSchema;
};

template<> struct SchemaTraits<Ikarus::Value::ComplexSchema> {
  static const Schema enum_value = Schema::ComplexSchema;
};

bool VerifySchema(::flatbuffers::Verifier &verifier, const void *obj, Schema type);
bool VerifySchemaVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Schema> *types);

struct ToggleDataPoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToggleDataPointBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const ::flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct ToggleDataPointBuilder {
  typedef ToggleDataPoint Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(ToggleDataPoint::VT_DATA, data);
  }
  explicit ToggleDataPointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToggleDataPoint> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToggleDataPoint>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ToggleDataPoint> CreateToggleDataPoint(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
  ToggleDataPointBuilder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}

struct ToggleDataPoint::Traits {
  using type = ToggleDataPoint;
  static auto constexpr Create = CreateToggleDataPoint;
};

inline ::flatbuffers::Offset<ToggleDataPoint> CreateToggleDataPointDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return Ikarus::Value::CreateToggleDataPoint(
      _fbb,
      data__);
}

struct NumberDataPoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NumberDataPointBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const ::flatbuffers::Vector<double> *data() const {
    return GetPointer<const ::flatbuffers::Vector<double> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct NumberDataPointBuilder {
  typedef NumberDataPoint Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<double>> data) {
    fbb_.AddOffset(NumberDataPoint::VT_DATA, data);
  }
  explicit NumberDataPointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NumberDataPoint> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NumberDataPoint>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NumberDataPoint> CreateNumberDataPoint(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<double>> data = 0) {
  NumberDataPointBuilder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}

struct NumberDataPoint::Traits {
  using type = NumberDataPoint;
  static auto constexpr Create = CreateNumberDataPoint;
};

inline ::flatbuffers::Offset<NumberDataPoint> CreateNumberDataPointDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<double> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<double>(*data) : 0;
  return Ikarus::Value::CreateNumberDataPoint(
      _fbb,
      data__);
}

struct TextDataPoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TextDataPointBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *data() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.VerifyVectorOfStrings(data()) &&
           verifier.EndTable();
  }
};

struct TextDataPointBuilder {
  typedef TextDataPoint Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> data) {
    fbb_.AddOffset(TextDataPoint::VT_DATA, data);
  }
  explicit TextDataPointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TextDataPoint> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TextDataPoint>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<TextDataPoint> CreateTextDataPoint(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> data = 0) {
  TextDataPointBuilder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}

struct TextDataPoint::Traits {
  using type = TextDataPoint;
  static auto constexpr Create = CreateTextDataPoint;
};

inline ::flatbuffers::Offset<TextDataPoint> CreateTextDataPointDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*data) : 0;
  return Ikarus::Value::CreateTextDataPoint(
      _fbb,
      data__);
}

struct ConstantSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstantSchemaBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUB_SCHEMA_TYPE = 4,
    VT_SUB_SCHEMA = 6,
    VT_DATA_TYPE = 8,
    VT_DATA = 10
  };
  Ikarus::Value::Schema sub_schema_type() const {
    return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_SUB_SCHEMA_TYPE, 0));
  }
  const void *sub_schema() const {
    return GetPointer<const void *>(VT_SUB_SCHEMA);
  }
  template<typename T> const T *sub_schema_as() const;
  const Ikarus::Value::ConstantSchema *sub_schema_as_ConstantSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::SimpleSchema *sub_schema_as_SimpleSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::CombinedSchema *sub_schema_as_CombinedSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::ListSchema *sub_schema_as_ListSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::ComplexSchema *sub_schema_as_ComplexSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(sub_schema()) : nullptr;
  }
  Ikarus::Value::Data data_type() const {
    return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DATA_TYPE, 0));
  }
  const void *data() const {
    return GetPointer<const void *>(VT_DATA);
  }
  template<typename T> const T *data_as() const;
  const Ikarus::Value::ToggleDataPoint *data_as_ToggleDataPoint() const {
    return data_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::NumberDataPoint *data_as_NumberDataPoint() const {
    return data_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::TextDataPoint *data_as_TextDataPoint() const {
    return data_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::SimpleData *data_as_SimpleData() const {
    return data_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(data()) : nullptr;
  }
  const Ikarus::Value::CombinedData *data_as_CombinedData() const {
    return data_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(data()) : nullptr;
  }
  const Ikarus::Value::ListData *data_as_ListData() const {
    return data_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(data()) : nullptr;
  }
  const Ikarus::Value::ComplexData *data_as_ComplexData() const {
    return data_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(data()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SUB_SCHEMA_TYPE, 1) &&
           VerifyOffset(verifier, VT_SUB_SCHEMA) &&
           VerifySchema(verifier, sub_schema(), sub_schema_type()) &&
           VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
           VerifyOffset(verifier, VT_DATA) &&
           VerifyData(verifier, data(), data_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ConstantSchema *ConstantSchema::sub_schema_as<Ikarus::Value::ConstantSchema>() const {
  return sub_schema_as_ConstantSchema();
}

template<> inline const Ikarus::Value::SimpleSchema *ConstantSchema::sub_schema_as<Ikarus::Value::SimpleSchema>() const {
  return sub_schema_as_SimpleSchema();
}

template<> inline const Ikarus::Value::CombinedSchema *ConstantSchema::sub_schema_as<Ikarus::Value::CombinedSchema>() const {
  return sub_schema_as_CombinedSchema();
}

template<> inline const Ikarus::Value::ListSchema *ConstantSchema::sub_schema_as<Ikarus::Value::ListSchema>() const {
  return sub_schema_as_ListSchema();
}

template<> inline const Ikarus::Value::ComplexSchema *ConstantSchema::sub_schema_as<Ikarus::Value::ComplexSchema>() const {
  return sub_schema_as_ComplexSchema();
}

template<> inline const Ikarus::Value::ToggleDataPoint *ConstantSchema::data_as<Ikarus::Value::ToggleDataPoint>() const {
  return data_as_ToggleDataPoint();
}

template<> inline const Ikarus::Value::NumberDataPoint *ConstantSchema::data_as<Ikarus::Value::NumberDataPoint>() const {
  return data_as_NumberDataPoint();
}

template<> inline const Ikarus::Value::TextDataPoint *ConstantSchema::data_as<Ikarus::Value::TextDataPoint>() const {
  return data_as_TextDataPoint();
}

template<> inline const Ikarus::Value::SimpleData *ConstantSchema::data_as<Ikarus::Value::SimpleData>() const {
  return data_as_SimpleData();
}

template<> inline const Ikarus::Value::CombinedData *ConstantSchema::data_as<Ikarus::Value::CombinedData>() const {
  return data_as_CombinedData();
}

template<> inline const Ikarus::Value::ListData *ConstantSchema::data_as<Ikarus::Value::ListData>() const {
  return data_as_ListData();
}

template<> inline const Ikarus::Value::ComplexData *ConstantSchema::data_as<Ikarus::Value::ComplexData>() const {
  return data_as_ComplexData();
}

struct ConstantSchemaBuilder {
  typedef ConstantSchema Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_sub_schema_type(Ikarus::Value::Schema sub_schema_type) {
    fbb_.AddElement<uint8_t>(ConstantSchema::VT_SUB_SCHEMA_TYPE, static_cast<uint8_t>(sub_schema_type), 0);
  }
  void add_sub_schema(::flatbuffers::Offset<void> sub_schema) {
    fbb_.AddOffset(ConstantSchema::VT_SUB_SCHEMA, sub_schema);
  }
  void add_data_type(Ikarus::Value::Data data_type) {
    fbb_.AddElement<uint8_t>(ConstantSchema::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
  }
  void add_data(::flatbuffers::Offset<void> data) {
    fbb_.AddOffset(ConstantSchema::VT_DATA, data);
  }
  explicit ConstantSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstantSchema> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstantSchema>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ConstantSchema> CreateConstantSchema(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Ikarus::Value::Schema sub_schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> sub_schema = 0,
    Ikarus::Value::Data data_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> data = 0) {
  ConstantSchemaBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_sub_schema(sub_schema);
  builder_.add_data_type(data_type);
  builder_.add_sub_schema_type(sub_schema_type);
  return builder_.Finish();
}

struct ConstantSchema::Traits {
  using type = ConstantSchema;
  static auto constexpr Create = CreateConstantSchema;
};

struct SimpleSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SimpleSchemaBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUB_SCHEMA_TYPE = 4,
    VT_SUB_SCHEMA = 6
  };
  Ikarus::Value::Schema sub_schema_type() const {
    return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_SUB_SCHEMA_TYPE, 0));
  }
  const void *sub_schema() const {
    return GetPointer<const void *>(VT_SUB_SCHEMA);
  }
  template<typename T> const T *sub_schema_as() const;
  const Ikarus::Value::ConstantSchema *sub_schema_as_ConstantSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::SimpleSchema *sub_schema_as_SimpleSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::CombinedSchema *sub_schema_as_CombinedSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::ListSchema *sub_schema_as_ListSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(sub_schema()) : nullptr;
  }
  const Ikarus::Value::ComplexSchema *sub_schema_as_ComplexSchema() const {
    return sub_schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(sub_schema()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SUB_SCHEMA_TYPE, 1) &&
           VerifyOffset(verifier, VT_SUB_SCHEMA) &&
           VerifySchema(verifier, sub_schema(), sub_schema_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ConstantSchema *SimpleSchema::sub_schema_as<Ikarus::Value::ConstantSchema>() const {
  return sub_schema_as_ConstantSchema();
}

template<> inline const Ikarus::Value::SimpleSchema *SimpleSchema::sub_schema_as<Ikarus::Value::SimpleSchema>() const {
  return sub_schema_as_SimpleSchema();
}

template<> inline const Ikarus::Value::CombinedSchema *SimpleSchema::sub_schema_as<Ikarus::Value::CombinedSchema>() const {
  return sub_schema_as_CombinedSchema();
}

template<> inline const Ikarus::Value::ListSchema *SimpleSchema::sub_schema_as<Ikarus::Value::ListSchema>() const {
  return sub_schema_as_ListSchema();
}

template<> inline const Ikarus::Value::ComplexSchema *SimpleSchema::sub_schema_as<Ikarus::Value::ComplexSchema>() const {
  return sub_schema_as_ComplexSchema();
}

struct SimpleSchemaBuilder {
  typedef SimpleSchema Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_sub_schema_type(Ikarus::Value::Schema sub_schema_type) {
    fbb_.AddElement<uint8_t>(SimpleSchema::VT_SUB_SCHEMA_TYPE, static_cast<uint8_t>(sub_schema_type), 0);
  }
  void add_sub_schema(::flatbuffers::Offset<void> sub_schema) {
    fbb_.AddOffset(SimpleSchema::VT_SUB_SCHEMA, sub_schema);
  }
  explicit SimpleSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SimpleSchema> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SimpleSchema>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SimpleSchema> CreateSimpleSchema(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Ikarus::Value::Schema sub_schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> sub_schema = 0) {
  SimpleSchemaBuilder builder_(_fbb);
  builder_.add_sub_schema(sub_schema);
  builder_.add_sub_schema_type(sub_schema_type);
  return builder_.Finish();
}

struct SimpleSchema::Traits {
  using type = SimpleSchema;
  static auto constexpr Create = CreateSimpleSchema;
};

struct SimpleData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SimpleDataBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA_TYPE = 4,
    VT_DATA = 6
  };
  Ikarus::Value::Data data_type() const {
    return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DATA_TYPE, 0));
  }
  const void *data() const {
    return GetPointer<const void *>(VT_DATA);
  }
  template<typename T> const T *data_as() const;
  const Ikarus::Value::ToggleDataPoint *data_as_ToggleDataPoint() const {
    return data_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::NumberDataPoint *data_as_NumberDataPoint() const {
    return data_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::TextDataPoint *data_as_TextDataPoint() const {
    return data_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::SimpleData *data_as_SimpleData() const {
    return data_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(data()) : nullptr;
  }
  const Ikarus::Value::CombinedData *data_as_CombinedData() const {
    return data_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(data()) : nullptr;
  }
  const Ikarus::Value::ListData *data_as_ListData() const {
    return data_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(data()) : nullptr;
  }
  const Ikarus::Value::ComplexData *data_as_ComplexData() const {
    return data_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(data()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
           VerifyOffset(verifier, VT_DATA) &&
           VerifyData(verifier, data(), data_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ToggleDataPoint *SimpleData::data_as<Ikarus::Value::ToggleDataPoint>() const {
  return data_as_ToggleDataPoint();
}

template<> inline const Ikarus::Value::NumberDataPoint *SimpleData::data_as<Ikarus::Value::NumberDataPoint>() const {
  return data_as_NumberDataPoint();
}

template<> inline const Ikarus::Value::TextDataPoint *SimpleData::data_as<Ikarus::Value::TextDataPoint>() const {
  return data_as_TextDataPoint();
}

template<> inline const Ikarus::Value::SimpleData *SimpleData::data_as<Ikarus::Value::SimpleData>() const {
  return data_as_SimpleData();
}

template<> inline const Ikarus::Value::CombinedData *SimpleData::data_as<Ikarus::Value::CombinedData>() const {
  return data_as_CombinedData();
}

template<> inline const Ikarus::Value::ListData *SimpleData::data_as<Ikarus::Value::ListData>() const {
  return data_as_ListData();
}

template<> inline const Ikarus::Value::ComplexData *SimpleData::data_as<Ikarus::Value::ComplexData>() const {
  return data_as_ComplexData();
}

struct SimpleDataBuilder {
  typedef SimpleData Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data_type(Ikarus::Value::Data data_type) {
    fbb_.AddElement<uint8_t>(SimpleData::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
  }
  void add_data(::flatbuffers::Offset<void> data) {
    fbb_.AddOffset(SimpleData::VT_DATA, data);
  }
  explicit SimpleDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SimpleData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SimpleData>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SimpleData> CreateSimpleData(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Ikarus::Value::Data data_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> data = 0) {
  SimpleDataBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}

struct SimpleData::Traits {
  using type = SimpleData;
  static auto constexpr Create = CreateSimpleData;
};

struct CombinedSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CombinedSchemaBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCHEMAS_TYPE = 4,
    VT_SCHEMAS = 6
  };
  const ::flatbuffers::Vector<Ikarus::Value::Schema> *schemas_type() const {
    return GetPointer<const ::flatbuffers::Vector<Ikarus::Value::Schema> *>(VT_SCHEMAS_TYPE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *schemas() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_SCHEMAS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SCHEMAS_TYPE) &&
           verifier.VerifyVector(schemas_type()) &&
           VerifyOffset(verifier, VT_SCHEMAS) &&
           verifier.VerifyVector(schemas()) &&
           VerifySchemaVector(verifier, schemas(), schemas_type()) &&
           verifier.EndTable();
  }
};

struct CombinedSchemaBuilder {
  typedef CombinedSchema Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_schemas_type(::flatbuffers::Offset<::flatbuffers::Vector<Ikarus::Value::Schema>> schemas_type) {
    fbb_.AddOffset(CombinedSchema::VT_SCHEMAS_TYPE, schemas_type);
  }
  void add_schemas(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> schemas) {
    fbb_.AddOffset(CombinedSchema::VT_SCHEMAS, schemas);
  }
  explicit CombinedSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CombinedSchema> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CombinedSchema>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CombinedSchema> CreateCombinedSchema(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<Ikarus::Value::Schema>> schemas_type = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> schemas = 0) {
  CombinedSchemaBuilder builder_(_fbb);
  builder_.add_schemas(schemas);
  builder_.add_schemas_type(schemas_type);
  return builder_.Finish();
}

struct CombinedSchema::Traits {
  using type = CombinedSchema;
  static auto constexpr Create = CreateCombinedSchema;
};

inline ::flatbuffers::Offset<CombinedSchema> CreateCombinedSchemaDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<Ikarus::Value::Schema> *schemas_type = nullptr,
    const std::vector<::flatbuffers::Offset<void>> *schemas = nullptr) {
  auto schemas_type__ = schemas_type ? _fbb.CreateVector<Ikarus::Value::Schema>(*schemas_type) : 0;
  auto schemas__ = schemas ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*schemas) : 0;
  return Ikarus::Value::CreateCombinedSchema(
      _fbb,
      schemas_type__,
      schemas__);
}

struct CombinedData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CombinedDataBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA_TYPE = 4,
    VT_DATA = 6
  };
  const ::flatbuffers::Vector<Ikarus::Value::Data> *data_type() const {
    return GetPointer<const ::flatbuffers::Vector<Ikarus::Value::Data> *>(VT_DATA_TYPE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *data() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA_TYPE) &&
           verifier.VerifyVector(data_type()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           VerifyDataVector(verifier, data(), data_type()) &&
           verifier.EndTable();
  }
};

struct CombinedDataBuilder {
  typedef CombinedData Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data_type(::flatbuffers::Offset<::flatbuffers::Vector<Ikarus::Value::Data>> data_type) {
    fbb_.AddOffset(CombinedData::VT_DATA_TYPE, data_type);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> data) {
    fbb_.AddOffset(CombinedData::VT_DATA, data);
  }
  explicit CombinedDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CombinedData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CombinedData>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CombinedData> CreateCombinedData(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<Ikarus::Value::Data>> data_type = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> data = 0) {
  CombinedDataBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}

struct CombinedData::Traits {
  using type = CombinedData;
  static auto constexpr Create = CreateCombinedData;
};

inline ::flatbuffers::Offset<CombinedData> CreateCombinedDataDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<Ikarus::Value::Data> *data_type = nullptr,
    const std::vector<::flatbuffers::Offset<void>> *data = nullptr) {
  auto data_type__ = data_type ? _fbb.CreateVector<Ikarus::Value::Data>(*data_type) : 0;
  auto data__ = data ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*data) : 0;
  return Ikarus::Value::CreateCombinedData(
      _fbb,
      data_type__,
      data__);
}

struct ListSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ListSchemaBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCHEMA_TYPE = 4,
    VT_SCHEMA = 6
  };
  Ikarus::Value::Schema schema_type() const {
    return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_SCHEMA_TYPE, 0));
  }
  const void *schema() const {
    return GetPointer<const void *>(VT_SCHEMA);
  }
  template<typename T> const T *schema_as() const;
  const Ikarus::Value::ConstantSchema *schema_as_ConstantSchema() const {
    return schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::SimpleSchema *schema_as_SimpleSchema() const {
    return schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::CombinedSchema *schema_as_CombinedSchema() const {
    return schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::ListSchema *schema_as_ListSchema() const {
    return schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::ComplexSchema *schema_as_ComplexSchema() const {
    return schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(schema()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SCHEMA_TYPE, 1) &&
           VerifyOffset(verifier, VT_SCHEMA) &&
           VerifySchema(verifier, schema(), schema_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ConstantSchema *ListSchema::schema_as<Ikarus::Value::ConstantSchema>() const {
  return schema_as_ConstantSchema();
}

template<> inline const Ikarus::Value::SimpleSchema *ListSchema::schema_as<Ikarus::Value::SimpleSchema>() const {
  return schema_as_SimpleSchema();
}

template<> inline const Ikarus::Value::CombinedSchema *ListSchema::schema_as<Ikarus::Value::CombinedSchema>() const {
  return schema_as_CombinedSchema();
}

template<> inline const Ikarus::Value::ListSchema *ListSchema::schema_as<Ikarus::Value::ListSchema>() const {
  return schema_as_ListSchema();
}

template<> inline const Ikarus::Value::ComplexSchema *ListSchema::schema_as<Ikarus::Value::ComplexSchema>() const {
  return schema_as_ComplexSchema();
}

struct ListSchemaBuilder {
  typedef ListSchema Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_schema_type(Ikarus::Value::Schema schema_type) {
    fbb_.AddElement<uint8_t>(ListSchema::VT_SCHEMA_TYPE, static_cast<uint8_t>(schema_type), 0);
  }
  void add_schema(::flatbuffers::Offset<void> schema) {
    fbb_.AddOffset(ListSchema::VT_SCHEMA, schema);
  }
  explicit ListSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ListSchema> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ListSchema>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ListSchema> CreateListSchema(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Ikarus::Value::Schema schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> schema = 0) {
  ListSchemaBuilder builder_(_fbb);
  builder_.add_schema(schema);
  builder_.add_schema_type(schema_type);
  return builder_.Finish();
}

struct ListSchema::Traits {
  using type = ListSchema;
  static auto constexpr Create = CreateListSchema;
};

struct ListData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ListDataBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA_TYPE = 4,
    VT_DATA = 6
  };
  const ::flatbuffers::Vector<Ikarus::Value::Data> *data_type() const {
    return GetPointer<const ::flatbuffers::Vector<Ikarus::Value::Data> *>(VT_DATA_TYPE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *data() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA_TYPE) &&
           verifier.VerifyVector(data_type()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           VerifyDataVector(verifier, data(), data_type()) &&
           verifier.EndTable();
  }
};

struct ListDataBuilder {
  typedef ListData Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data_type(::flatbuffers::Offset<::flatbuffers::Vector<Ikarus::Value::Data>> data_type) {
    fbb_.AddOffset(ListData::VT_DATA_TYPE, data_type);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> data) {
    fbb_.AddOffset(ListData::VT_DATA, data);
  }
  explicit ListDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ListData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ListData>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ListData> CreateListData(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<Ikarus::Value::Data>> data_type = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> data = 0) {
  ListDataBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}

struct ListData::Traits {
  using type = ListData;
  static auto constexpr Create = CreateListData;
};

inline ::flatbuffers::Offset<ListData> CreateListDataDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<Ikarus::Value::Data> *data_type = nullptr,
    const std::vector<::flatbuffers::Offset<void>> *data = nullptr) {
  auto data_type__ = data_type ? _fbb.CreateVector<Ikarus::Value::Data>(*data_type) : 0;
  auto data__ = data ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*data) : 0;
  return Ikarus::Value::CreateListData(
      _fbb,
      data_type__,
      data__);
}

struct NamedSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NamedSchemaBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_SCHEMA_TYPE = 6,
    VT_SCHEMA = 8
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  Ikarus::Value::Schema schema_type() const {
    return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_SCHEMA_TYPE, 0));
  }
  const void *schema() const {
    return GetPointer<const void *>(VT_SCHEMA);
  }
  template<typename T> const T *schema_as() const;
  const Ikarus::Value::ConstantSchema *schema_as_ConstantSchema() const {
    return schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::SimpleSchema *schema_as_SimpleSchema() const {
    return schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::CombinedSchema *schema_as_CombinedSchema() const {
    return schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::ListSchema *schema_as_ListSchema() const {
    return schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::ComplexSchema *schema_as_ComplexSchema() const {
    return schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(schema()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint8_t>(verifier, VT_SCHEMA_TYPE, 1) &&
           VerifyOffset(verifier, VT_SCHEMA) &&
           VerifySchema(verifier, schema(), schema_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ConstantSchema *NamedSchema::schema_as<Ikarus::Value::ConstantSchema>() const {
  return schema_as_ConstantSchema();
}

template<> inline const Ikarus::Value::SimpleSchema *NamedSchema::schema_as<Ikarus::Value::SimpleSchema>() const {
  return schema_as_SimpleSchema();
}

template<> inline const Ikarus::Value::CombinedSchema *NamedSchema::schema_as<Ikarus::Value::CombinedSchema>() const {
  return schema_as_CombinedSchema();
}

template<> inline const Ikarus::Value::ListSchema *NamedSchema::schema_as<Ikarus::Value::ListSchema>() const {
  return schema_as_ListSchema();
}

template<> inline const Ikarus::Value::ComplexSchema *NamedSchema::schema_as<Ikarus::Value::ComplexSchema>() const {
  return schema_as_ComplexSchema();
}

struct NamedSchemaBuilder {
  typedef NamedSchema Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(NamedSchema::VT_NAME, name);
  }
  void add_schema_type(Ikarus::Value::Schema schema_type) {
    fbb_.AddElement<uint8_t>(NamedSchema::VT_SCHEMA_TYPE, static_cast<uint8_t>(schema_type), 0);
  }
  void add_schema(::flatbuffers::Offset<void> schema) {
    fbb_.AddOffset(NamedSchema::VT_SCHEMA, schema);
  }
  explicit NamedSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NamedSchema> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NamedSchema>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NamedSchema> CreateNamedSchema(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    Ikarus::Value::Schema schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> schema = 0) {
  NamedSchemaBuilder builder_(_fbb);
  builder_.add_schema(schema);
  builder_.add_name(name);
  builder_.add_schema_type(schema_type);
  return builder_.Finish();
}

struct NamedSchema::Traits {
  using type = NamedSchema;
  static auto constexpr Create = CreateNamedSchema;
};

inline ::flatbuffers::Offset<NamedSchema> CreateNamedSchemaDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    Ikarus::Value::Schema schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> schema = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return Ikarus::Value::CreateNamedSchema(
      _fbb,
      name__,
      schema_type,
      schema);
}

struct ComplexSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ComplexSchemaBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCHEMAS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedSchema>> *schemas() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedSchema>> *>(VT_SCHEMAS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SCHEMAS) &&
           verifier.VerifyVector(schemas()) &&
           verifier.VerifyVectorOfTables(schemas()) &&
           verifier.EndTable();
  }
};

struct ComplexSchemaBuilder {
  typedef ComplexSchema Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_schemas(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedSchema>>> schemas) {
    fbb_.AddOffset(ComplexSchema::VT_SCHEMAS, schemas);
  }
  explicit ComplexSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ComplexSchema> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ComplexSchema>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ComplexSchema> CreateComplexSchema(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedSchema>>> schemas = 0) {
  ComplexSchemaBuilder builder_(_fbb);
  builder_.add_schemas(schemas);
  return builder_.Finish();
}

struct ComplexSchema::Traits {
  using type = ComplexSchema;
  static auto constexpr Create = CreateComplexSchema;
};

inline ::flatbuffers::Offset<ComplexSchema> CreateComplexSchemaDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<Ikarus::Value::NamedSchema>> *schemas = nullptr) {
  auto schemas__ = schemas ? _fbb.CreateVector<::flatbuffers::Offset<Ikarus::Value::NamedSchema>>(*schemas) : 0;
  return Ikarus::Value::CreateComplexSchema(
      _fbb,
      schemas__);
}

struct NamedData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NamedDataBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_DATA_TYPE = 6,
    VT_DATA = 8
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  Ikarus::Value::Data data_type() const {
    return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DATA_TYPE, 0));
  }
  const void *data() const {
    return GetPointer<const void *>(VT_DATA);
  }
  template<typename T> const T *data_as() const;
  const Ikarus::Value::ToggleDataPoint *data_as_ToggleDataPoint() const {
    return data_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::NumberDataPoint *data_as_NumberDataPoint() const {
    return data_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::TextDataPoint *data_as_TextDataPoint() const {
    return data_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::SimpleData *data_as_SimpleData() const {
    return data_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(data()) : nullptr;
  }
  const Ikarus::Value::CombinedData *data_as_CombinedData() const {
    return data_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(data()) : nullptr;
  }
  const Ikarus::Value::ListData *data_as_ListData() const {
    return data_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(data()) : nullptr;
  }
  const Ikarus::Value::ComplexData *data_as_ComplexData() const {
    return data_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(data()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
           VerifyOffset(verifier, VT_DATA) &&
           VerifyData(verifier, data(), data_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ToggleDataPoint *NamedData::data_as<Ikarus::Value::ToggleDataPoint>() const {
  return data_as_ToggleDataPoint();
}

template<> inline const Ikarus::Value::NumberDataPoint *NamedData::data_as<Ikarus::Value::NumberDataPoint>() const {
  return data_as_NumberDataPoint();
}

template<> inline const Ikarus::Value::TextDataPoint *NamedData::data_as<Ikarus::Value::TextDataPoint>() const {
  return data_as_TextDataPoint();
}

template<> inline const Ikarus::Value::SimpleData *NamedData::data_as<Ikarus::Value::SimpleData>() const {
  return data_as_SimpleData();
}

template<> inline const Ikarus::Value::CombinedData *NamedData::data_as<Ikarus::Value::CombinedData>() const {
  return data_as_CombinedData();
}

template<> inline const Ikarus::Value::ListData *NamedData::data_as<Ikarus::Value::ListData>() const {
  return data_as_ListData();
}

template<> inline const Ikarus::Value::ComplexData *NamedData::data_as<Ikarus::Value::ComplexData>() const {
  return data_as_ComplexData();
}

struct NamedDataBuilder {
  typedef NamedData Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(NamedData::VT_NAME, name);
  }
  void add_data_type(Ikarus::Value::Data data_type) {
    fbb_.AddElement<uint8_t>(NamedData::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
  }
  void add_data(::flatbuffers::Offset<void> data) {
    fbb_.AddOffset(NamedData::VT_DATA, data);
  }
  explicit NamedDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NamedData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NamedData>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NamedData> CreateNamedData(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    Ikarus::Value::Data data_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> data = 0) {
  NamedDataBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_name(name);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}

struct NamedData::Traits {
  using type = NamedData;
  static auto constexpr Create = CreateNamedData;
};

inline ::flatbuffers::Offset<NamedData> CreateNamedDataDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    Ikarus::Value::Data data_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> data = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return Ikarus::Value::CreateNamedData(
      _fbb,
      name__,
      data_type,
      data);
}

struct ComplexData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ComplexDataBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedData>> *data() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedData>> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.VerifyVectorOfTables(data()) &&
           verifier.EndTable();
  }
};

struct ComplexDataBuilder {
  typedef ComplexData Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedData>>> data) {
    fbb_.AddOffset(ComplexData::VT_DATA, data);
  }
  explicit ComplexDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ComplexData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ComplexData>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ComplexData> CreateComplexData(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Ikarus::Value::NamedData>>> data = 0) {
  ComplexDataBuilder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}

struct ComplexData::Traits {
  using type = ComplexData;
  static auto constexpr Create = CreateComplexData;
};

inline ::flatbuffers::Offset<ComplexData> CreateComplexDataDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<Ikarus::Value::NamedData>> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<::flatbuffers::Offset<Ikarus::Value::NamedData>>(*data) : 0;
  return Ikarus::Value::CreateComplexData(
      _fbb,
      data__);
}

struct Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ValueBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCHEMA_TYPE = 4,
    VT_SCHEMA = 6,
    VT_DATA_TYPE = 8,
    VT_DATA = 10
  };
  Ikarus::Value::Schema schema_type() const {
    return static_cast<Ikarus::Value::Schema>(GetField<uint8_t>(VT_SCHEMA_TYPE, 0));
  }
  const void *schema() const {
    return GetPointer<const void *>(VT_SCHEMA);
  }
  template<typename T> const T *schema_as() const;
  const Ikarus::Value::ConstantSchema *schema_as_ConstantSchema() const {
    return schema_type() == Ikarus::Value::Schema::ConstantSchema ? static_cast<const Ikarus::Value::ConstantSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::SimpleSchema *schema_as_SimpleSchema() const {
    return schema_type() == Ikarus::Value::Schema::SimpleSchema ? static_cast<const Ikarus::Value::SimpleSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::CombinedSchema *schema_as_CombinedSchema() const {
    return schema_type() == Ikarus::Value::Schema::CombinedSchema ? static_cast<const Ikarus::Value::CombinedSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::ListSchema *schema_as_ListSchema() const {
    return schema_type() == Ikarus::Value::Schema::ListSchema ? static_cast<const Ikarus::Value::ListSchema *>(schema()) : nullptr;
  }
  const Ikarus::Value::ComplexSchema *schema_as_ComplexSchema() const {
    return schema_type() == Ikarus::Value::Schema::ComplexSchema ? static_cast<const Ikarus::Value::ComplexSchema *>(schema()) : nullptr;
  }
  Ikarus::Value::Data data_type() const {
    return static_cast<Ikarus::Value::Data>(GetField<uint8_t>(VT_DATA_TYPE, 0));
  }
  const void *data() const {
    return GetPointer<const void *>(VT_DATA);
  }
  template<typename T> const T *data_as() const;
  const Ikarus::Value::ToggleDataPoint *data_as_ToggleDataPoint() const {
    return data_type() == Ikarus::Value::Data::ToggleDataPoint ? static_cast<const Ikarus::Value::ToggleDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::NumberDataPoint *data_as_NumberDataPoint() const {
    return data_type() == Ikarus::Value::Data::NumberDataPoint ? static_cast<const Ikarus::Value::NumberDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::TextDataPoint *data_as_TextDataPoint() const {
    return data_type() == Ikarus::Value::Data::TextDataPoint ? static_cast<const Ikarus::Value::TextDataPoint *>(data()) : nullptr;
  }
  const Ikarus::Value::SimpleData *data_as_SimpleData() const {
    return data_type() == Ikarus::Value::Data::SimpleData ? static_cast<const Ikarus::Value::SimpleData *>(data()) : nullptr;
  }
  const Ikarus::Value::CombinedData *data_as_CombinedData() const {
    return data_type() == Ikarus::Value::Data::CombinedData ? static_cast<const Ikarus::Value::CombinedData *>(data()) : nullptr;
  }
  const Ikarus::Value::ListData *data_as_ListData() const {
    return data_type() == Ikarus::Value::Data::ListData ? static_cast<const Ikarus::Value::ListData *>(data()) : nullptr;
  }
  const Ikarus::Value::ComplexData *data_as_ComplexData() const {
    return data_type() == Ikarus::Value::Data::ComplexData ? static_cast<const Ikarus::Value::ComplexData *>(data()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SCHEMA_TYPE, 1) &&
           VerifyOffset(verifier, VT_SCHEMA) &&
           VerifySchema(verifier, schema(), schema_type()) &&
           VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
           VerifyOffset(verifier, VT_DATA) &&
           VerifyData(verifier, data(), data_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Ikarus::Value::ConstantSchema *Value::schema_as<Ikarus::Value::ConstantSchema>() const {
  return schema_as_ConstantSchema();
}

template<> inline const Ikarus::Value::SimpleSchema *Value::schema_as<Ikarus::Value::SimpleSchema>() const {
  return schema_as_SimpleSchema();
}

template<> inline const Ikarus::Value::CombinedSchema *Value::schema_as<Ikarus::Value::CombinedSchema>() const {
  return schema_as_CombinedSchema();
}

template<> inline const Ikarus::Value::ListSchema *Value::schema_as<Ikarus::Value::ListSchema>() const {
  return schema_as_ListSchema();
}

template<> inline const Ikarus::Value::ComplexSchema *Value::schema_as<Ikarus::Value::ComplexSchema>() const {
  return schema_as_ComplexSchema();
}

template<> inline const Ikarus::Value::ToggleDataPoint *Value::data_as<Ikarus::Value::ToggleDataPoint>() const {
  return data_as_ToggleDataPoint();
}

template<> inline const Ikarus::Value::NumberDataPoint *Value::data_as<Ikarus::Value::NumberDataPoint>() const {
  return data_as_NumberDataPoint();
}

template<> inline const Ikarus::Value::TextDataPoint *Value::data_as<Ikarus::Value::TextDataPoint>() const {
  return data_as_TextDataPoint();
}

template<> inline const Ikarus::Value::SimpleData *Value::data_as<Ikarus::Value::SimpleData>() const {
  return data_as_SimpleData();
}

template<> inline const Ikarus::Value::CombinedData *Value::data_as<Ikarus::Value::CombinedData>() const {
  return data_as_CombinedData();
}

template<> inline const Ikarus::Value::ListData *Value::data_as<Ikarus::Value::ListData>() const {
  return data_as_ListData();
}

template<> inline const Ikarus::Value::ComplexData *Value::data_as<Ikarus::Value::ComplexData>() const {
  return data_as_ComplexData();
}

struct ValueBuilder {
  typedef Value Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_schema_type(Ikarus::Value::Schema schema_type) {
    fbb_.AddElement<uint8_t>(Value::VT_SCHEMA_TYPE, static_cast<uint8_t>(schema_type), 0);
  }
  void add_schema(::flatbuffers::Offset<void> schema) {
    fbb_.AddOffset(Value::VT_SCHEMA, schema);
  }
  void add_data_type(Ikarus::Value::Data data_type) {
    fbb_.AddElement<uint8_t>(Value::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
  }
  void add_data(::flatbuffers::Offset<void> data) {
    fbb_.AddOffset(Value::VT_DATA, data);
  }
  explicit ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Value> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Value>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Value> CreateValue(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Ikarus::Value::Schema schema_type = Ikarus::Value::Schema::NONE,
    ::flatbuffers::Offset<void> schema = 0,
    Ikarus::Value::Data data_type = Ikarus::Value::Data::NONE,
    ::flatbuffers::Offset<void> data = 0) {
  ValueBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_schema(schema);
  builder_.add_data_type(data_type);
  builder_.add_schema_type(schema_type);
  return builder_.Finish();
}

struct Value::Traits {
  using type = Value;
  static auto constexpr Create = CreateValue;
};

inline bool VerifyData(::flatbuffers::Verifier &verifier, const void *obj, Data type) {
  switch (type) {
    case Data::NONE: {
      return true;
    }
    case Data::ToggleDataPoint: {
      auto ptr = reinterpret_cast<const Ikarus::Value::ToggleDataPoint *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data::NumberDataPoint: {
      auto ptr = reinterpret_cast<const Ikarus::Value::NumberDataPoint *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data::TextDataPoint: {
      auto ptr = reinterpret_cast<const Ikarus::Value::TextDataPoint *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data::SimpleData: {
      auto ptr = reinterpret_cast<const Ikarus::Value::SimpleData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data::CombinedData: {
      auto ptr = reinterpret_cast<const Ikarus::Value::CombinedData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data::ListData: {
      auto ptr = reinterpret_cast<const Ikarus::Value::ListData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data::ComplexData: {
      auto ptr = reinterpret_cast<const Ikarus::Value::ComplexData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyDataVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Data> *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 (!VerifyData(
        verifier,  values->Get(i), types->GetEnum<Data>(i))) {
      return false;
    }
  }
  return true;
}

inline bool VerifySchema(::flatbuffers::Verifier &verifier, const void *obj, Schema type) {
  switch (type) {
    case Schema::NONE: {
      return true;
    }
    case Schema::ConstantSchema: {
      auto ptr = reinterpret_cast<const Ikarus::Value::ConstantSchema *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Schema::SimpleSchema: {
      auto ptr = reinterpret_cast<const Ikarus::Value::SimpleSchema *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Schema::CombinedSchema: {
      auto ptr = reinterpret_cast<const Ikarus::Value::CombinedSchema *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Schema::ListSchema: {
      auto ptr = reinterpret_cast<const Ikarus::Value::ListSchema *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Schema::ComplexSchema: {
      auto ptr = reinterpret_cast<const Ikarus::Value::ComplexSchema *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifySchemaVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Schema> *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 (!VerifySchema(
        verifier,  values->Get(i), types->GetEnum<Schema>(i))) {
      return false;
    }
  }
  return true;
}

inline const Ikarus::Value::Value *GetValue(const void *buf) {
  return ::flatbuffers::GetRoot<Ikarus::Value::Value>(buf);
}

inline const Ikarus::Value::Value *GetSizePrefixedValue(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<Ikarus::Value::Value>(buf);
}

inline bool VerifyValueBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<Ikarus::Value::Value>(nullptr);
}

inline bool VerifySizePrefixedValueBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<Ikarus::Value::Value>(nullptr);
}

inline void FinishValueBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Ikarus::Value::Value> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedValueBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Ikarus::Value::Value> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace Value
}  // namespace Ikarus

#endif  // FLATBUFFERS_GENERATED_VALUE_IKARUS_VALUE_H_