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


#ifndef FLATBUFFERS_GENERATED_MESSAGE_FBS_H_
#define FLATBUFFERS_GENERATED_MESSAGE_FBS_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 == 23 &&
              FLATBUFFERS_VERSION_MINOR == 5 &&
              FLATBUFFERS_VERSION_REVISION == 26,
             "Non-compatible flatbuffers version included");

namespace fbs {

struct DictEntry;
struct DictEntryBuilder;

struct Color;

struct Array3Meta;
struct Array3MetaBuilder;

struct Array3MetaFlow;
struct Array3MetaFlowBuilder;

struct Array3DataChunkf;
struct Array3DataChunkfBuilder;

struct Array3DataChunku8;
struct Array3DataChunku8Builder;

struct Array3DataChunku16;
struct Array3DataChunku16Builder;

struct Filepaths;
struct FilepathsBuilder;

struct VideoExport;
struct VideoExportBuilder;

struct CloseVideo;
struct CloseVideoBuilder;

struct Quit;
struct QuitBuilder;

struct PointsVideo;
struct PointsVideoBuilder;

struct Root;
struct RootBuilder;

enum BitRange : int32_t {
  BitRange_AUTODETECT = 0,
  BitRange_MINMAX = 1,
  BitRange_UINT8 = 2,
  BitRange_UINT10 = 3,
  BitRange_UINT12 = 4,
  BitRange_UINT16 = 5,
  BitRange_FLOAT = 6,
  BitRange_DIFF = 7,
  BitRange_PHASE = 8,
  BitRange_PHASE_DIFF = 9,
  BitRange_INT8 = 10,
  BitRange_MIN = BitRange_AUTODETECT,
  BitRange_MAX = BitRange_INT8
};

inline const BitRange (&EnumValuesBitRange())[11] {
  static const BitRange values[] = {
    BitRange_AUTODETECT,
    BitRange_MINMAX,
    BitRange_UINT8,
    BitRange_UINT10,
    BitRange_UINT12,
    BitRange_UINT16,
    BitRange_FLOAT,
    BitRange_DIFF,
    BitRange_PHASE,
    BitRange_PHASE_DIFF,
    BitRange_INT8
  };
  return values;
}

inline const char * const *EnumNamesBitRange() {
  static const char * const names[12] = {
    "AUTODETECT",
    "MINMAX",
    "UINT8",
    "UINT10",
    "UINT12",
    "UINT16",
    "FLOAT",
    "DIFF",
    "PHASE",
    "PHASE_DIFF",
    "INT8",
    nullptr
  };
  return names;
}

inline const char *EnumNameBitRange(BitRange e) {
  if (::flatbuffers::IsOutRange(e, BitRange_AUTODETECT, BitRange_INT8)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesBitRange()[index];
}

enum ColorMap : int32_t {
  ColorMap_DEFAULT = 0,
  ColorMap_GRAY = 1,
  ColorMap_HSV = 2,
  ColorMap_BLACKBODY = 3,
  ColorMap_VIRIDIS = 4,
  ColorMap_PRGN = 5,
  ColorMap_PRGN_POS = 6,
  ColorMap_PRGN_NEG = 7,
  ColorMap_RDBU = 8,
  ColorMap_MIN = ColorMap_DEFAULT,
  ColorMap_MAX = ColorMap_RDBU
};

inline const ColorMap (&EnumValuesColorMap())[9] {
  static const ColorMap values[] = {
    ColorMap_DEFAULT,
    ColorMap_GRAY,
    ColorMap_HSV,
    ColorMap_BLACKBODY,
    ColorMap_VIRIDIS,
    ColorMap_PRGN,
    ColorMap_PRGN_POS,
    ColorMap_PRGN_NEG,
    ColorMap_RDBU
  };
  return values;
}

inline const char * const *EnumNamesColorMap() {
  static const char * const names[10] = {
    "DEFAULT",
    "GRAY",
    "HSV",
    "BLACKBODY",
    "VIRIDIS",
    "PRGN",
    "PRGN_POS",
    "PRGN_NEG",
    "RDBU",
    nullptr
  };
  return names;
}

inline const char *EnumNameColorMap(ColorMap e) {
  if (::flatbuffers::IsOutRange(e, ColorMap_DEFAULT, ColorMap_RDBU)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesColorMap()[index];
}

enum OpacityFunction : int32_t {
  OpacityFunction_NONE = 0,
  OpacityFunction_LINEAR = 1,
  OpacityFunction_LINEAR_R = 2,
  OpacityFunction_CENTERED = 3,
  OpacityFunction_FIXED_100 = 4,
  OpacityFunction_FIXED_75 = 5,
  OpacityFunction_FIXED_50 = 6,
  OpacityFunction_FIXED_25 = 7,
  OpacityFunction_FIXED_0 = 8,
  OpacityFunction_MIN = OpacityFunction_NONE,
  OpacityFunction_MAX = OpacityFunction_FIXED_0
};

inline const OpacityFunction (&EnumValuesOpacityFunction())[9] {
  static const OpacityFunction values[] = {
    OpacityFunction_NONE,
    OpacityFunction_LINEAR,
    OpacityFunction_LINEAR_R,
    OpacityFunction_CENTERED,
    OpacityFunction_FIXED_100,
    OpacityFunction_FIXED_75,
    OpacityFunction_FIXED_50,
    OpacityFunction_FIXED_25,
    OpacityFunction_FIXED_0
  };
  return values;
}

inline const char * const *EnumNamesOpacityFunction() {
  static const char * const names[10] = {
    "NONE",
    "LINEAR",
    "LINEAR_R",
    "CENTERED",
    "FIXED_100",
    "FIXED_75",
    "FIXED_50",
    "FIXED_25",
    "FIXED_0",
    nullptr
  };
  return names;
}

inline const char *EnumNameOpacityFunction(OpacityFunction e) {
  if (::flatbuffers::IsOutRange(e, OpacityFunction_NONE, OpacityFunction_FIXED_0)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesOpacityFunction()[index];
}

enum ArrayDataType : int32_t {
  ArrayDataType_FLOAT = 0,
  ArrayDataType_UINT8 = 1,
  ArrayDataType_UINT16 = 2,
  ArrayDataType_MIN = ArrayDataType_FLOAT,
  ArrayDataType_MAX = ArrayDataType_UINT16
};

inline const ArrayDataType (&EnumValuesArrayDataType())[3] {
  static const ArrayDataType values[] = {
    ArrayDataType_FLOAT,
    ArrayDataType_UINT8,
    ArrayDataType_UINT16
  };
  return values;
}

inline const char * const *EnumNamesArrayDataType() {
  static const char * const names[4] = {
    "FLOAT",
    "UINT8",
    "UINT16",
    nullptr
  };
  return names;
}

inline const char *EnumNameArrayDataType(ArrayDataType e) {
  if (::flatbuffers::IsOutRange(e, ArrayDataType_FLOAT, ArrayDataType_UINT16)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesArrayDataType()[index];
}

enum VideoExportFormat : int32_t {
  VideoExportFormat_FFMPEG = 0,
  VideoExportFormat_PNG = 1,
  VideoExportFormat_MIN = VideoExportFormat_FFMPEG,
  VideoExportFormat_MAX = VideoExportFormat_PNG
};

inline const VideoExportFormat (&EnumValuesVideoExportFormat())[2] {
  static const VideoExportFormat values[] = {
    VideoExportFormat_FFMPEG,
    VideoExportFormat_PNG
  };
  return values;
}

inline const char * const *EnumNamesVideoExportFormat() {
  static const char * const names[3] = {
    "FFMPEG",
    "PNG",
    nullptr
  };
  return names;
}

inline const char *EnumNameVideoExportFormat(VideoExportFormat e) {
  if (::flatbuffers::IsOutRange(e, VideoExportFormat_FFMPEG, VideoExportFormat_PNG)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesVideoExportFormat()[index];
}

enum Data : uint8_t {
  Data_NONE = 0,
  Data_Filepaths = 1,
  Data_Array3Meta = 2,
  Data_Array3MetaFlow = 3,
  Data_Array3DataChunkf = 4,
  Data_Array3DataChunku8 = 5,
  Data_Array3DataChunku16 = 6,
  Data_VideoExport = 7,
  Data_PointsVideo = 8,
  Data_CloseVideo = 9,
  Data_Quit = 10,
  Data_MIN = Data_NONE,
  Data_MAX = Data_Quit
};

inline const Data (&EnumValuesData())[11] {
  static const Data values[] = {
    Data_NONE,
    Data_Filepaths,
    Data_Array3Meta,
    Data_Array3MetaFlow,
    Data_Array3DataChunkf,
    Data_Array3DataChunku8,
    Data_Array3DataChunku16,
    Data_VideoExport,
    Data_PointsVideo,
    Data_CloseVideo,
    Data_Quit
  };
  return values;
}

inline const char * const *EnumNamesData() {
  static const char * const names[12] = {
    "NONE",
    "Filepaths",
    "Array3Meta",
    "Array3MetaFlow",
    "Array3DataChunkf",
    "Array3DataChunku8",
    "Array3DataChunku16",
    "VideoExport",
    "PointsVideo",
    "CloseVideo",
    "Quit",
    nullptr
  };
  return names;
}

inline const char *EnumNameData(Data e) {
  if (::flatbuffers::IsOutRange(e, Data_NONE, Data_Quit)) 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<fbs::Filepaths> {
  static const Data enum_value = Data_Filepaths;
};

template<> struct DataTraits<fbs::Array3Meta> {
  static const Data enum_value = Data_Array3Meta;
};

template<> struct DataTraits<fbs::Array3MetaFlow> {
  static const Data enum_value = Data_Array3MetaFlow;
};

template<> struct DataTraits<fbs::Array3DataChunkf> {
  static const Data enum_value = Data_Array3DataChunkf;
};

template<> struct DataTraits<fbs::Array3DataChunku8> {
  static const Data enum_value = Data_Array3DataChunku8;
};

template<> struct DataTraits<fbs::Array3DataChunku16> {
  static const Data enum_value = Data_Array3DataChunku16;
};

template<> struct DataTraits<fbs::VideoExport> {
  static const Data enum_value = Data_VideoExport;
};

template<> struct DataTraits<fbs::PointsVideo> {
  static const Data enum_value = Data_PointsVideo;
};

template<> struct DataTraits<fbs::CloseVideo> {
  static const Data enum_value = Data_CloseVideo;
};

template<> struct DataTraits<fbs::Quit> {
  static const Data enum_value = Data_Quit;
};

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<uint8_t> *types);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Color FLATBUFFERS_FINAL_CLASS {
 private:
  float values_[4];

 public:
  Color()
      : values_() {
  }
  Color(::flatbuffers::span<const float, 4> _values) {
    ::flatbuffers::CastToArray(values_).CopyFromSpan(_values);
  }
  const ::flatbuffers::Array<float, 4> *values() const {
    return &::flatbuffers::CastToArray(values_);
  }
};
FLATBUFFERS_STRUCT_END(Color, 16);

struct DictEntry FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DictEntryBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_KEY = 4,
    VT_VAL = 6
  };
  const ::flatbuffers::String *key() const {
    return GetPointer<const ::flatbuffers::String *>(VT_KEY);
  }
  const ::flatbuffers::String *val() const {
    return GetPointer<const ::flatbuffers::String *>(VT_VAL);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_KEY) &&
           verifier.VerifyString(key()) &&
           VerifyOffset(verifier, VT_VAL) &&
           verifier.VerifyString(val()) &&
           verifier.EndTable();
  }
};

struct DictEntryBuilder {
  typedef DictEntry Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
    fbb_.AddOffset(DictEntry::VT_KEY, key);
  }
  void add_val(::flatbuffers::Offset<::flatbuffers::String> val) {
    fbb_.AddOffset(DictEntry::VT_VAL, val);
  }
  explicit DictEntryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DictEntry> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DictEntry>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DictEntry> CreateDictEntry(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> key = 0,
    ::flatbuffers::Offset<::flatbuffers::String> val = 0) {
  DictEntryBuilder builder_(_fbb);
  builder_.add_val(val);
  builder_.add_key(key);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<DictEntry> CreateDictEntryDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *key = nullptr,
    const char *val = nullptr) {
  auto key__ = key ? _fbb.CreateString(key) : 0;
  auto val__ = val ? _fbb.CreateString(val) : 0;
  return fbs::CreateDictEntry(
      _fbb,
      key__,
      val__);
}

struct Array3Meta FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Array3MetaBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_NX = 6,
    VT_NY = 8,
    VT_NT = 10,
    VT_BITRANGE = 12,
    VT_CMAP = 14,
    VT_VMIN = 16,
    VT_VMAX = 18,
    VT_OPACITY = 20,
    VT_NAME = 22,
    VT_PARENT_NAME = 24,
    VT_DURATION = 26,
    VT_FPS = 28,
    VT_DATE = 30,
    VT_COMMENT = 32,
    VT_METADATA = 34
  };
  fbs::ArrayDataType type() const {
    return static_cast<fbs::ArrayDataType>(GetField<int32_t>(VT_TYPE, 0));
  }
  int32_t nx() const {
    return GetField<int32_t>(VT_NX, 0);
  }
  int32_t ny() const {
    return GetField<int32_t>(VT_NY, 0);
  }
  int32_t nt() const {
    return GetField<int32_t>(VT_NT, 0);
  }
  fbs::BitRange bitrange() const {
    return static_cast<fbs::BitRange>(GetField<int32_t>(VT_BITRANGE, 0));
  }
  fbs::ColorMap cmap() const {
    return static_cast<fbs::ColorMap>(GetField<int32_t>(VT_CMAP, 0));
  }
  float vmin() const {
    return GetField<float>(VT_VMIN, 0.0f);
  }
  float vmax() const {
    return GetField<float>(VT_VMAX, 0.0f);
  }
  fbs::OpacityFunction opacity() const {
    return static_cast<fbs::OpacityFunction>(GetField<int32_t>(VT_OPACITY, 0));
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::String *parent_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PARENT_NAME);
  }
  float duration() const {
    return GetField<float>(VT_DURATION, 0.0f);
  }
  float fps() const {
    return GetField<float>(VT_FPS, 0.0f);
  }
  const ::flatbuffers::String *date() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DATE);
  }
  const ::flatbuffers::String *comment() const {
    return GetPointer<const ::flatbuffers::String *>(VT_COMMENT);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<fbs::DictEntry>> *metadata() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<fbs::DictEntry>> *>(VT_METADATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
           VerifyField<int32_t>(verifier, VT_NX, 4) &&
           VerifyField<int32_t>(verifier, VT_NY, 4) &&
           VerifyField<int32_t>(verifier, VT_NT, 4) &&
           VerifyField<int32_t>(verifier, VT_BITRANGE, 4) &&
           VerifyField<int32_t>(verifier, VT_CMAP, 4) &&
           VerifyField<float>(verifier, VT_VMIN, 4) &&
           VerifyField<float>(verifier, VT_VMAX, 4) &&
           VerifyField<int32_t>(verifier, VT_OPACITY, 4) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_PARENT_NAME) &&
           verifier.VerifyString(parent_name()) &&
           VerifyField<float>(verifier, VT_DURATION, 4) &&
           VerifyField<float>(verifier, VT_FPS, 4) &&
           VerifyOffset(verifier, VT_DATE) &&
           verifier.VerifyString(date()) &&
           VerifyOffset(verifier, VT_COMMENT) &&
           verifier.VerifyString(comment()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyVector(metadata()) &&
           verifier.VerifyVectorOfTables(metadata()) &&
           verifier.EndTable();
  }
};

struct Array3MetaBuilder {
  typedef Array3Meta Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(fbs::ArrayDataType type) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_TYPE, static_cast<int32_t>(type), 0);
  }
  void add_nx(int32_t nx) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_NX, nx, 0);
  }
  void add_ny(int32_t ny) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_NY, ny, 0);
  }
  void add_nt(int32_t nt) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_NT, nt, 0);
  }
  void add_bitrange(fbs::BitRange bitrange) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_BITRANGE, static_cast<int32_t>(bitrange), 0);
  }
  void add_cmap(fbs::ColorMap cmap) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_CMAP, static_cast<int32_t>(cmap), 0);
  }
  void add_vmin(float vmin) {
    fbb_.AddElement<float>(Array3Meta::VT_VMIN, vmin, 0.0f);
  }
  void add_vmax(float vmax) {
    fbb_.AddElement<float>(Array3Meta::VT_VMAX, vmax, 0.0f);
  }
  void add_opacity(fbs::OpacityFunction opacity) {
    fbb_.AddElement<int32_t>(Array3Meta::VT_OPACITY, static_cast<int32_t>(opacity), 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Array3Meta::VT_NAME, name);
  }
  void add_parent_name(::flatbuffers::Offset<::flatbuffers::String> parent_name) {
    fbb_.AddOffset(Array3Meta::VT_PARENT_NAME, parent_name);
  }
  void add_duration(float duration) {
    fbb_.AddElement<float>(Array3Meta::VT_DURATION, duration, 0.0f);
  }
  void add_fps(float fps) {
    fbb_.AddElement<float>(Array3Meta::VT_FPS, fps, 0.0f);
  }
  void add_date(::flatbuffers::Offset<::flatbuffers::String> date) {
    fbb_.AddOffset(Array3Meta::VT_DATE, date);
  }
  void add_comment(::flatbuffers::Offset<::flatbuffers::String> comment) {
    fbb_.AddOffset(Array3Meta::VT_COMMENT, comment);
  }
  void add_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<fbs::DictEntry>>> metadata) {
    fbb_.AddOffset(Array3Meta::VT_METADATA, metadata);
  }
  explicit Array3MetaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Array3Meta> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Array3Meta>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Array3Meta> CreateArray3Meta(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    fbs::ArrayDataType type = fbs::ArrayDataType_FLOAT,
    int32_t nx = 0,
    int32_t ny = 0,
    int32_t nt = 0,
    fbs::BitRange bitrange = fbs::BitRange_AUTODETECT,
    fbs::ColorMap cmap = fbs::ColorMap_DEFAULT,
    float vmin = 0.0f,
    float vmax = 0.0f,
    fbs::OpacityFunction opacity = fbs::OpacityFunction_NONE,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::String> parent_name = 0,
    float duration = 0.0f,
    float fps = 0.0f,
    ::flatbuffers::Offset<::flatbuffers::String> date = 0,
    ::flatbuffers::Offset<::flatbuffers::String> comment = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<fbs::DictEntry>>> metadata = 0) {
  Array3MetaBuilder builder_(_fbb);
  builder_.add_metadata(metadata);
  builder_.add_comment(comment);
  builder_.add_date(date);
  builder_.add_fps(fps);
  builder_.add_duration(duration);
  builder_.add_parent_name(parent_name);
  builder_.add_name(name);
  builder_.add_opacity(opacity);
  builder_.add_vmax(vmax);
  builder_.add_vmin(vmin);
  builder_.add_cmap(cmap);
  builder_.add_bitrange(bitrange);
  builder_.add_nt(nt);
  builder_.add_ny(ny);
  builder_.add_nx(nx);
  builder_.add_type(type);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Array3Meta> CreateArray3MetaDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    fbs::ArrayDataType type = fbs::ArrayDataType_FLOAT,
    int32_t nx = 0,
    int32_t ny = 0,
    int32_t nt = 0,
    fbs::BitRange bitrange = fbs::BitRange_AUTODETECT,
    fbs::ColorMap cmap = fbs::ColorMap_DEFAULT,
    float vmin = 0.0f,
    float vmax = 0.0f,
    fbs::OpacityFunction opacity = fbs::OpacityFunction_NONE,
    const char *name = nullptr,
    const char *parent_name = nullptr,
    float duration = 0.0f,
    float fps = 0.0f,
    const char *date = nullptr,
    const char *comment = nullptr,
    const std::vector<::flatbuffers::Offset<fbs::DictEntry>> *metadata = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto parent_name__ = parent_name ? _fbb.CreateString(parent_name) : 0;
  auto date__ = date ? _fbb.CreateString(date) : 0;
  auto comment__ = comment ? _fbb.CreateString(comment) : 0;
  auto metadata__ = metadata ? _fbb.CreateVector<::flatbuffers::Offset<fbs::DictEntry>>(*metadata) : 0;
  return fbs::CreateArray3Meta(
      _fbb,
      type,
      nx,
      ny,
      nt,
      bitrange,
      cmap,
      vmin,
      vmax,
      opacity,
      name__,
      parent_name__,
      duration,
      fps,
      date__,
      comment__,
      metadata__);
}

struct Array3MetaFlow FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Array3MetaFlowBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NX = 4,
    VT_NY = 6,
    VT_NT = 8,
    VT_NAME = 10,
    VT_PARENT_NAME = 12,
    VT_COLOR = 14
  };
  int32_t nx() const {
    return GetField<int32_t>(VT_NX, 0);
  }
  int32_t ny() const {
    return GetField<int32_t>(VT_NY, 0);
  }
  int32_t nt() const {
    return GetField<int32_t>(VT_NT, 0);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::String *parent_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PARENT_NAME);
  }
  const fbs::Color *color() const {
    return GetStruct<const fbs::Color *>(VT_COLOR);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_NX, 4) &&
           VerifyField<int32_t>(verifier, VT_NY, 4) &&
           VerifyField<int32_t>(verifier, VT_NT, 4) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_PARENT_NAME) &&
           verifier.VerifyString(parent_name()) &&
           VerifyField<fbs::Color>(verifier, VT_COLOR, 4) &&
           verifier.EndTable();
  }
};

struct Array3MetaFlowBuilder {
  typedef Array3MetaFlow Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_nx(int32_t nx) {
    fbb_.AddElement<int32_t>(Array3MetaFlow::VT_NX, nx, 0);
  }
  void add_ny(int32_t ny) {
    fbb_.AddElement<int32_t>(Array3MetaFlow::VT_NY, ny, 0);
  }
  void add_nt(int32_t nt) {
    fbb_.AddElement<int32_t>(Array3MetaFlow::VT_NT, nt, 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Array3MetaFlow::VT_NAME, name);
  }
  void add_parent_name(::flatbuffers::Offset<::flatbuffers::String> parent_name) {
    fbb_.AddOffset(Array3MetaFlow::VT_PARENT_NAME, parent_name);
  }
  void add_color(const fbs::Color *color) {
    fbb_.AddStruct(Array3MetaFlow::VT_COLOR, color);
  }
  explicit Array3MetaFlowBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Array3MetaFlow> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Array3MetaFlow>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Array3MetaFlow> CreateArray3MetaFlow(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t nx = 0,
    int32_t ny = 0,
    int32_t nt = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::String> parent_name = 0,
    const fbs::Color *color = nullptr) {
  Array3MetaFlowBuilder builder_(_fbb);
  builder_.add_color(color);
  builder_.add_parent_name(parent_name);
  builder_.add_name(name);
  builder_.add_nt(nt);
  builder_.add_ny(ny);
  builder_.add_nx(nx);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Array3MetaFlow> CreateArray3MetaFlowDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t nx = 0,
    int32_t ny = 0,
    int32_t nt = 0,
    const char *name = nullptr,
    const char *parent_name = nullptr,
    const fbs::Color *color = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto parent_name__ = parent_name ? _fbb.CreateString(parent_name) : 0;
  return fbs::CreateArray3MetaFlow(
      _fbb,
      nx,
      ny,
      nt,
      name__,
      parent_name__,
      color);
}

struct Array3DataChunkf FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Array3DataChunkfBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STARTIDX = 4,
    VT_DATA = 6
  };
  uint64_t startidx() const {
    return GetField<uint64_t>(VT_STARTIDX, 0);
  }
  const ::flatbuffers::Vector<float> *data() const {
    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_STARTIDX, 8) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct Array3DataChunkfBuilder {
  typedef Array3DataChunkf Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_startidx(uint64_t startidx) {
    fbb_.AddElement<uint64_t>(Array3DataChunkf::VT_STARTIDX, startidx, 0);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<float>> data) {
    fbb_.AddOffset(Array3DataChunkf::VT_DATA, data);
  }
  explicit Array3DataChunkfBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Array3DataChunkf> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Array3DataChunkf>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Array3DataChunkf> CreateArray3DataChunkf(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t startidx = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> data = 0) {
  Array3DataChunkfBuilder builder_(_fbb);
  builder_.add_startidx(startidx);
  builder_.add_data(data);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Array3DataChunkf> CreateArray3DataChunkfDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t startidx = 0,
    const std::vector<float> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<float>(*data) : 0;
  return fbs::CreateArray3DataChunkf(
      _fbb,
      startidx,
      data__);
}

struct Array3DataChunku8 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Array3DataChunku8Builder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STARTIDX = 4,
    VT_DATA = 6
  };
  uint64_t startidx() const {
    return GetField<uint64_t>(VT_STARTIDX, 0);
  }
  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) &&
           VerifyField<uint64_t>(verifier, VT_STARTIDX, 8) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct Array3DataChunku8Builder {
  typedef Array3DataChunku8 Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_startidx(uint64_t startidx) {
    fbb_.AddElement<uint64_t>(Array3DataChunku8::VT_STARTIDX, startidx, 0);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(Array3DataChunku8::VT_DATA, data);
  }
  explicit Array3DataChunku8Builder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Array3DataChunku8> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Array3DataChunku8>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Array3DataChunku8> CreateArray3DataChunku8(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t startidx = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
  Array3DataChunku8Builder builder_(_fbb);
  builder_.add_startidx(startidx);
  builder_.add_data(data);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Array3DataChunku8> CreateArray3DataChunku8Direct(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t startidx = 0,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return fbs::CreateArray3DataChunku8(
      _fbb,
      startidx,
      data__);
}

struct Array3DataChunku16 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Array3DataChunku16Builder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STARTIDX = 4,
    VT_DATA = 6
  };
  uint64_t startidx() const {
    return GetField<uint64_t>(VT_STARTIDX, 0);
  }
  const ::flatbuffers::Vector<uint16_t> *data() const {
    return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_STARTIDX, 8) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct Array3DataChunku16Builder {
  typedef Array3DataChunku16 Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_startidx(uint64_t startidx) {
    fbb_.AddElement<uint64_t>(Array3DataChunku16::VT_STARTIDX, startidx, 0);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> data) {
    fbb_.AddOffset(Array3DataChunku16::VT_DATA, data);
  }
  explicit Array3DataChunku16Builder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Array3DataChunku16> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Array3DataChunku16>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Array3DataChunku16> CreateArray3DataChunku16(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t startidx = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> data = 0) {
  Array3DataChunku16Builder builder_(_fbb);
  builder_.add_startidx(startidx);
  builder_.add_data(data);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Array3DataChunku16> CreateArray3DataChunku16Direct(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t startidx = 0,
    const std::vector<uint16_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint16_t>(*data) : 0;
  return fbs::CreateArray3DataChunku16(
      _fbb,
      startidx,
      data__);
}

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

struct FilepathsBuilder {
  typedef Filepaths Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_file(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> file) {
    fbb_.AddOffset(Filepaths::VT_FILE, file);
  }
  explicit FilepathsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Filepaths> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Filepaths>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Filepaths> CreateFilepaths(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> file = 0) {
  FilepathsBuilder builder_(_fbb);
  builder_.add_file(file);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Filepaths> CreateFilepathsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *file = nullptr) {
  auto file__ = file ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*file) : 0;
  return fbs::CreateFilepaths(
      _fbb,
      file__);
}

struct VideoExport FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VideoExportBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RECORDING = 4,
    VT_FILEPATH = 6,
    VT_DESCRIPTION = 8,
    VT_FORMAT = 10,
    VT_FPS = 12,
    VT_T_START = 14,
    VT_T_END = 16,
    VT_CLOSE_AFTER_COMPLETION = 18
  };
  const ::flatbuffers::String *recording() const {
    return GetPointer<const ::flatbuffers::String *>(VT_RECORDING);
  }
  const ::flatbuffers::String *filepath() const {
    return GetPointer<const ::flatbuffers::String *>(VT_FILEPATH);
  }
  const ::flatbuffers::String *description() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
  }
  fbs::VideoExportFormat format() const {
    return static_cast<fbs::VideoExportFormat>(GetField<int32_t>(VT_FORMAT, 0));
  }
  float fps() const {
    return GetField<float>(VT_FPS, 0.0f);
  }
  int32_t t_start() const {
    return GetField<int32_t>(VT_T_START, 0);
  }
  int32_t t_end() const {
    return GetField<int32_t>(VT_T_END, 0);
  }
  bool close_after_completion() const {
    return GetField<uint8_t>(VT_CLOSE_AFTER_COMPLETION, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_RECORDING) &&
           verifier.VerifyString(recording()) &&
           VerifyOffset(verifier, VT_FILEPATH) &&
           verifier.VerifyString(filepath()) &&
           VerifyOffset(verifier, VT_DESCRIPTION) &&
           verifier.VerifyString(description()) &&
           VerifyField<int32_t>(verifier, VT_FORMAT, 4) &&
           VerifyField<float>(verifier, VT_FPS, 4) &&
           VerifyField<int32_t>(verifier, VT_T_START, 4) &&
           VerifyField<int32_t>(verifier, VT_T_END, 4) &&
           VerifyField<uint8_t>(verifier, VT_CLOSE_AFTER_COMPLETION, 1) &&
           verifier.EndTable();
  }
};

struct VideoExportBuilder {
  typedef VideoExport Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_recording(::flatbuffers::Offset<::flatbuffers::String> recording) {
    fbb_.AddOffset(VideoExport::VT_RECORDING, recording);
  }
  void add_filepath(::flatbuffers::Offset<::flatbuffers::String> filepath) {
    fbb_.AddOffset(VideoExport::VT_FILEPATH, filepath);
  }
  void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
    fbb_.AddOffset(VideoExport::VT_DESCRIPTION, description);
  }
  void add_format(fbs::VideoExportFormat format) {
    fbb_.AddElement<int32_t>(VideoExport::VT_FORMAT, static_cast<int32_t>(format), 0);
  }
  void add_fps(float fps) {
    fbb_.AddElement<float>(VideoExport::VT_FPS, fps, 0.0f);
  }
  void add_t_start(int32_t t_start) {
    fbb_.AddElement<int32_t>(VideoExport::VT_T_START, t_start, 0);
  }
  void add_t_end(int32_t t_end) {
    fbb_.AddElement<int32_t>(VideoExport::VT_T_END, t_end, 0);
  }
  void add_close_after_completion(bool close_after_completion) {
    fbb_.AddElement<uint8_t>(VideoExport::VT_CLOSE_AFTER_COMPLETION, static_cast<uint8_t>(close_after_completion), 0);
  }
  explicit VideoExportBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VideoExport> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VideoExport>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VideoExport> CreateVideoExport(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> recording = 0,
    ::flatbuffers::Offset<::flatbuffers::String> filepath = 0,
    ::flatbuffers::Offset<::flatbuffers::String> description = 0,
    fbs::VideoExportFormat format = fbs::VideoExportFormat_FFMPEG,
    float fps = 0.0f,
    int32_t t_start = 0,
    int32_t t_end = 0,
    bool close_after_completion = false) {
  VideoExportBuilder builder_(_fbb);
  builder_.add_t_end(t_end);
  builder_.add_t_start(t_start);
  builder_.add_fps(fps);
  builder_.add_format(format);
  builder_.add_description(description);
  builder_.add_filepath(filepath);
  builder_.add_recording(recording);
  builder_.add_close_after_completion(close_after_completion);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VideoExport> CreateVideoExportDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *recording = nullptr,
    const char *filepath = nullptr,
    const char *description = nullptr,
    fbs::VideoExportFormat format = fbs::VideoExportFormat_FFMPEG,
    float fps = 0.0f,
    int32_t t_start = 0,
    int32_t t_end = 0,
    bool close_after_completion = false) {
  auto recording__ = recording ? _fbb.CreateString(recording) : 0;
  auto filepath__ = filepath ? _fbb.CreateString(filepath) : 0;
  auto description__ = description ? _fbb.CreateString(description) : 0;
  return fbs::CreateVideoExport(
      _fbb,
      recording__,
      filepath__,
      description__,
      format,
      fps,
      t_start,
      t_end,
      close_after_completion);
}

struct CloseVideo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CloseVideoBuilder Builder;
  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) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};

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

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

inline ::flatbuffers::Offset<CloseVideo> CreateCloseVideoDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return fbs::CreateCloseVideo(
      _fbb,
      name__);
}

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

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

inline ::flatbuffers::Offset<Quit> CreateQuit(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  QuitBuilder builder_(_fbb);
  return builder_.Finish();
}

struct PointsVideo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PointsVideoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_PARENT_NAME = 6,
    VT_POINTS_DATA = 8,
    VT_TIME_IDXS = 10,
    VT_COLOR = 12,
    VT_POINT_SIZE = 14
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::String *parent_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PARENT_NAME);
  }
  const ::flatbuffers::Vector<float> *points_data() const {
    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_POINTS_DATA);
  }
  const ::flatbuffers::Vector<uint32_t> *time_idxs() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_TIME_IDXS);
  }
  const fbs::Color *color() const {
    return GetStruct<const fbs::Color *>(VT_COLOR);
  }
  float point_size() const {
    return GetField<float>(VT_POINT_SIZE, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_PARENT_NAME) &&
           verifier.VerifyString(parent_name()) &&
           VerifyOffset(verifier, VT_POINTS_DATA) &&
           verifier.VerifyVector(points_data()) &&
           VerifyOffset(verifier, VT_TIME_IDXS) &&
           verifier.VerifyVector(time_idxs()) &&
           VerifyField<fbs::Color>(verifier, VT_COLOR, 4) &&
           VerifyField<float>(verifier, VT_POINT_SIZE, 4) &&
           verifier.EndTable();
  }
};

struct PointsVideoBuilder {
  typedef PointsVideo Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(PointsVideo::VT_NAME, name);
  }
  void add_parent_name(::flatbuffers::Offset<::flatbuffers::String> parent_name) {
    fbb_.AddOffset(PointsVideo::VT_PARENT_NAME, parent_name);
  }
  void add_points_data(::flatbuffers::Offset<::flatbuffers::Vector<float>> points_data) {
    fbb_.AddOffset(PointsVideo::VT_POINTS_DATA, points_data);
  }
  void add_time_idxs(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> time_idxs) {
    fbb_.AddOffset(PointsVideo::VT_TIME_IDXS, time_idxs);
  }
  void add_color(const fbs::Color *color) {
    fbb_.AddStruct(PointsVideo::VT_COLOR, color);
  }
  void add_point_size(float point_size) {
    fbb_.AddElement<float>(PointsVideo::VT_POINT_SIZE, point_size, 0.0f);
  }
  explicit PointsVideoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PointsVideo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PointsVideo>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PointsVideo> CreatePointsVideo(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::String> parent_name = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> points_data = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> time_idxs = 0,
    const fbs::Color *color = nullptr,
    float point_size = 0.0f) {
  PointsVideoBuilder builder_(_fbb);
  builder_.add_point_size(point_size);
  builder_.add_color(color);
  builder_.add_time_idxs(time_idxs);
  builder_.add_points_data(points_data);
  builder_.add_parent_name(parent_name);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<PointsVideo> CreatePointsVideoDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const char *parent_name = nullptr,
    const std::vector<float> *points_data = nullptr,
    const std::vector<uint32_t> *time_idxs = nullptr,
    const fbs::Color *color = nullptr,
    float point_size = 0.0f) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto parent_name__ = parent_name ? _fbb.CreateString(parent_name) : 0;
  auto points_data__ = points_data ? _fbb.CreateVector<float>(*points_data) : 0;
  auto time_idxs__ = time_idxs ? _fbb.CreateVector<uint32_t>(*time_idxs) : 0;
  return fbs::CreatePointsVideo(
      _fbb,
      name__,
      parent_name__,
      points_data__,
      time_idxs__,
      color,
      point_size);
}

struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RootBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA_TYPE = 4,
    VT_DATA = 6
  };
  fbs::Data data_type() const {
    return static_cast<fbs::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 fbs::Filepaths *data_as_Filepaths() const {
    return data_type() == fbs::Data_Filepaths ? static_cast<const fbs::Filepaths *>(data()) : nullptr;
  }
  const fbs::Array3Meta *data_as_Array3Meta() const {
    return data_type() == fbs::Data_Array3Meta ? static_cast<const fbs::Array3Meta *>(data()) : nullptr;
  }
  const fbs::Array3MetaFlow *data_as_Array3MetaFlow() const {
    return data_type() == fbs::Data_Array3MetaFlow ? static_cast<const fbs::Array3MetaFlow *>(data()) : nullptr;
  }
  const fbs::Array3DataChunkf *data_as_Array3DataChunkf() const {
    return data_type() == fbs::Data_Array3DataChunkf ? static_cast<const fbs::Array3DataChunkf *>(data()) : nullptr;
  }
  const fbs::Array3DataChunku8 *data_as_Array3DataChunku8() const {
    return data_type() == fbs::Data_Array3DataChunku8 ? static_cast<const fbs::Array3DataChunku8 *>(data()) : nullptr;
  }
  const fbs::Array3DataChunku16 *data_as_Array3DataChunku16() const {
    return data_type() == fbs::Data_Array3DataChunku16 ? static_cast<const fbs::Array3DataChunku16 *>(data()) : nullptr;
  }
  const fbs::VideoExport *data_as_VideoExport() const {
    return data_type() == fbs::Data_VideoExport ? static_cast<const fbs::VideoExport *>(data()) : nullptr;
  }
  const fbs::PointsVideo *data_as_PointsVideo() const {
    return data_type() == fbs::Data_PointsVideo ? static_cast<const fbs::PointsVideo *>(data()) : nullptr;
  }
  const fbs::CloseVideo *data_as_CloseVideo() const {
    return data_type() == fbs::Data_CloseVideo ? static_cast<const fbs::CloseVideo *>(data()) : nullptr;
  }
  const fbs::Quit *data_as_Quit() const {
    return data_type() == fbs::Data_Quit ? static_cast<const fbs::Quit *>(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 fbs::Filepaths *Root::data_as<fbs::Filepaths>() const {
  return data_as_Filepaths();
}

template<> inline const fbs::Array3Meta *Root::data_as<fbs::Array3Meta>() const {
  return data_as_Array3Meta();
}

template<> inline const fbs::Array3MetaFlow *Root::data_as<fbs::Array3MetaFlow>() const {
  return data_as_Array3MetaFlow();
}

template<> inline const fbs::Array3DataChunkf *Root::data_as<fbs::Array3DataChunkf>() const {
  return data_as_Array3DataChunkf();
}

template<> inline const fbs::Array3DataChunku8 *Root::data_as<fbs::Array3DataChunku8>() const {
  return data_as_Array3DataChunku8();
}

template<> inline const fbs::Array3DataChunku16 *Root::data_as<fbs::Array3DataChunku16>() const {
  return data_as_Array3DataChunku16();
}

template<> inline const fbs::VideoExport *Root::data_as<fbs::VideoExport>() const {
  return data_as_VideoExport();
}

template<> inline const fbs::PointsVideo *Root::data_as<fbs::PointsVideo>() const {
  return data_as_PointsVideo();
}

template<> inline const fbs::CloseVideo *Root::data_as<fbs::CloseVideo>() const {
  return data_as_CloseVideo();
}

template<> inline const fbs::Quit *Root::data_as<fbs::Quit>() const {
  return data_as_Quit();
}

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

inline ::flatbuffers::Offset<Root> CreateRoot(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    fbs::Data data_type = fbs::Data_NONE,
    ::flatbuffers::Offset<void> data = 0) {
  RootBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}

inline bool VerifyData(::flatbuffers::Verifier &verifier, const void *obj, Data type) {
  switch (type) {
    case Data_NONE: {
      return true;
    }
    case Data_Filepaths: {
      auto ptr = reinterpret_cast<const fbs::Filepaths *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_Array3Meta: {
      auto ptr = reinterpret_cast<const fbs::Array3Meta *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_Array3MetaFlow: {
      auto ptr = reinterpret_cast<const fbs::Array3MetaFlow *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_Array3DataChunkf: {
      auto ptr = reinterpret_cast<const fbs::Array3DataChunkf *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_Array3DataChunku8: {
      auto ptr = reinterpret_cast<const fbs::Array3DataChunku8 *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_Array3DataChunku16: {
      auto ptr = reinterpret_cast<const fbs::Array3DataChunku16 *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_VideoExport: {
      auto ptr = reinterpret_cast<const fbs::VideoExport *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_PointsVideo: {
      auto ptr = reinterpret_cast<const fbs::PointsVideo *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_CloseVideo: {
      auto ptr = reinterpret_cast<const fbs::CloseVideo *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Data_Quit: {
      auto ptr = reinterpret_cast<const fbs::Quit *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyDataVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *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 const fbs::Root *GetRoot(const void *buf) {
  return ::flatbuffers::GetRoot<fbs::Root>(buf);
}

inline const fbs::Root *GetSizePrefixedRoot(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<fbs::Root>(buf);
}

inline bool VerifyRootBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<fbs::Root>(nullptr);
}

inline bool VerifySizePrefixedRootBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<fbs::Root>(nullptr);
}

inline void FinishRootBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<fbs::Root> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedRootBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<fbs::Root> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace fbs

#endif  // FLATBUFFERS_GENERATED_MESSAGE_FBS_H_
