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


#ifndef FLATBUFFERS_GENERATED_SIGMFSDRANGEL_SDRANGEL_H_
#define FLATBUFFERS_GENERATED_SIGMFSDRANGEL_SDRANGEL_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 sdrangel {

struct Global;
struct GlobalBuilder;
struct GlobalT;

struct Capture;
struct CaptureBuilder;
struct CaptureT;

struct Annotation;
struct AnnotationBuilder;
struct AnnotationT;

struct Descr;
struct DescrBuilder;
struct DescrT;

inline const ::flatbuffers::TypeTable *GlobalTypeTable();

inline const ::flatbuffers::TypeTable *CaptureTypeTable();

inline const ::flatbuffers::TypeTable *AnnotationTypeTable();

inline const ::flatbuffers::TypeTable *DescrTypeTable();

struct GlobalT : public ::flatbuffers::NativeTable {
  typedef Global TableType;
  std::string version{};
  std::string qt_version{};
  int32_t rx_bits = 0;
  std::string arch{};
  std::string os{};
};

struct Global FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GlobalT NativeTableType;
  typedef GlobalBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GlobalTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VERSION = 4,
    VT_QT_VERSION = 6,
    VT_RX_BITS = 8,
    VT_ARCH = 10,
    VT_OS = 12
  };
  const ::flatbuffers::String *version() const {
    return GetPointer<const ::flatbuffers::String *>(VT_VERSION);
  }
  const ::flatbuffers::String *qt_version() const {
    return GetPointer<const ::flatbuffers::String *>(VT_QT_VERSION);
  }
  int32_t rx_bits() const {
    return GetField<int32_t>(VT_RX_BITS, 0);
  }
  const ::flatbuffers::String *arch() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ARCH);
  }
  const ::flatbuffers::String *os() const {
    return GetPointer<const ::flatbuffers::String *>(VT_OS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_VERSION) &&
           verifier.VerifyString(version()) &&
           VerifyOffset(verifier, VT_QT_VERSION) &&
           verifier.VerifyString(qt_version()) &&
           VerifyField<int32_t>(verifier, VT_RX_BITS, 4) &&
           VerifyOffset(verifier, VT_ARCH) &&
           verifier.VerifyString(arch()) &&
           VerifyOffset(verifier, VT_OS) &&
           verifier.VerifyString(os()) &&
           verifier.EndTable();
  }
  GlobalT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(GlobalT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<Global> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GlobalT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct GlobalBuilder {
  typedef Global Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_version(::flatbuffers::Offset<::flatbuffers::String> version) {
    fbb_.AddOffset(Global::VT_VERSION, version);
  }
  void add_qt_version(::flatbuffers::Offset<::flatbuffers::String> qt_version) {
    fbb_.AddOffset(Global::VT_QT_VERSION, qt_version);
  }
  void add_rx_bits(int32_t rx_bits) {
    fbb_.AddElement<int32_t>(Global::VT_RX_BITS, rx_bits, 0);
  }
  void add_arch(::flatbuffers::Offset<::flatbuffers::String> arch) {
    fbb_.AddOffset(Global::VT_ARCH, arch);
  }
  void add_os(::flatbuffers::Offset<::flatbuffers::String> os) {
    fbb_.AddOffset(Global::VT_OS, os);
  }
  explicit GlobalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Global> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Global>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Global> CreateGlobal(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> version = 0,
    ::flatbuffers::Offset<::flatbuffers::String> qt_version = 0,
    int32_t rx_bits = 0,
    ::flatbuffers::Offset<::flatbuffers::String> arch = 0,
    ::flatbuffers::Offset<::flatbuffers::String> os = 0) {
  GlobalBuilder builder_(_fbb);
  builder_.add_os(os);
  builder_.add_arch(arch);
  builder_.add_rx_bits(rx_bits);
  builder_.add_qt_version(qt_version);
  builder_.add_version(version);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Global> CreateGlobalDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *version = nullptr,
    const char *qt_version = nullptr,
    int32_t rx_bits = 0,
    const char *arch = nullptr,
    const char *os = nullptr) {
  auto version__ = version ? _fbb.CreateString(version) : 0;
  auto qt_version__ = qt_version ? _fbb.CreateString(qt_version) : 0;
  auto arch__ = arch ? _fbb.CreateString(arch) : 0;
  auto os__ = os ? _fbb.CreateString(os) : 0;
  return sdrangel::CreateGlobal(
      _fbb,
      version__,
      qt_version__,
      rx_bits,
      arch__,
      os__);
}

::flatbuffers::Offset<Global> CreateGlobal(::flatbuffers::FlatBufferBuilder &_fbb, const GlobalT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CaptureT : public ::flatbuffers::NativeTable {
  typedef Capture TableType;
  int32_t sample_rate = 0;
  uint64_t tsms = 0;
};

struct Capture FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CaptureT NativeTableType;
  typedef CaptureBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CaptureTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SAMPLE_RATE = 4,
    VT_TSMS = 6
  };
  int32_t sample_rate() const {
    return GetField<int32_t>(VT_SAMPLE_RATE, 0);
  }
  uint64_t tsms() const {
    return GetField<uint64_t>(VT_TSMS, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_SAMPLE_RATE, 4) &&
           VerifyField<uint64_t>(verifier, VT_TSMS, 8) &&
           verifier.EndTable();
  }
  CaptureT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(CaptureT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<Capture> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CaptureT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct CaptureBuilder {
  typedef Capture Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_sample_rate(int32_t sample_rate) {
    fbb_.AddElement<int32_t>(Capture::VT_SAMPLE_RATE, sample_rate, 0);
  }
  void add_tsms(uint64_t tsms) {
    fbb_.AddElement<uint64_t>(Capture::VT_TSMS, tsms, 0);
  }
  explicit CaptureBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Capture> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Capture>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Capture> CreateCapture(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t sample_rate = 0,
    uint64_t tsms = 0) {
  CaptureBuilder builder_(_fbb);
  builder_.add_tsms(tsms);
  builder_.add_sample_rate(sample_rate);
  return builder_.Finish();
}

::flatbuffers::Offset<Capture> CreateCapture(::flatbuffers::FlatBufferBuilder &_fbb, const CaptureT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct AnnotationT : public ::flatbuffers::NativeTable {
  typedef Annotation TableType;
};

struct Annotation FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AnnotationT NativeTableType;
  typedef AnnotationBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AnnotationTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  AnnotationT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(AnnotationT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<Annotation> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

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

inline ::flatbuffers::Offset<Annotation> CreateAnnotation(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  AnnotationBuilder builder_(_fbb);
  return builder_.Finish();
}

::flatbuffers::Offset<Annotation> CreateAnnotation(::flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct DescrT : public ::flatbuffers::NativeTable {
  typedef Descr TableType;
  std::unique_ptr<sdrangel::GlobalT> global{};
  std::unique_ptr<sdrangel::AnnotationT> annotation{};
  std::unique_ptr<sdrangel::CaptureT> capture{};
  DescrT() = default;
  DescrT(const DescrT &o);
  DescrT(DescrT&&) FLATBUFFERS_NOEXCEPT = default;
  DescrT &operator=(DescrT o) FLATBUFFERS_NOEXCEPT;
};

struct Descr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DescrT NativeTableType;
  typedef DescrBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DescrTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL = 4,
    VT_ANNOTATION = 6,
    VT_CAPTURE = 8
  };
  const sdrangel::Global *global() const {
    return GetPointer<const sdrangel::Global *>(VT_GLOBAL);
  }
  const sdrangel::Annotation *annotation() const {
    return GetPointer<const sdrangel::Annotation *>(VT_ANNOTATION);
  }
  const sdrangel::Capture *capture() const {
    return GetPointer<const sdrangel::Capture *>(VT_CAPTURE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_GLOBAL) &&
           verifier.VerifyTable(global()) &&
           VerifyOffset(verifier, VT_ANNOTATION) &&
           verifier.VerifyTable(annotation()) &&
           VerifyOffset(verifier, VT_CAPTURE) &&
           verifier.VerifyTable(capture()) &&
           verifier.EndTable();
  }
  DescrT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(DescrT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<Descr> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DescrT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct DescrBuilder {
  typedef Descr Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global(::flatbuffers::Offset<sdrangel::Global> global) {
    fbb_.AddOffset(Descr::VT_GLOBAL, global);
  }
  void add_annotation(::flatbuffers::Offset<sdrangel::Annotation> annotation) {
    fbb_.AddOffset(Descr::VT_ANNOTATION, annotation);
  }
  void add_capture(::flatbuffers::Offset<sdrangel::Capture> capture) {
    fbb_.AddOffset(Descr::VT_CAPTURE, capture);
  }
  explicit DescrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Descr> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Descr>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Descr> CreateDescr(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<sdrangel::Global> global = 0,
    ::flatbuffers::Offset<sdrangel::Annotation> annotation = 0,
    ::flatbuffers::Offset<sdrangel::Capture> capture = 0) {
  DescrBuilder builder_(_fbb);
  builder_.add_capture(capture);
  builder_.add_annotation(annotation);
  builder_.add_global(global);
  return builder_.Finish();
}

::flatbuffers::Offset<Descr> CreateDescr(::flatbuffers::FlatBufferBuilder &_fbb, const DescrT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

inline GlobalT *Global::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::unique_ptr<GlobalT>(new GlobalT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void Global::UnPackTo(GlobalT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = version(); if (_e) _o->version = _e->str(); }
  { auto _e = qt_version(); if (_e) _o->qt_version = _e->str(); }
  { auto _e = rx_bits(); _o->rx_bits = _e; }
  { auto _e = arch(); if (_e) _o->arch = _e->str(); }
  { auto _e = os(); if (_e) _o->os = _e->str(); }
}

inline ::flatbuffers::Offset<Global> Global::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GlobalT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return CreateGlobal(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<Global> CreateGlobal(::flatbuffers::FlatBufferBuilder &_fbb, const GlobalT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GlobalT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _version = _o->version.empty() ? 0 : _fbb.CreateString(_o->version);
  auto _qt_version = _o->qt_version.empty() ? 0 : _fbb.CreateString(_o->qt_version);
  auto _rx_bits = _o->rx_bits;
  auto _arch = _o->arch.empty() ? 0 : _fbb.CreateString(_o->arch);
  auto _os = _o->os.empty() ? 0 : _fbb.CreateString(_o->os);
  return sdrangel::CreateGlobal(
      _fbb,
      _version,
      _qt_version,
      _rx_bits,
      _arch,
      _os);
}

inline CaptureT *Capture::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::unique_ptr<CaptureT>(new CaptureT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void Capture::UnPackTo(CaptureT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = sample_rate(); _o->sample_rate = _e; }
  { auto _e = tsms(); _o->tsms = _e; }
}

inline ::flatbuffers::Offset<Capture> Capture::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CaptureT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return CreateCapture(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<Capture> CreateCapture(::flatbuffers::FlatBufferBuilder &_fbb, const CaptureT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CaptureT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _sample_rate = _o->sample_rate;
  auto _tsms = _o->tsms;
  return sdrangel::CreateCapture(
      _fbb,
      _sample_rate,
      _tsms);
}

inline AnnotationT *Annotation::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::unique_ptr<AnnotationT>(new AnnotationT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void Annotation::UnPackTo(AnnotationT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline ::flatbuffers::Offset<Annotation> Annotation::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return CreateAnnotation(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<Annotation> CreateAnnotation(::flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AnnotationT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return sdrangel::CreateAnnotation(
      _fbb);
}

inline DescrT::DescrT(const DescrT &o)
      : global((o.global) ? new sdrangel::GlobalT(*o.global) : nullptr),
        annotation((o.annotation) ? new sdrangel::AnnotationT(*o.annotation) : nullptr),
        capture((o.capture) ? new sdrangel::CaptureT(*o.capture) : nullptr) {
}

inline DescrT &DescrT::operator=(DescrT o) FLATBUFFERS_NOEXCEPT {
  std::swap(global, o.global);
  std::swap(annotation, o.annotation);
  std::swap(capture, o.capture);
  return *this;
}

inline DescrT *Descr::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::unique_ptr<DescrT>(new DescrT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void Descr::UnPackTo(DescrT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = global(); if (_e) { if(_o->global) { _e->UnPackTo(_o->global.get(), _resolver); } else { _o->global = std::unique_ptr<sdrangel::GlobalT>(_e->UnPack(_resolver)); } } else if (_o->global) { _o->global.reset(); } }
  { auto _e = annotation(); if (_e) { if(_o->annotation) { _e->UnPackTo(_o->annotation.get(), _resolver); } else { _o->annotation = std::unique_ptr<sdrangel::AnnotationT>(_e->UnPack(_resolver)); } } else if (_o->annotation) { _o->annotation.reset(); } }
  { auto _e = capture(); if (_e) { if(_o->capture) { _e->UnPackTo(_o->capture.get(), _resolver); } else { _o->capture = std::unique_ptr<sdrangel::CaptureT>(_e->UnPack(_resolver)); } } else if (_o->capture) { _o->capture.reset(); } }
}

inline ::flatbuffers::Offset<Descr> Descr::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DescrT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return CreateDescr(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<Descr> CreateDescr(::flatbuffers::FlatBufferBuilder &_fbb, const DescrT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const DescrT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _global = _o->global ? CreateGlobal(_fbb, _o->global.get(), _rehasher) : 0;
  auto _annotation = _o->annotation ? CreateAnnotation(_fbb, _o->annotation.get(), _rehasher) : 0;
  auto _capture = _o->capture ? CreateCapture(_fbb, _o->capture.get(), _rehasher) : 0;
  return sdrangel::CreateDescr(
      _fbb,
      _global,
      _annotation,
      _capture);
}

inline const ::flatbuffers::TypeTable *GlobalTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 }
  };
  static const char * const names[] = {
    "version",
    "qt_version",
    "rx_bits",
    "arch",
    "os"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CaptureTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_ULONG, 0, -1 }
  };
  static const char * const names[] = {
    "sample_rate",
    "tsms"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *AnnotationTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DescrTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 2 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    sdrangel::GlobalTypeTable,
    sdrangel::AnnotationTypeTable,
    sdrangel::CaptureTypeTable
  };
  static const char * const names[] = {
    "global",
    "annotation",
    "capture"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

}  // namespace sdrangel

#endif  // FLATBUFFERS_GENERATED_SIGMFSDRANGEL_SDRANGEL_H_
