consumer_generated

consumer_generated.h

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


#ifndef FLATBUFFERS_GENERATED_CONSUMER_FBS_CONSUMER_H_
#define FLATBUFFERS_GENERATED_CONSUMER_FBS_CONSUMER_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 == 22 &&
              FLATBUFFERS_VERSION_MINOR == 11 &&
              FLATBUFFERS_VERSION_REVISION == 23,
             "Non-compatible flatbuffers version included");

#include "rtpParameters_generated.h"
#include "rtpStream_generated.h"

namespace FBS {
namespace Consumer {

struct ConsumerLayers;
struct ConsumerLayersBuilder;

struct ConsumerScore;
struct ConsumerScoreBuilder;

struct SetPreferredLayersRequest;
struct SetPreferredLayersRequestBuilder;

struct SetPreferredLayersResponse;
struct SetPreferredLayersResponseBuilder;

struct SetPriorityRequest;
struct SetPriorityRequestBuilder;

struct SetPriorityResponse;
struct SetPriorityResponseBuilder;

struct EnableTraceEventRequest;
struct EnableTraceEventRequestBuilder;

struct DumpResponse;
struct DumpResponseBuilder;

struct BaseConsumerDump;
struct BaseConsumerDumpBuilder;

struct SimpleConsumerDump;
struct SimpleConsumerDumpBuilder;

struct SimulcastConsumerDump;
struct SimulcastConsumerDumpBuilder;

struct SvcConsumerDump;
struct SvcConsumerDumpBuilder;

struct PipeConsumerDump;
struct PipeConsumerDumpBuilder;

struct GetStatsResponse;
struct GetStatsResponseBuilder;

struct LayersChangeNotification;
struct LayersChangeNotificationBuilder;

struct RtpNotification;
struct RtpNotificationBuilder;

struct ScoreNotification;
struct ScoreNotificationBuilder;

struct KeyFrameTraceInfo;
struct KeyFrameTraceInfoBuilder;

struct FirTraceInfo;
struct FirTraceInfoBuilder;

struct PliTraceInfo;
struct PliTraceInfoBuilder;

struct RtpTraceInfo;
struct RtpTraceInfoBuilder;

struct TraceNotification;
struct TraceNotificationBuilder;

inline const flatbuffers::TypeTable *ConsumerLayersTypeTable();

inline const flatbuffers::TypeTable *ConsumerScoreTypeTable();

inline const flatbuffers::TypeTable *SetPreferredLayersRequestTypeTable();

inline const flatbuffers::TypeTable *SetPreferredLayersResponseTypeTable();

inline const flatbuffers::TypeTable *SetPriorityRequestTypeTable();

inline const flatbuffers::TypeTable *SetPriorityResponseTypeTable();

inline const flatbuffers::TypeTable *EnableTraceEventRequestTypeTable();

inline const flatbuffers::TypeTable *DumpResponseTypeTable();

inline const flatbuffers::TypeTable *BaseConsumerDumpTypeTable();

inline const flatbuffers::TypeTable *SimpleConsumerDumpTypeTable();

inline const flatbuffers::TypeTable *SimulcastConsumerDumpTypeTable();

inline const flatbuffers::TypeTable *SvcConsumerDumpTypeTable();

inline const flatbuffers::TypeTable *PipeConsumerDumpTypeTable();

inline const flatbuffers::TypeTable *GetStatsResponseTypeTable();

inline const flatbuffers::TypeTable *LayersChangeNotificationTypeTable();

inline const flatbuffers::TypeTable *RtpNotificationTypeTable();

inline const flatbuffers::TypeTable *ScoreNotificationTypeTable();

inline const flatbuffers::TypeTable *KeyFrameTraceInfoTypeTable();

inline const flatbuffers::TypeTable *FirTraceInfoTypeTable();

inline const flatbuffers::TypeTable *PliTraceInfoTypeTable();

inline const flatbuffers::TypeTable *RtpTraceInfoTypeTable();

inline const flatbuffers::TypeTable *TraceNotificationTypeTable();

enum class DumpData : uint8_t {
  NONE = 0,
  SimpleConsumerDump = 1,
  SimulcastConsumerDump = 2,
  SvcConsumerDump = 3,
  PipeConsumerDump = 4,
  MIN = NONE,
  MAX = PipeConsumerDump
};

inline const DumpData (&EnumValuesDumpData())[5] {
  static const DumpData values[] = {
    DumpData::NONE,
    DumpData::SimpleConsumerDump,
    DumpData::SimulcastConsumerDump,
    DumpData::SvcConsumerDump,
    DumpData::PipeConsumerDump
  };
  return values;
}

inline const char * const *EnumNamesDumpData() {
  static const char * const names[6] = {
    "NONE",
    "SimpleConsumerDump",
    "SimulcastConsumerDump",
    "SvcConsumerDump",
    "PipeConsumerDump",
    nullptr
  };
  return names;
}

inline const char *EnumNameDumpData(DumpData e) {
  if (flatbuffers::IsOutRange(e, DumpData::NONE, DumpData::PipeConsumerDump)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDumpData()[index];
}

template<typename T> struct DumpDataTraits {
  static const DumpData enum_value = DumpData::NONE;
};

template<> struct DumpDataTraits<FBS::Consumer::SimpleConsumerDump> {
  static const DumpData enum_value = DumpData::SimpleConsumerDump;
};

template<> struct DumpDataTraits<FBS::Consumer::SimulcastConsumerDump> {
  static const DumpData enum_value = DumpData::SimulcastConsumerDump;
};

template<> struct DumpDataTraits<FBS::Consumer::SvcConsumerDump> {
  static const DumpData enum_value = DumpData::SvcConsumerDump;
};

template<> struct DumpDataTraits<FBS::Consumer::PipeConsumerDump> {
  static const DumpData enum_value = DumpData::PipeConsumerDump;
};

bool VerifyDumpData(flatbuffers::Verifier &verifier, const void *obj, DumpData type);
bool VerifyDumpDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<DumpData> *types);

enum class TraceType : uint8_t {
  KEYFRAME = 0,
  FIR = 1,
  NACK = 2,
  PLI = 3,
  RTP = 4,
  MIN = KEYFRAME,
  MAX = RTP
};

inline const TraceType (&EnumValuesTraceType())[5] {
  static const TraceType values[] = {
    TraceType::KEYFRAME,
    TraceType::FIR,
    TraceType::NACK,
    TraceType::PLI,
    TraceType::RTP
  };
  return values;
}

inline const char * const *EnumNamesTraceType() {
  static const char * const names[6] = {
    "KEYFRAME",
    "FIR",
    "NACK",
    "PLI",
    "RTP",
    nullptr
  };
  return names;
}

inline const char *EnumNameTraceType(TraceType e) {
  if (flatbuffers::IsOutRange(e, TraceType::KEYFRAME, TraceType::RTP)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTraceType()[index];
}

enum class TraceDirection : uint8_t {
  IN = 0,
  OUT = 1,
  MIN = IN,
  MAX = OUT
};

inline const TraceDirection (&EnumValuesTraceDirection())[2] {
  static const TraceDirection values[] = {
    TraceDirection::IN,
    TraceDirection::OUT
  };
  return values;
}

inline const char * const *EnumNamesTraceDirection() {
  static const char * const names[3] = {
    "IN",
    "OUT",
    nullptr
  };
  return names;
}

inline const char *EnumNameTraceDirection(TraceDirection e) {
  if (flatbuffers::IsOutRange(e, TraceDirection::IN, TraceDirection::OUT)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTraceDirection()[index];
}

enum class TraceInfo : uint8_t {
  NONE = 0,
  KeyFrameTraceInfo = 1,
  FirTraceInfo = 2,
  PliTraceInfo = 3,
  RtpTraceInfo = 4,
  MIN = NONE,
  MAX = RtpTraceInfo
};

inline const TraceInfo (&EnumValuesTraceInfo())[5] {
  static const TraceInfo values[] = {
    TraceInfo::NONE,
    TraceInfo::KeyFrameTraceInfo,
    TraceInfo::FirTraceInfo,
    TraceInfo::PliTraceInfo,
    TraceInfo::RtpTraceInfo
  };
  return values;
}

inline const char * const *EnumNamesTraceInfo() {
  static const char * const names[6] = {
    "NONE",
    "KeyFrameTraceInfo",
    "FirTraceInfo",
    "PliTraceInfo",
    "RtpTraceInfo",
    nullptr
  };
  return names;
}

inline const char *EnumNameTraceInfo(TraceInfo e) {
  if (flatbuffers::IsOutRange(e, TraceInfo::NONE, TraceInfo::RtpTraceInfo)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTraceInfo()[index];
}

template<typename T> struct TraceInfoTraits {
  static const TraceInfo enum_value = TraceInfo::NONE;
};

template<> struct TraceInfoTraits<FBS::Consumer::KeyFrameTraceInfo> {
  static const TraceInfo enum_value = TraceInfo::KeyFrameTraceInfo;
};

template<> struct TraceInfoTraits<FBS::Consumer::FirTraceInfo> {
  static const TraceInfo enum_value = TraceInfo::FirTraceInfo;
};

template<> struct TraceInfoTraits<FBS::Consumer::PliTraceInfo> {
  static const TraceInfo enum_value = TraceInfo::PliTraceInfo;
};

template<> struct TraceInfoTraits<FBS::Consumer::RtpTraceInfo> {
  static const TraceInfo enum_value = TraceInfo::RtpTraceInfo;
};

bool VerifyTraceInfo(flatbuffers::Verifier &verifier, const void *obj, TraceInfo type);
bool VerifyTraceInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<TraceInfo> *types);

struct ConsumerLayers FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ConsumerLayersBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ConsumerLayersTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SPATIALLAYER = 4,
    VT_TEMPORALLAYER = 6
  };
  int16_t spatialLayer() const {
    return GetField<int16_t>(VT_SPATIALLAYER, 0);
  }
  flatbuffers::Optional<int16_t> temporalLayer() const {
    return GetOptional<int16_t, int16_t>(VT_TEMPORALLAYER);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int16_t>(verifier, VT_SPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_TEMPORALLAYER, 2) &&
           verifier.EndTable();
  }
};

struct ConsumerLayersBuilder {
  typedef ConsumerLayers Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_spatialLayer(int16_t spatialLayer) {
    fbb_.AddElement<int16_t>(ConsumerLayers::VT_SPATIALLAYER, spatialLayer, 0);
  }
  void add_temporalLayer(int16_t temporalLayer) {
    fbb_.AddElement<int16_t>(ConsumerLayers::VT_TEMPORALLAYER, temporalLayer);
  }
  explicit ConsumerLayersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ConsumerLayers> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ConsumerLayers>(end);
    return o;
  }
};

inline flatbuffers::Offset<ConsumerLayers> CreateConsumerLayers(
    flatbuffers::FlatBufferBuilder &_fbb,
    int16_t spatialLayer = 0,
    flatbuffers::Optional<int16_t> temporalLayer = flatbuffers::nullopt) {
  ConsumerLayersBuilder builder_(_fbb);
  if(temporalLayer) { builder_.add_temporalLayer(*temporalLayer); }
  builder_.add_spatialLayer(spatialLayer);
  return builder_.Finish();
}

struct ConsumerScore FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ConsumerScoreBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ConsumerScoreTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCORE = 4,
    VT_PRODUCERSCORE = 6,
    VT_PRODUCERSCORES = 8
  };
  uint8_t score() const {
    return GetField<uint8_t>(VT_SCORE, 0);
  }
  uint8_t producerScore() const {
    return GetField<uint8_t>(VT_PRODUCERSCORE, 0);
  }
  const flatbuffers::Vector<uint8_t> *producerScores() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PRODUCERSCORES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SCORE, 1) &&
           VerifyField<uint8_t>(verifier, VT_PRODUCERSCORE, 1) &&
           VerifyOffset(verifier, VT_PRODUCERSCORES) &&
           verifier.VerifyVector(producerScores()) &&
           verifier.EndTable();
  }
};

struct ConsumerScoreBuilder {
  typedef ConsumerScore Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_score(uint8_t score) {
    fbb_.AddElement<uint8_t>(ConsumerScore::VT_SCORE, score, 0);
  }
  void add_producerScore(uint8_t producerScore) {
    fbb_.AddElement<uint8_t>(ConsumerScore::VT_PRODUCERSCORE, producerScore, 0);
  }
  void add_producerScores(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> producerScores) {
    fbb_.AddOffset(ConsumerScore::VT_PRODUCERSCORES, producerScores);
  }
  explicit ConsumerScoreBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ConsumerScore> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ConsumerScore>(end);
    return o;
  }
};

inline flatbuffers::Offset<ConsumerScore> CreateConsumerScore(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t score = 0,
    uint8_t producerScore = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> producerScores = 0) {
  ConsumerScoreBuilder builder_(_fbb);
  builder_.add_producerScores(producerScores);
  builder_.add_producerScore(producerScore);
  builder_.add_score(score);
  return builder_.Finish();
}

inline flatbuffers::Offset<ConsumerScore> CreateConsumerScoreDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t score = 0,
    uint8_t producerScore = 0,
    const std::vector<uint8_t> *producerScores = nullptr) {
  auto producerScores__ = producerScores ? _fbb.CreateVector<uint8_t>(*producerScores) : 0;
  return FBS::Consumer::CreateConsumerScore(
      _fbb,
      score,
      producerScore,
      producerScores__);
}

struct SetPreferredLayersRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetPreferredLayersRequestBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SetPreferredLayersRequestTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PREFERREDLAYERS = 4
  };
  const FBS::Consumer::ConsumerLayers *preferredLayers() const {
    return GetPointer<const FBS::Consumer::ConsumerLayers *>(VT_PREFERREDLAYERS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_PREFERREDLAYERS) &&
           verifier.VerifyTable(preferredLayers()) &&
           verifier.EndTable();
  }
};

struct SetPreferredLayersRequestBuilder {
  typedef SetPreferredLayersRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_preferredLayers(flatbuffers::Offset<FBS::Consumer::ConsumerLayers> preferredLayers) {
    fbb_.AddOffset(SetPreferredLayersRequest::VT_PREFERREDLAYERS, preferredLayers);
  }
  explicit SetPreferredLayersRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetPreferredLayersRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetPreferredLayersRequest>(end);
    fbb_.Required(o, SetPreferredLayersRequest::VT_PREFERREDLAYERS);
    return o;
  }
};

inline flatbuffers::Offset<SetPreferredLayersRequest> CreateSetPreferredLayersRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::ConsumerLayers> preferredLayers = 0) {
  SetPreferredLayersRequestBuilder builder_(_fbb);
  builder_.add_preferredLayers(preferredLayers);
  return builder_.Finish();
}

struct SetPreferredLayersResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetPreferredLayersResponseBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SetPreferredLayersResponseTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PREFERREDLAYERS = 4
  };
  const FBS::Consumer::ConsumerLayers *preferredLayers() const {
    return GetPointer<const FBS::Consumer::ConsumerLayers *>(VT_PREFERREDLAYERS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PREFERREDLAYERS) &&
           verifier.VerifyTable(preferredLayers()) &&
           verifier.EndTable();
  }
};

struct SetPreferredLayersResponseBuilder {
  typedef SetPreferredLayersResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_preferredLayers(flatbuffers::Offset<FBS::Consumer::ConsumerLayers> preferredLayers) {
    fbb_.AddOffset(SetPreferredLayersResponse::VT_PREFERREDLAYERS, preferredLayers);
  }
  explicit SetPreferredLayersResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetPreferredLayersResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetPreferredLayersResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<SetPreferredLayersResponse> CreateSetPreferredLayersResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::ConsumerLayers> preferredLayers = 0) {
  SetPreferredLayersResponseBuilder builder_(_fbb);
  builder_.add_preferredLayers(preferredLayers);
  return builder_.Finish();
}

struct SetPriorityRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetPriorityRequestBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SetPriorityRequestTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PRIORITY = 4
  };
  uint8_t priority() const {
    return GetField<uint8_t>(VT_PRIORITY, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_PRIORITY, 1) &&
           verifier.EndTable();
  }
};

struct SetPriorityRequestBuilder {
  typedef SetPriorityRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_priority(uint8_t priority) {
    fbb_.AddElement<uint8_t>(SetPriorityRequest::VT_PRIORITY, priority, 0);
  }
  explicit SetPriorityRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetPriorityRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetPriorityRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SetPriorityRequest> CreateSetPriorityRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t priority = 0) {
  SetPriorityRequestBuilder builder_(_fbb);
  builder_.add_priority(priority);
  return builder_.Finish();
}

struct SetPriorityResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetPriorityResponseBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SetPriorityResponseTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PRIORITY = 4
  };
  uint8_t priority() const {
    return GetField<uint8_t>(VT_PRIORITY, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_PRIORITY, 1) &&
           verifier.EndTable();
  }
};

struct SetPriorityResponseBuilder {
  typedef SetPriorityResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_priority(uint8_t priority) {
    fbb_.AddElement<uint8_t>(SetPriorityResponse::VT_PRIORITY, priority, 0);
  }
  explicit SetPriorityResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetPriorityResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetPriorityResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<SetPriorityResponse> CreateSetPriorityResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t priority = 0) {
  SetPriorityResponseBuilder builder_(_fbb);
  builder_.add_priority(priority);
  return builder_.Finish();
}

struct EnableTraceEventRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef EnableTraceEventRequestBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return EnableTraceEventRequestTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_EVENTS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *events() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_EVENTS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_EVENTS) &&
           verifier.VerifyVector(events()) &&
           verifier.VerifyVectorOfStrings(events()) &&
           verifier.EndTable();
  }
};

struct EnableTraceEventRequestBuilder {
  typedef EnableTraceEventRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_events(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> events) {
    fbb_.AddOffset(EnableTraceEventRequest::VT_EVENTS, events);
  }
  explicit EnableTraceEventRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<EnableTraceEventRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<EnableTraceEventRequest>(end);
    fbb_.Required(o, EnableTraceEventRequest::VT_EVENTS);
    return o;
  }
};

inline flatbuffers::Offset<EnableTraceEventRequest> CreateEnableTraceEventRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> events = 0) {
  EnableTraceEventRequestBuilder builder_(_fbb);
  builder_.add_events(events);
  return builder_.Finish();
}

inline flatbuffers::Offset<EnableTraceEventRequest> CreateEnableTraceEventRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *events = nullptr) {
  auto events__ = events ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*events) : 0;
  return FBS::Consumer::CreateEnableTraceEventRequest(
      _fbb,
      events__);
}

struct DumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DumpResponseBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DumpResponseTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA_TYPE = 4,
    VT_DATA = 6,
    VT_TYPE = 8
  };
  FBS::Consumer::DumpData data_type() const {
    return static_cast<FBS::Consumer::DumpData>(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::Consumer::SimpleConsumerDump *data_as_SimpleConsumerDump() const {
    return data_type() == FBS::Consumer::DumpData::SimpleConsumerDump ? static_cast<const FBS::Consumer::SimpleConsumerDump *>(data()) : nullptr;
  }
  const FBS::Consumer::SimulcastConsumerDump *data_as_SimulcastConsumerDump() const {
    return data_type() == FBS::Consumer::DumpData::SimulcastConsumerDump ? static_cast<const FBS::Consumer::SimulcastConsumerDump *>(data()) : nullptr;
  }
  const FBS::Consumer::SvcConsumerDump *data_as_SvcConsumerDump() const {
    return data_type() == FBS::Consumer::DumpData::SvcConsumerDump ? static_cast<const FBS::Consumer::SvcConsumerDump *>(data()) : nullptr;
  }
  const FBS::Consumer::PipeConsumerDump *data_as_PipeConsumerDump() const {
    return data_type() == FBS::Consumer::DumpData::PipeConsumerDump ? static_cast<const FBS::Consumer::PipeConsumerDump *>(data()) : nullptr;
  }
  FBS::RtpParameters::Type type() const {
    return static_cast<FBS::RtpParameters::Type>(GetField<uint8_t>(VT_TYPE, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_DATA_TYPE, 1) &&
           VerifyOffset(verifier, VT_DATA) &&
           VerifyDumpData(verifier, data(), data_type()) &&
           VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
           verifier.EndTable();
  }
};

template<> inline const FBS::Consumer::SimpleConsumerDump *DumpResponse::data_as<FBS::Consumer::SimpleConsumerDump>() const {
  return data_as_SimpleConsumerDump();
}

template<> inline const FBS::Consumer::SimulcastConsumerDump *DumpResponse::data_as<FBS::Consumer::SimulcastConsumerDump>() const {
  return data_as_SimulcastConsumerDump();
}

template<> inline const FBS::Consumer::SvcConsumerDump *DumpResponse::data_as<FBS::Consumer::SvcConsumerDump>() const {
  return data_as_SvcConsumerDump();
}

template<> inline const FBS::Consumer::PipeConsumerDump *DumpResponse::data_as<FBS::Consumer::PipeConsumerDump>() const {
  return data_as_PipeConsumerDump();
}

struct DumpResponseBuilder {
  typedef DumpResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_data_type(FBS::Consumer::DumpData data_type) {
    fbb_.AddElement<uint8_t>(DumpResponse::VT_DATA_TYPE, static_cast<uint8_t>(data_type), 0);
  }
  void add_data(flatbuffers::Offset<void> data) {
    fbb_.AddOffset(DumpResponse::VT_DATA, data);
  }
  void add_type(FBS::RtpParameters::Type type) {
    fbb_.AddElement<uint8_t>(DumpResponse::VT_TYPE, static_cast<uint8_t>(type), 0);
  }
  explicit DumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<DumpResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<DumpResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<DumpResponse> CreateDumpResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    FBS::Consumer::DumpData data_type = FBS::Consumer::DumpData::NONE,
    flatbuffers::Offset<void> data = 0,
    FBS::RtpParameters::Type type = FBS::RtpParameters::Type::NONE) {
  DumpResponseBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_type(type);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}

struct BaseConsumerDump FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BaseConsumerDumpBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BaseConsumerDumpTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_PRODUCERID = 6,
    VT_KIND = 8,
    VT_RTPPARAMETERS = 10,
    VT_CONSUMABLERTPENCODINGS = 12,
    VT_SUPPORTEDCODECPAYLOADTYPES = 14,
    VT_TRACEEVENTTYPES = 16,
    VT_PAUSED = 18,
    VT_PRODUCERPAUSED = 20,
    VT_PRIORITY = 22
  };
  const flatbuffers::String *id() const {
    return GetPointer<const flatbuffers::String *>(VT_ID);
  }
  const flatbuffers::String *producerId() const {
    return GetPointer<const flatbuffers::String *>(VT_PRODUCERID);
  }
  FBS::RtpParameters::MediaKind kind() const {
    return static_cast<FBS::RtpParameters::MediaKind>(GetField<uint8_t>(VT_KIND, 0));
  }
  const FBS::RtpParameters::RtpParameters *rtpParameters() const {
    return GetPointer<const FBS::RtpParameters::RtpParameters *>(VT_RTPPARAMETERS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<FBS::RtpParameters::RtpEncodingParameters>> *consumableRtpEncodings() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBS::RtpParameters::RtpEncodingParameters>> *>(VT_CONSUMABLERTPENCODINGS);
  }
  const flatbuffers::Vector<uint8_t> *supportedCodecPayloadTypes() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SUPPORTEDCODECPAYLOADTYPES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *traceEventTypes() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TRACEEVENTTYPES);
  }
  bool paused() const {
    return GetField<uint8_t>(VT_PAUSED, 0) != 0;
  }
  bool producerPaused() const {
    return GetField<uint8_t>(VT_PRODUCERPAUSED, 0) != 0;
  }
  uint8_t priority() const {
    return GetField<uint8_t>(VT_PRIORITY, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffsetRequired(verifier, VT_PRODUCERID) &&
           verifier.VerifyString(producerId()) &&
           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
           VerifyOffsetRequired(verifier, VT_RTPPARAMETERS) &&
           verifier.VerifyTable(rtpParameters()) &&
           VerifyOffset(verifier, VT_CONSUMABLERTPENCODINGS) &&
           verifier.VerifyVector(consumableRtpEncodings()) &&
           verifier.VerifyVectorOfTables(consumableRtpEncodings()) &&
           VerifyOffset(verifier, VT_SUPPORTEDCODECPAYLOADTYPES) &&
           verifier.VerifyVector(supportedCodecPayloadTypes()) &&
           VerifyOffsetRequired(verifier, VT_TRACEEVENTTYPES) &&
           verifier.VerifyVector(traceEventTypes()) &&
           verifier.VerifyVectorOfStrings(traceEventTypes()) &&
           VerifyField<uint8_t>(verifier, VT_PAUSED, 1) &&
           VerifyField<uint8_t>(verifier, VT_PRODUCERPAUSED, 1) &&
           VerifyField<uint8_t>(verifier, VT_PRIORITY, 1) &&
           verifier.EndTable();
  }
};

struct BaseConsumerDumpBuilder {
  typedef BaseConsumerDump Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(flatbuffers::Offset<flatbuffers::String> id) {
    fbb_.AddOffset(BaseConsumerDump::VT_ID, id);
  }
  void add_producerId(flatbuffers::Offset<flatbuffers::String> producerId) {
    fbb_.AddOffset(BaseConsumerDump::VT_PRODUCERID, producerId);
  }
  void add_kind(FBS::RtpParameters::MediaKind kind) {
    fbb_.AddElement<uint8_t>(BaseConsumerDump::VT_KIND, static_cast<uint8_t>(kind), 0);
  }
  void add_rtpParameters(flatbuffers::Offset<FBS::RtpParameters::RtpParameters> rtpParameters) {
    fbb_.AddOffset(BaseConsumerDump::VT_RTPPARAMETERS, rtpParameters);
  }
  void add_consumableRtpEncodings(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBS::RtpParameters::RtpEncodingParameters>>> consumableRtpEncodings) {
    fbb_.AddOffset(BaseConsumerDump::VT_CONSUMABLERTPENCODINGS, consumableRtpEncodings);
  }
  void add_supportedCodecPayloadTypes(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> supportedCodecPayloadTypes) {
    fbb_.AddOffset(BaseConsumerDump::VT_SUPPORTEDCODECPAYLOADTYPES, supportedCodecPayloadTypes);
  }
  void add_traceEventTypes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> traceEventTypes) {
    fbb_.AddOffset(BaseConsumerDump::VT_TRACEEVENTTYPES, traceEventTypes);
  }
  void add_paused(bool paused) {
    fbb_.AddElement<uint8_t>(BaseConsumerDump::VT_PAUSED, static_cast<uint8_t>(paused), 0);
  }
  void add_producerPaused(bool producerPaused) {
    fbb_.AddElement<uint8_t>(BaseConsumerDump::VT_PRODUCERPAUSED, static_cast<uint8_t>(producerPaused), 0);
  }
  void add_priority(uint8_t priority) {
    fbb_.AddElement<uint8_t>(BaseConsumerDump::VT_PRIORITY, priority, 0);
  }
  explicit BaseConsumerDumpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BaseConsumerDump> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BaseConsumerDump>(end);
    fbb_.Required(o, BaseConsumerDump::VT_ID);
    fbb_.Required(o, BaseConsumerDump::VT_PRODUCERID);
    fbb_.Required(o, BaseConsumerDump::VT_RTPPARAMETERS);
    fbb_.Required(o, BaseConsumerDump::VT_TRACEEVENTTYPES);
    return o;
  }
};

inline flatbuffers::Offset<BaseConsumerDump> CreateBaseConsumerDump(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> id = 0,
    flatbuffers::Offset<flatbuffers::String> producerId = 0,
    FBS::RtpParameters::MediaKind kind = FBS::RtpParameters::MediaKind::ALL,
    flatbuffers::Offset<FBS::RtpParameters::RtpParameters> rtpParameters = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBS::RtpParameters::RtpEncodingParameters>>> consumableRtpEncodings = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> supportedCodecPayloadTypes = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> traceEventTypes = 0,
    bool paused = false,
    bool producerPaused = false,
    uint8_t priority = 0) {
  BaseConsumerDumpBuilder builder_(_fbb);
  builder_.add_traceEventTypes(traceEventTypes);
  builder_.add_supportedCodecPayloadTypes(supportedCodecPayloadTypes);
  builder_.add_consumableRtpEncodings(consumableRtpEncodings);
  builder_.add_rtpParameters(rtpParameters);
  builder_.add_producerId(producerId);
  builder_.add_id(id);
  builder_.add_priority(priority);
  builder_.add_producerPaused(producerPaused);
  builder_.add_paused(paused);
  builder_.add_kind(kind);
  return builder_.Finish();
}

inline flatbuffers::Offset<BaseConsumerDump> CreateBaseConsumerDumpDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *producerId = nullptr,
    FBS::RtpParameters::MediaKind kind = FBS::RtpParameters::MediaKind::ALL,
    flatbuffers::Offset<FBS::RtpParameters::RtpParameters> rtpParameters = 0,
    const std::vector<flatbuffers::Offset<FBS::RtpParameters::RtpEncodingParameters>> *consumableRtpEncodings = nullptr,
    const std::vector<uint8_t> *supportedCodecPayloadTypes = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *traceEventTypes = nullptr,
    bool paused = false,
    bool producerPaused = false,
    uint8_t priority = 0) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto producerId__ = producerId ? _fbb.CreateString(producerId) : 0;
  auto consumableRtpEncodings__ = consumableRtpEncodings ? _fbb.CreateVector<flatbuffers::Offset<FBS::RtpParameters::RtpEncodingParameters>>(*consumableRtpEncodings) : 0;
  auto supportedCodecPayloadTypes__ = supportedCodecPayloadTypes ? _fbb.CreateVector<uint8_t>(*supportedCodecPayloadTypes) : 0;
  auto traceEventTypes__ = traceEventTypes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*traceEventTypes) : 0;
  return FBS::Consumer::CreateBaseConsumerDump(
      _fbb,
      id__,
      producerId__,
      kind,
      rtpParameters,
      consumableRtpEncodings__,
      supportedCodecPayloadTypes__,
      traceEventTypes__,
      paused,
      producerPaused,
      priority);
}

struct SimpleConsumerDump FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SimpleConsumerDumpBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SimpleConsumerDumpTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BASE = 4,
    VT_RTPSTREAM = 6
  };
  const FBS::Consumer::BaseConsumerDump *base() const {
    return GetPointer<const FBS::Consumer::BaseConsumerDump *>(VT_BASE);
  }
  const FBS::RtpStream::Dump *rtpStream() const {
    return GetPointer<const FBS::RtpStream::Dump *>(VT_RTPSTREAM);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BASE) &&
           verifier.VerifyTable(base()) &&
           VerifyOffsetRequired(verifier, VT_RTPSTREAM) &&
           verifier.VerifyTable(rtpStream()) &&
           verifier.EndTable();
  }
};

struct SimpleConsumerDumpBuilder {
  typedef SimpleConsumerDump Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_base(flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base) {
    fbb_.AddOffset(SimpleConsumerDump::VT_BASE, base);
  }
  void add_rtpStream(flatbuffers::Offset<FBS::RtpStream::Dump> rtpStream) {
    fbb_.AddOffset(SimpleConsumerDump::VT_RTPSTREAM, rtpStream);
  }
  explicit SimpleConsumerDumpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SimpleConsumerDump> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SimpleConsumerDump>(end);
    fbb_.Required(o, SimpleConsumerDump::VT_BASE);
    fbb_.Required(o, SimpleConsumerDump::VT_RTPSTREAM);
    return o;
  }
};

inline flatbuffers::Offset<SimpleConsumerDump> CreateSimpleConsumerDump(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base = 0,
    flatbuffers::Offset<FBS::RtpStream::Dump> rtpStream = 0) {
  SimpleConsumerDumpBuilder builder_(_fbb);
  builder_.add_rtpStream(rtpStream);
  builder_.add_base(base);
  return builder_.Finish();
}

struct SimulcastConsumerDump FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SimulcastConsumerDumpBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SimulcastConsumerDumpTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BASE = 4,
    VT_RTPSTREAM = 6,
    VT_PREFERREDSPATIALLAYER = 8,
    VT_TARGETSPATIALLAYER = 10,
    VT_CURRENTSPATIALLAYER = 12,
    VT_PREFERREDTEMPORALLAYER = 14,
    VT_TARGETTEMPORALLAYER = 16,
    VT_CURRENTTEMPORALLAYER = 18
  };
  const FBS::Consumer::BaseConsumerDump *base() const {
    return GetPointer<const FBS::Consumer::BaseConsumerDump *>(VT_BASE);
  }
  const FBS::RtpStream::Dump *rtpStream() const {
    return GetPointer<const FBS::RtpStream::Dump *>(VT_RTPSTREAM);
  }
  int16_t preferredSpatialLayer() const {
    return GetField<int16_t>(VT_PREFERREDSPATIALLAYER, 0);
  }
  int16_t targetSpatialLayer() const {
    return GetField<int16_t>(VT_TARGETSPATIALLAYER, 0);
  }
  int16_t currentSpatialLayer() const {
    return GetField<int16_t>(VT_CURRENTSPATIALLAYER, 0);
  }
  int16_t preferredTemporalLayer() const {
    return GetField<int16_t>(VT_PREFERREDTEMPORALLAYER, 0);
  }
  int16_t targetTemporalLayer() const {
    return GetField<int16_t>(VT_TARGETTEMPORALLAYER, 0);
  }
  int16_t currentTemporalLayer() const {
    return GetField<int16_t>(VT_CURRENTTEMPORALLAYER, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BASE) &&
           verifier.VerifyTable(base()) &&
           VerifyOffsetRequired(verifier, VT_RTPSTREAM) &&
           verifier.VerifyTable(rtpStream()) &&
           VerifyField<int16_t>(verifier, VT_PREFERREDSPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_TARGETSPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_CURRENTSPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_PREFERREDTEMPORALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_TARGETTEMPORALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_CURRENTTEMPORALLAYER, 2) &&
           verifier.EndTable();
  }
};

struct SimulcastConsumerDumpBuilder {
  typedef SimulcastConsumerDump Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_base(flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base) {
    fbb_.AddOffset(SimulcastConsumerDump::VT_BASE, base);
  }
  void add_rtpStream(flatbuffers::Offset<FBS::RtpStream::Dump> rtpStream) {
    fbb_.AddOffset(SimulcastConsumerDump::VT_RTPSTREAM, rtpStream);
  }
  void add_preferredSpatialLayer(int16_t preferredSpatialLayer) {
    fbb_.AddElement<int16_t>(SimulcastConsumerDump::VT_PREFERREDSPATIALLAYER, preferredSpatialLayer, 0);
  }
  void add_targetSpatialLayer(int16_t targetSpatialLayer) {
    fbb_.AddElement<int16_t>(SimulcastConsumerDump::VT_TARGETSPATIALLAYER, targetSpatialLayer, 0);
  }
  void add_currentSpatialLayer(int16_t currentSpatialLayer) {
    fbb_.AddElement<int16_t>(SimulcastConsumerDump::VT_CURRENTSPATIALLAYER, currentSpatialLayer, 0);
  }
  void add_preferredTemporalLayer(int16_t preferredTemporalLayer) {
    fbb_.AddElement<int16_t>(SimulcastConsumerDump::VT_PREFERREDTEMPORALLAYER, preferredTemporalLayer, 0);
  }
  void add_targetTemporalLayer(int16_t targetTemporalLayer) {
    fbb_.AddElement<int16_t>(SimulcastConsumerDump::VT_TARGETTEMPORALLAYER, targetTemporalLayer, 0);
  }
  void add_currentTemporalLayer(int16_t currentTemporalLayer) {
    fbb_.AddElement<int16_t>(SimulcastConsumerDump::VT_CURRENTTEMPORALLAYER, currentTemporalLayer, 0);
  }
  explicit SimulcastConsumerDumpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SimulcastConsumerDump> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SimulcastConsumerDump>(end);
    fbb_.Required(o, SimulcastConsumerDump::VT_BASE);
    fbb_.Required(o, SimulcastConsumerDump::VT_RTPSTREAM);
    return o;
  }
};

inline flatbuffers::Offset<SimulcastConsumerDump> CreateSimulcastConsumerDump(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base = 0,
    flatbuffers::Offset<FBS::RtpStream::Dump> rtpStream = 0,
    int16_t preferredSpatialLayer = 0,
    int16_t targetSpatialLayer = 0,
    int16_t currentSpatialLayer = 0,
    int16_t preferredTemporalLayer = 0,
    int16_t targetTemporalLayer = 0,
    int16_t currentTemporalLayer = 0) {
  SimulcastConsumerDumpBuilder builder_(_fbb);
  builder_.add_rtpStream(rtpStream);
  builder_.add_base(base);
  builder_.add_currentTemporalLayer(currentTemporalLayer);
  builder_.add_targetTemporalLayer(targetTemporalLayer);
  builder_.add_preferredTemporalLayer(preferredTemporalLayer);
  builder_.add_currentSpatialLayer(currentSpatialLayer);
  builder_.add_targetSpatialLayer(targetSpatialLayer);
  builder_.add_preferredSpatialLayer(preferredSpatialLayer);
  return builder_.Finish();
}

struct SvcConsumerDump FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SvcConsumerDumpBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SvcConsumerDumpTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BASE = 4,
    VT_RTPSTREAM = 6,
    VT_PREFERREDSPATIALLAYER = 8,
    VT_TARGETSPATIALLAYER = 10,
    VT_CURRENTSPATIALLAYER = 12,
    VT_PREFERREDTEMPORALLAYER = 14,
    VT_TARGETTEMPORALLAYER = 16,
    VT_CURRENTTEMPORALLAYER = 18
  };
  const FBS::Consumer::BaseConsumerDump *base() const {
    return GetPointer<const FBS::Consumer::BaseConsumerDump *>(VT_BASE);
  }
  const FBS::RtpStream::Dump *rtpStream() const {
    return GetPointer<const FBS::RtpStream::Dump *>(VT_RTPSTREAM);
  }
  int16_t preferredSpatialLayer() const {
    return GetField<int16_t>(VT_PREFERREDSPATIALLAYER, 0);
  }
  int16_t targetSpatialLayer() const {
    return GetField<int16_t>(VT_TARGETSPATIALLAYER, 0);
  }
  int16_t currentSpatialLayer() const {
    return GetField<int16_t>(VT_CURRENTSPATIALLAYER, 0);
  }
  int16_t preferredTemporalLayer() const {
    return GetField<int16_t>(VT_PREFERREDTEMPORALLAYER, 0);
  }
  int16_t targetTemporalLayer() const {
    return GetField<int16_t>(VT_TARGETTEMPORALLAYER, 0);
  }
  int16_t currentTemporalLayer() const {
    return GetField<int16_t>(VT_CURRENTTEMPORALLAYER, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BASE) &&
           verifier.VerifyTable(base()) &&
           VerifyOffsetRequired(verifier, VT_RTPSTREAM) &&
           verifier.VerifyTable(rtpStream()) &&
           VerifyField<int16_t>(verifier, VT_PREFERREDSPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_TARGETSPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_CURRENTSPATIALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_PREFERREDTEMPORALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_TARGETTEMPORALLAYER, 2) &&
           VerifyField<int16_t>(verifier, VT_CURRENTTEMPORALLAYER, 2) &&
           verifier.EndTable();
  }
};

struct SvcConsumerDumpBuilder {
  typedef SvcConsumerDump Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_base(flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base) {
    fbb_.AddOffset(SvcConsumerDump::VT_BASE, base);
  }
  void add_rtpStream(flatbuffers::Offset<FBS::RtpStream::Dump> rtpStream) {
    fbb_.AddOffset(SvcConsumerDump::VT_RTPSTREAM, rtpStream);
  }
  void add_preferredSpatialLayer(int16_t preferredSpatialLayer) {
    fbb_.AddElement<int16_t>(SvcConsumerDump::VT_PREFERREDSPATIALLAYER, preferredSpatialLayer, 0);
  }
  void add_targetSpatialLayer(int16_t targetSpatialLayer) {
    fbb_.AddElement<int16_t>(SvcConsumerDump::VT_TARGETSPATIALLAYER, targetSpatialLayer, 0);
  }
  void add_currentSpatialLayer(int16_t currentSpatialLayer) {
    fbb_.AddElement<int16_t>(SvcConsumerDump::VT_CURRENTSPATIALLAYER, currentSpatialLayer, 0);
  }
  void add_preferredTemporalLayer(int16_t preferredTemporalLayer) {
    fbb_.AddElement<int16_t>(SvcConsumerDump::VT_PREFERREDTEMPORALLAYER, preferredTemporalLayer, 0);
  }
  void add_targetTemporalLayer(int16_t targetTemporalLayer) {
    fbb_.AddElement<int16_t>(SvcConsumerDump::VT_TARGETTEMPORALLAYER, targetTemporalLayer, 0);
  }
  void add_currentTemporalLayer(int16_t currentTemporalLayer) {
    fbb_.AddElement<int16_t>(SvcConsumerDump::VT_CURRENTTEMPORALLAYER, currentTemporalLayer, 0);
  }
  explicit SvcConsumerDumpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SvcConsumerDump> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SvcConsumerDump>(end);
    fbb_.Required(o, SvcConsumerDump::VT_BASE);
    fbb_.Required(o, SvcConsumerDump::VT_RTPSTREAM);
    return o;
  }
};

inline flatbuffers::Offset<SvcConsumerDump> CreateSvcConsumerDump(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base = 0,
    flatbuffers::Offset<FBS::RtpStream::Dump> rtpStream = 0,
    int16_t preferredSpatialLayer = 0,
    int16_t targetSpatialLayer = 0,
    int16_t currentSpatialLayer = 0,
    int16_t preferredTemporalLayer = 0,
    int16_t targetTemporalLayer = 0,
    int16_t currentTemporalLayer = 0) {
  SvcConsumerDumpBuilder builder_(_fbb);
  builder_.add_rtpStream(rtpStream);
  builder_.add_base(base);
  builder_.add_currentTemporalLayer(currentTemporalLayer);
  builder_.add_targetTemporalLayer(targetTemporalLayer);
  builder_.add_preferredTemporalLayer(preferredTemporalLayer);
  builder_.add_currentSpatialLayer(currentSpatialLayer);
  builder_.add_targetSpatialLayer(targetSpatialLayer);
  builder_.add_preferredSpatialLayer(preferredSpatialLayer);
  return builder_.Finish();
}

struct PipeConsumerDump FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PipeConsumerDumpBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PipeConsumerDumpTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BASE = 4,
    VT_RTPSTREAMS = 6
  };
  const FBS::Consumer::BaseConsumerDump *base() const {
    return GetPointer<const FBS::Consumer::BaseConsumerDump *>(VT_BASE);
  }
  const flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Dump>> *rtpStreams() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Dump>> *>(VT_RTPSTREAMS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BASE) &&
           verifier.VerifyTable(base()) &&
           VerifyOffsetRequired(verifier, VT_RTPSTREAMS) &&
           verifier.VerifyVector(rtpStreams()) &&
           verifier.VerifyVectorOfTables(rtpStreams()) &&
           verifier.EndTable();
  }
};

struct PipeConsumerDumpBuilder {
  typedef PipeConsumerDump Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_base(flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base) {
    fbb_.AddOffset(PipeConsumerDump::VT_BASE, base);
  }
  void add_rtpStreams(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Dump>>> rtpStreams) {
    fbb_.AddOffset(PipeConsumerDump::VT_RTPSTREAMS, rtpStreams);
  }
  explicit PipeConsumerDumpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<PipeConsumerDump> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<PipeConsumerDump>(end);
    fbb_.Required(o, PipeConsumerDump::VT_BASE);
    fbb_.Required(o, PipeConsumerDump::VT_RTPSTREAMS);
    return o;
  }
};

inline flatbuffers::Offset<PipeConsumerDump> CreatePipeConsumerDump(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Dump>>> rtpStreams = 0) {
  PipeConsumerDumpBuilder builder_(_fbb);
  builder_.add_rtpStreams(rtpStreams);
  builder_.add_base(base);
  return builder_.Finish();
}

inline flatbuffers::Offset<PipeConsumerDump> CreatePipeConsumerDumpDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::BaseConsumerDump> base = 0,
    const std::vector<flatbuffers::Offset<FBS::RtpStream::Dump>> *rtpStreams = nullptr) {
  auto rtpStreams__ = rtpStreams ? _fbb.CreateVector<flatbuffers::Offset<FBS::RtpStream::Dump>>(*rtpStreams) : 0;
  return FBS::Consumer::CreatePipeConsumerDump(
      _fbb,
      base,
      rtpStreams__);
}

struct GetStatsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetStatsResponseBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GetStatsResponseTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STATS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Stats>> *stats() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Stats>> *>(VT_STATS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_STATS) &&
           verifier.VerifyVector(stats()) &&
           verifier.VerifyVectorOfTables(stats()) &&
           verifier.EndTable();
  }
};

struct GetStatsResponseBuilder {
  typedef GetStatsResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_stats(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Stats>>> stats) {
    fbb_.AddOffset(GetStatsResponse::VT_STATS, stats);
  }
  explicit GetStatsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetStatsResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetStatsResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetStatsResponse> CreateGetStatsResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FBS::RtpStream::Stats>>> stats = 0) {
  GetStatsResponseBuilder builder_(_fbb);
  builder_.add_stats(stats);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetStatsResponse> CreateGetStatsResponseDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<FBS::RtpStream::Stats>> *stats = nullptr) {
  auto stats__ = stats ? _fbb.CreateVector<flatbuffers::Offset<FBS::RtpStream::Stats>>(*stats) : 0;
  return FBS::Consumer::CreateGetStatsResponse(
      _fbb,
      stats__);
}

struct LayersChangeNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LayersChangeNotificationBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LayersChangeNotificationTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LAYERS = 4
  };
  const FBS::Consumer::ConsumerLayers *layers() const {
    return GetPointer<const FBS::Consumer::ConsumerLayers *>(VT_LAYERS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LAYERS) &&
           verifier.VerifyTable(layers()) &&
           verifier.EndTable();
  }
};

struct LayersChangeNotificationBuilder {
  typedef LayersChangeNotification Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_layers(flatbuffers::Offset<FBS::Consumer::ConsumerLayers> layers) {
    fbb_.AddOffset(LayersChangeNotification::VT_LAYERS, layers);
  }
  explicit LayersChangeNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<LayersChangeNotification> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LayersChangeNotification>(end);
    return o;
  }
};

inline flatbuffers::Offset<LayersChangeNotification> CreateLayersChangeNotification(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::ConsumerLayers> layers = 0) {
  LayersChangeNotificationBuilder builder_(_fbb);
  builder_.add_layers(layers);
  return builder_.Finish();
}

struct RtpNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RtpNotificationBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RtpNotificationTypeTable();
  }
  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) &&
           VerifyOffsetRequired(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

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

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

inline flatbuffers::Offset<RtpNotification> CreateRtpNotificationDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return FBS::Consumer::CreateRtpNotification(
      _fbb,
      data__);
}

struct ScoreNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ScoreNotificationBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ScoreNotificationTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCORE = 4
  };
  const FBS::Consumer::ConsumerScore *score() const {
    return GetPointer<const FBS::Consumer::ConsumerScore *>(VT_SCORE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_SCORE) &&
           verifier.VerifyTable(score()) &&
           verifier.EndTable();
  }
};

struct ScoreNotificationBuilder {
  typedef ScoreNotification Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_score(flatbuffers::Offset<FBS::Consumer::ConsumerScore> score) {
    fbb_.AddOffset(ScoreNotification::VT_SCORE, score);
  }
  explicit ScoreNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ScoreNotification> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ScoreNotification>(end);
    fbb_.Required(o, ScoreNotification::VT_SCORE);
    return o;
  }
};

inline flatbuffers::Offset<ScoreNotification> CreateScoreNotification(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<FBS::Consumer::ConsumerScore> score = 0) {
  ScoreNotificationBuilder builder_(_fbb);
  builder_.add_score(score);
  return builder_.Finish();
}

struct KeyFrameTraceInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef KeyFrameTraceInfoBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return KeyFrameTraceInfoTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ISRTX = 4
  };
  bool isRtx() const {
    return GetField<uint8_t>(VT_ISRTX, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ISRTX, 1) &&
           verifier.EndTable();
  }
};

struct KeyFrameTraceInfoBuilder {
  typedef KeyFrameTraceInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_isRtx(bool isRtx) {
    fbb_.AddElement<uint8_t>(KeyFrameTraceInfo::VT_ISRTX, static_cast<uint8_t>(isRtx), 0);
  }
  explicit KeyFrameTraceInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<KeyFrameTraceInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<KeyFrameTraceInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<KeyFrameTraceInfo> CreateKeyFrameTraceInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool isRtx = false) {
  KeyFrameTraceInfoBuilder builder_(_fbb);
  builder_.add_isRtx(isRtx);
  return builder_.Finish();
}

struct FirTraceInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef FirTraceInfoBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return FirTraceInfoTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SSRC = 4
  };
  uint32_t ssrc() const {
    return GetField<uint32_t>(VT_SSRC, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SSRC, 4) &&
           verifier.EndTable();
  }
};

struct FirTraceInfoBuilder {
  typedef FirTraceInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_ssrc(uint32_t ssrc) {
    fbb_.AddElement<uint32_t>(FirTraceInfo::VT_SSRC, ssrc, 0);
  }
  explicit FirTraceInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<FirTraceInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<FirTraceInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<FirTraceInfo> CreateFirTraceInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t ssrc = 0) {
  FirTraceInfoBuilder builder_(_fbb);
  builder_.add_ssrc(ssrc);
  return builder_.Finish();
}

struct PliTraceInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PliTraceInfoBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PliTraceInfoTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SSRC = 4
  };
  uint32_t ssrc() const {
    return GetField<uint32_t>(VT_SSRC, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SSRC, 4) &&
           verifier.EndTable();
  }
};

struct PliTraceInfoBuilder {
  typedef PliTraceInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_ssrc(uint32_t ssrc) {
    fbb_.AddElement<uint32_t>(PliTraceInfo::VT_SSRC, ssrc, 0);
  }
  explicit PliTraceInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<PliTraceInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<PliTraceInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<PliTraceInfo> CreatePliTraceInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t ssrc = 0) {
  PliTraceInfoBuilder builder_(_fbb);
  builder_.add_ssrc(ssrc);
  return builder_.Finish();
}

struct RtpTraceInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RtpTraceInfoBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RtpTraceInfoTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ISRTX = 4
  };
  bool isRtx() const {
    return GetField<uint8_t>(VT_ISRTX, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ISRTX, 1) &&
           verifier.EndTable();
  }
};

struct RtpTraceInfoBuilder {
  typedef RtpTraceInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_isRtx(bool isRtx) {
    fbb_.AddElement<uint8_t>(RtpTraceInfo::VT_ISRTX, static_cast<uint8_t>(isRtx), 0);
  }
  explicit RtpTraceInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RtpTraceInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RtpTraceInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<RtpTraceInfo> CreateRtpTraceInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool isRtx = false) {
  RtpTraceInfoBuilder builder_(_fbb);
  builder_.add_isRtx(isRtx);
  return builder_.Finish();
}

struct TraceNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TraceNotificationBuilder Builder;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TraceNotificationTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_TIMESTAMP = 6,
    VT_DIRECTION = 8,
    VT_INFO_TYPE = 10,
    VT_INFO = 12
  };
  FBS::Consumer::TraceType type() const {
    return static_cast<FBS::Consumer::TraceType>(GetField<uint8_t>(VT_TYPE, 0));
  }
  uint64_t timestamp() const {
    return GetField<uint64_t>(VT_TIMESTAMP, 0);
  }
  FBS::Consumer::TraceDirection direction() const {
    return static_cast<FBS::Consumer::TraceDirection>(GetField<uint8_t>(VT_DIRECTION, 0));
  }
  FBS::Consumer::TraceInfo info_type() const {
    return static_cast<FBS::Consumer::TraceInfo>(GetField<uint8_t>(VT_INFO_TYPE, 0));
  }
  const void *info() const {
    return GetPointer<const void *>(VT_INFO);
  }
  template<typename T> const T *info_as() const;
  const FBS::Consumer::KeyFrameTraceInfo *info_as_KeyFrameTraceInfo() const {
    return info_type() == FBS::Consumer::TraceInfo::KeyFrameTraceInfo ? static_cast<const FBS::Consumer::KeyFrameTraceInfo *>(info()) : nullptr;
  }
  const FBS::Consumer::FirTraceInfo *info_as_FirTraceInfo() const {
    return info_type() == FBS::Consumer::TraceInfo::FirTraceInfo ? static_cast<const FBS::Consumer::FirTraceInfo *>(info()) : nullptr;
  }
  const FBS::Consumer::PliTraceInfo *info_as_PliTraceInfo() const {
    return info_type() == FBS::Consumer::TraceInfo::PliTraceInfo ? static_cast<const FBS::Consumer::PliTraceInfo *>(info()) : nullptr;
  }
  const FBS::Consumer::RtpTraceInfo *info_as_RtpTraceInfo() const {
    return info_type() == FBS::Consumer::TraceInfo::RtpTraceInfo ? static_cast<const FBS::Consumer::RtpTraceInfo *>(info()) : nullptr;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
           VerifyField<uint64_t>(verifier, VT_TIMESTAMP, 8) &&
           VerifyField<uint8_t>(verifier, VT_DIRECTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_INFO_TYPE, 1) &&
           VerifyOffset(verifier, VT_INFO) &&
           VerifyTraceInfo(verifier, info(), info_type()) &&
           verifier.EndTable();
  }
};

template<> inline const FBS::Consumer::KeyFrameTraceInfo *TraceNotification::info_as<FBS::Consumer::KeyFrameTraceInfo>() const {
  return info_as_KeyFrameTraceInfo();
}

template<> inline const FBS::Consumer::FirTraceInfo *TraceNotification::info_as<FBS::Consumer::FirTraceInfo>() const {
  return info_as_FirTraceInfo();
}

template<> inline const FBS::Consumer::PliTraceInfo *TraceNotification::info_as<FBS::Consumer::PliTraceInfo>() const {
  return info_as_PliTraceInfo();
}

template<> inline const FBS::Consumer::RtpTraceInfo *TraceNotification::info_as<FBS::Consumer::RtpTraceInfo>() const {
  return info_as_RtpTraceInfo();
}

struct TraceNotificationBuilder {
  typedef TraceNotification Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_type(FBS::Consumer::TraceType type) {
    fbb_.AddElement<uint8_t>(TraceNotification::VT_TYPE, static_cast<uint8_t>(type), 0);
  }
  void add_timestamp(uint64_t timestamp) {
    fbb_.AddElement<uint64_t>(TraceNotification::VT_TIMESTAMP, timestamp, 0);
  }
  void add_direction(FBS::Consumer::TraceDirection direction) {
    fbb_.AddElement<uint8_t>(TraceNotification::VT_DIRECTION, static_cast<uint8_t>(direction), 0);
  }
  void add_info_type(FBS::Consumer::TraceInfo info_type) {
    fbb_.AddElement<uint8_t>(TraceNotification::VT_INFO_TYPE, static_cast<uint8_t>(info_type), 0);
  }
  void add_info(flatbuffers::Offset<void> info) {
    fbb_.AddOffset(TraceNotification::VT_INFO, info);
  }
  explicit TraceNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<TraceNotification> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TraceNotification>(end);
    return o;
  }
};

inline flatbuffers::Offset<TraceNotification> CreateTraceNotification(
    flatbuffers::FlatBufferBuilder &_fbb,
    FBS::Consumer::TraceType type = FBS::Consumer::TraceType::KEYFRAME,
    uint64_t timestamp = 0,
    FBS::Consumer::TraceDirection direction = FBS::Consumer::TraceDirection::IN,
    FBS::Consumer::TraceInfo info_type = FBS::Consumer::TraceInfo::NONE,
    flatbuffers::Offset<void> info = 0) {
  TraceNotificationBuilder builder_(_fbb);
  builder_.add_timestamp(timestamp);
  builder_.add_info(info);
  builder_.add_info_type(info_type);
  builder_.add_direction(direction);
  builder_.add_type(type);
  return builder_.Finish();
}

inline bool VerifyDumpData(flatbuffers::Verifier &verifier, const void *obj, DumpData type) {
  switch (type) {
    case DumpData::NONE: {
      return true;
    }
    case DumpData::SimpleConsumerDump: {
      auto ptr = reinterpret_cast<const FBS::Consumer::SimpleConsumerDump *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DumpData::SimulcastConsumerDump: {
      auto ptr = reinterpret_cast<const FBS::Consumer::SimulcastConsumerDump *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DumpData::SvcConsumerDump: {
      auto ptr = reinterpret_cast<const FBS::Consumer::SvcConsumerDump *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DumpData::PipeConsumerDump: {
      auto ptr = reinterpret_cast<const FBS::Consumer::PipeConsumerDump *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

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

inline bool VerifyTraceInfo(flatbuffers::Verifier &verifier, const void *obj, TraceInfo type) {
  switch (type) {
    case TraceInfo::NONE: {
      return true;
    }
    case TraceInfo::KeyFrameTraceInfo: {
      auto ptr = reinterpret_cast<const FBS::Consumer::KeyFrameTraceInfo *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case TraceInfo::FirTraceInfo: {
      auto ptr = reinterpret_cast<const FBS::Consumer::FirTraceInfo *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case TraceInfo::PliTraceInfo: {
      auto ptr = reinterpret_cast<const FBS::Consumer::PliTraceInfo *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case TraceInfo::RtpTraceInfo: {
      auto ptr = reinterpret_cast<const FBS::Consumer::RtpTraceInfo *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

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

inline const flatbuffers::TypeTable *DumpDataTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, -1 },
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 1 },
    { flatbuffers::ET_SEQUENCE, 0, 2 },
    { flatbuffers::ET_SEQUENCE, 0, 3 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::SimpleConsumerDumpTypeTable,
    FBS::Consumer::SimulcastConsumerDumpTypeTable,
    FBS::Consumer::SvcConsumerDumpTypeTable,
    FBS::Consumer::PipeConsumerDumpTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "SimpleConsumerDump",
    "SimulcastConsumerDump",
    "SvcConsumerDump",
    "PipeConsumerDump"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_UNION, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *TraceTypeTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_UCHAR, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::TraceTypeTypeTable
  };
  static const char * const names[] = {
    "KEYFRAME",
    "FIR",
    "NACK",
    "PLI",
    "RTP"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_ENUM, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *TraceDirectionTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_UCHAR, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::TraceDirectionTypeTable
  };
  static const char * const names[] = {
    "IN",
    "OUT"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *TraceInfoTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, -1 },
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 1 },
    { flatbuffers::ET_SEQUENCE, 0, 2 },
    { flatbuffers::ET_SEQUENCE, 0, 3 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::KeyFrameTraceInfoTypeTable,
    FBS::Consumer::FirTraceInfoTypeTable,
    FBS::Consumer::PliTraceInfoTypeTable,
    FBS::Consumer::RtpTraceInfoTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "KeyFrameTraceInfo",
    "FirTraceInfo",
    "PliTraceInfo",
    "RtpTraceInfo"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_UNION, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ConsumerLayersTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 }
  };
  static const char * const names[] = {
    "spatialLayer",
    "temporalLayer"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ConsumerScoreTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 0, -1 },
    { flatbuffers::ET_UCHAR, 0, -1 },
    { flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const char * const names[] = {
    "score",
    "producerScore",
    "producerScores"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SetPreferredLayersRequestTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::ConsumerLayersTypeTable
  };
  static const char * const names[] = {
    "preferredLayers"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SetPreferredLayersResponseTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::ConsumerLayersTypeTable
  };
  static const char * const names[] = {
    "preferredLayers"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SetPriorityRequestTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 0, -1 }
  };
  static const char * const names[] = {
    "priority"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SetPriorityResponseTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 0, -1 }
  };
  static const char * const names[] = {
    "priority"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *EnableTraceEventRequestTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_STRING, 1, -1 }
  };
  static const char * const names[] = {
    "events"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *DumpResponseTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UTYPE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_UCHAR, 0, 1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::DumpDataTypeTable,
    FBS::RtpParameters::TypeTypeTable
  };
  static const char * const names[] = {
    "data_type",
    "data",
    "type"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *BaseConsumerDumpTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_STRING, 0, -1 },
    { flatbuffers::ET_STRING, 0, -1 },
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 1 },
    { flatbuffers::ET_SEQUENCE, 1, 2 },
    { flatbuffers::ET_UCHAR, 1, -1 },
    { flatbuffers::ET_STRING, 1, -1 },
    { flatbuffers::ET_BOOL, 0, -1 },
    { flatbuffers::ET_BOOL, 0, -1 },
    { flatbuffers::ET_UCHAR, 0, -1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::RtpParameters::MediaKindTypeTable,
    FBS::RtpParameters::RtpParametersTypeTable,
    FBS::RtpParameters::RtpEncodingParametersTypeTable
  };
  static const char * const names[] = {
    "id",
    "producerId",
    "kind",
    "rtpParameters",
    "consumableRtpEncodings",
    "supportedCodecPayloadTypes",
    "traceEventTypes",
    "paused",
    "producerPaused",
    "priority"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 10, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SimpleConsumerDumpTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::BaseConsumerDumpTypeTable,
    FBS::RtpStream::DumpTypeTable
  };
  static const char * const names[] = {
    "base",
    "rtpStream"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SimulcastConsumerDumpTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::BaseConsumerDumpTypeTable,
    FBS::RtpStream::DumpTypeTable
  };
  static const char * const names[] = {
    "base",
    "rtpStream",
    "preferredSpatialLayer",
    "targetSpatialLayer",
    "currentSpatialLayer",
    "preferredTemporalLayer",
    "targetTemporalLayer",
    "currentTemporalLayer"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 8, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *SvcConsumerDumpTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 0, 1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 },
    { flatbuffers::ET_SHORT, 0, -1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::BaseConsumerDumpTypeTable,
    FBS::RtpStream::DumpTypeTable
  };
  static const char * const names[] = {
    "base",
    "rtpStream",
    "preferredSpatialLayer",
    "targetSpatialLayer",
    "currentSpatialLayer",
    "preferredTemporalLayer",
    "targetTemporalLayer",
    "currentTemporalLayer"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 8, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *PipeConsumerDumpTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 },
    { flatbuffers::ET_SEQUENCE, 1, 1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::BaseConsumerDumpTypeTable,
    FBS::RtpStream::DumpTypeTable
  };
  static const char * const names[] = {
    "base",
    "rtpStreams"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *GetStatsResponseTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 1, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::RtpStream::StatsTypeTable
  };
  static const char * const names[] = {
    "stats"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *LayersChangeNotificationTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::ConsumerLayersTypeTable
  };
  static const char * const names[] = {
    "layers"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *RtpNotificationTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const char * const names[] = {
    "data"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ScoreNotificationTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_SEQUENCE, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::ConsumerScoreTypeTable
  };
  static const char * const names[] = {
    "score"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *KeyFrameTraceInfoTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "isRtx"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *FirTraceInfoTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UINT, 0, -1 }
  };
  static const char * const names[] = {
    "ssrc"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *PliTraceInfoTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UINT, 0, -1 }
  };
  static const char * const names[] = {
    "ssrc"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *RtpTraceInfoTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "isRtx"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *TraceNotificationTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_UCHAR, 0, 0 },
    { flatbuffers::ET_ULONG, 0, -1 },
    { flatbuffers::ET_UCHAR, 0, 1 },
    { flatbuffers::ET_UTYPE, 0, 2 },
    { flatbuffers::ET_SEQUENCE, 0, 2 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    FBS::Consumer::TraceTypeTypeTable,
    FBS::Consumer::TraceDirectionTypeTable,
    FBS::Consumer::TraceInfoTypeTable
  };
  static const char * const names[] = {
    "type",
    "timestamp",
    "direction",
    "info_type",
    "info"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

}  // namespace Consumer
}  // namespace FBS

#endif  // FLATBUFFERS_GENERATED_CONSUMER_FBS_CONSUMER_H_