cpp-cli/wire_gen/bex_all_generated.h

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


#ifndef FLATBUFFERS_GENERATED_BEXALL_BEX_WIRE_H_
#define FLATBUFFERS_GENERATED_BEXALL_BEX_WIRE_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 == 25 &&
              FLATBUFFERS_VERSION_MINOR == 12 &&
              FLATBUFFERS_VERSION_REVISION == 19,
             "Non-compatible flatbuffers version included");

namespace bex {
namespace wire {

struct Image;
struct ImageBuilder;

struct ImageSet;
struct ImageSetBuilder;

struct LinkedId;
struct LinkedIdBuilder;

struct Attr;
struct AttrBuilder;

struct MediaCard;
struct MediaCardBuilder;

struct CategoryLink;
struct CategoryLinkBuilder;

struct HomeSection;
struct HomeSectionBuilder;

struct PagedResult;
struct PagedResultBuilder;

struct Episode;
struct EpisodeBuilder;

struct Season;
struct SeasonBuilder;

struct Person;
struct PersonBuilder;

struct MediaInfo;
struct MediaInfoBuilder;

struct VideoResolution;
struct VideoResolutionBuilder;

struct VideoTrack;
struct VideoTrackBuilder;

struct SubtitleTrack;
struct SubtitleTrackBuilder;

struct Server;
struct ServerBuilder;

struct StreamSource;
struct StreamSourceBuilder;

struct HomeResult;
struct HomeResultBuilder;

struct CategoryResult;
struct CategoryResultBuilder;

struct SearchResult;
struct SearchResultBuilder;

struct InfoResult;
struct InfoResultBuilder;

struct ServersResult;
struct ServersResultBuilder;

struct StreamResult;
struct StreamResultBuilder;

struct ErrorInfo;
struct ErrorInfoBuilder;

enum MediaKind : int8_t {
  MediaKind_Movie = 0,
  MediaKind_Series = 1,
  MediaKind_Anime = 2,
  MediaKind_Short = 3,
  MediaKind_Special = 4,
  MediaKind_Documentary = 5,
  MediaKind_Music = 6,
  MediaKind_Podcast = 7,
  MediaKind_Book = 8,
  MediaKind_Live = 9,
  MediaKind_Unknown = 10,
  MediaKind_MIN = MediaKind_Movie,
  MediaKind_MAX = MediaKind_Unknown
};

inline const MediaKind (&EnumValuesMediaKind())[11] {
  static const MediaKind values[] = {
    MediaKind_Movie,
    MediaKind_Series,
    MediaKind_Anime,
    MediaKind_Short,
    MediaKind_Special,
    MediaKind_Documentary,
    MediaKind_Music,
    MediaKind_Podcast,
    MediaKind_Book,
    MediaKind_Live,
    MediaKind_Unknown
  };
  return values;
}

inline const char * const *EnumNamesMediaKind() {
  static const char * const names[12] = {
    "Movie",
    "Series",
    "Anime",
    "Short",
    "Special",
    "Documentary",
    "Music",
    "Podcast",
    "Book",
    "Live",
    "Unknown",
    nullptr
  };
  return names;
}

inline const char *EnumNameMediaKind(MediaKind e) {
  if (::flatbuffers::IsOutRange(e, MediaKind_Movie, MediaKind_Unknown)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMediaKind()[index];
}

enum Status : int8_t {
  Status_Unknown = 0,
  Status_Upcoming = 1,
  Status_Ongoing = 2,
  Status_Completed = 3,
  Status_Cancelled = 4,
  Status_Paused = 5,
  Status_MIN = Status_Unknown,
  Status_MAX = Status_Paused
};

inline const Status (&EnumValuesStatus())[6] {
  static const Status values[] = {
    Status_Unknown,
    Status_Upcoming,
    Status_Ongoing,
    Status_Completed,
    Status_Cancelled,
    Status_Paused
  };
  return values;
}

inline const char * const *EnumNamesStatus() {
  static const char * const names[7] = {
    "Unknown",
    "Upcoming",
    "Ongoing",
    "Completed",
    "Cancelled",
    "Paused",
    nullptr
  };
  return names;
}

inline const char *EnumNameStatus(Status e) {
  if (::flatbuffers::IsOutRange(e, Status_Unknown, Status_Paused)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesStatus()[index];
}

enum StreamFormat : int8_t {
  StreamFormat_Hls = 0,
  StreamFormat_Dash = 1,
  StreamFormat_Progressive = 2,
  StreamFormat_Unknown = 3,
  StreamFormat_MIN = StreamFormat_Hls,
  StreamFormat_MAX = StreamFormat_Unknown
};

inline const StreamFormat (&EnumValuesStreamFormat())[4] {
  static const StreamFormat values[] = {
    StreamFormat_Hls,
    StreamFormat_Dash,
    StreamFormat_Progressive,
    StreamFormat_Unknown
  };
  return values;
}

inline const char * const *EnumNamesStreamFormat() {
  static const char * const names[5] = {
    "Hls",
    "Dash",
    "Progressive",
    "Unknown",
    nullptr
  };
  return names;
}

inline const char *EnumNameStreamFormat(StreamFormat e) {
  if (::flatbuffers::IsOutRange(e, StreamFormat_Hls, StreamFormat_Unknown)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesStreamFormat()[index];
}

struct Image FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ImageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_URL = 4,
    VT_LAYOUT = 6,
    VT_WIDTH = 8,
    VT_HEIGHT = 10,
    VT_BLURHASH = 12
  };
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::String *layout() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LAYOUT);
  }
  ::flatbuffers::String *mutable_layout() {
    return GetPointer<::flatbuffers::String *>(VT_LAYOUT);
  }
  uint32_t width() const {
    return GetField<uint32_t>(VT_WIDTH, 0);
  }
  bool mutate_width(uint32_t _width = 0) {
    return SetField<uint32_t>(VT_WIDTH, _width, 0);
  }
  uint32_t height() const {
    return GetField<uint32_t>(VT_HEIGHT, 0);
  }
  bool mutate_height(uint32_t _height = 0) {
    return SetField<uint32_t>(VT_HEIGHT, _height, 0);
  }
  const ::flatbuffers::String *blurhash() const {
    return GetPointer<const ::flatbuffers::String *>(VT_BLURHASH);
  }
  ::flatbuffers::String *mutable_blurhash() {
    return GetPointer<::flatbuffers::String *>(VT_BLURHASH);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyOffset(verifier, VT_LAYOUT) &&
           verifier.VerifyString(layout()) &&
           VerifyField<uint32_t>(verifier, VT_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) &&
           VerifyOffset(verifier, VT_BLURHASH) &&
           verifier.VerifyString(blurhash()) &&
           verifier.EndTable();
  }
};

struct ImageBuilder {
  typedef Image Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(Image::VT_URL, url);
  }
  void add_layout(::flatbuffers::Offset<::flatbuffers::String> layout) {
    fbb_.AddOffset(Image::VT_LAYOUT, layout);
  }
  void add_width(uint32_t width) {
    fbb_.AddElement<uint32_t>(Image::VT_WIDTH, width, 0);
  }
  void add_height(uint32_t height) {
    fbb_.AddElement<uint32_t>(Image::VT_HEIGHT, height, 0);
  }
  void add_blurhash(::flatbuffers::Offset<::flatbuffers::String> blurhash) {
    fbb_.AddOffset(Image::VT_BLURHASH, blurhash);
  }
  explicit ImageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Image> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Image>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Image> CreateImage(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    ::flatbuffers::Offset<::flatbuffers::String> layout = 0,
    uint32_t width = 0,
    uint32_t height = 0,
    ::flatbuffers::Offset<::flatbuffers::String> blurhash = 0) {
  ImageBuilder builder_(_fbb);
  builder_.add_blurhash(blurhash);
  builder_.add_height(height);
  builder_.add_width(width);
  builder_.add_layout(layout);
  builder_.add_url(url);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Image> CreateImageDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *url = nullptr,
    const char *layout = nullptr,
    uint32_t width = 0,
    uint32_t height = 0,
    const char *blurhash = nullptr) {
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto layout__ = layout ? _fbb.CreateString(layout) : 0;
  auto blurhash__ = blurhash ? _fbb.CreateString(blurhash) : 0;
  return bex::wire::CreateImage(
      _fbb,
      url__,
      layout__,
      width,
      height,
      blurhash__);
}

struct ImageSet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ImageSetBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LOW = 4,
    VT_MEDIUM = 6,
    VT_HIGH = 8,
    VT_BACKDROP = 10,
    VT_LOGO = 12
  };
  const bex::wire::Image *low() const {
    return GetPointer<const bex::wire::Image *>(VT_LOW);
  }
  bex::wire::Image *mutable_low() {
    return GetPointer<bex::wire::Image *>(VT_LOW);
  }
  const bex::wire::Image *medium() const {
    return GetPointer<const bex::wire::Image *>(VT_MEDIUM);
  }
  bex::wire::Image *mutable_medium() {
    return GetPointer<bex::wire::Image *>(VT_MEDIUM);
  }
  const bex::wire::Image *high() const {
    return GetPointer<const bex::wire::Image *>(VT_HIGH);
  }
  bex::wire::Image *mutable_high() {
    return GetPointer<bex::wire::Image *>(VT_HIGH);
  }
  const bex::wire::Image *backdrop() const {
    return GetPointer<const bex::wire::Image *>(VT_BACKDROP);
  }
  bex::wire::Image *mutable_backdrop() {
    return GetPointer<bex::wire::Image *>(VT_BACKDROP);
  }
  const bex::wire::Image *logo() const {
    return GetPointer<const bex::wire::Image *>(VT_LOGO);
  }
  bex::wire::Image *mutable_logo() {
    return GetPointer<bex::wire::Image *>(VT_LOGO);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LOW) &&
           verifier.VerifyTable(low()) &&
           VerifyOffset(verifier, VT_MEDIUM) &&
           verifier.VerifyTable(medium()) &&
           VerifyOffset(verifier, VT_HIGH) &&
           verifier.VerifyTable(high()) &&
           VerifyOffset(verifier, VT_BACKDROP) &&
           verifier.VerifyTable(backdrop()) &&
           VerifyOffset(verifier, VT_LOGO) &&
           verifier.VerifyTable(logo()) &&
           verifier.EndTable();
  }
};

struct ImageSetBuilder {
  typedef ImageSet Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_low(::flatbuffers::Offset<bex::wire::Image> low) {
    fbb_.AddOffset(ImageSet::VT_LOW, low);
  }
  void add_medium(::flatbuffers::Offset<bex::wire::Image> medium) {
    fbb_.AddOffset(ImageSet::VT_MEDIUM, medium);
  }
  void add_high(::flatbuffers::Offset<bex::wire::Image> high) {
    fbb_.AddOffset(ImageSet::VT_HIGH, high);
  }
  void add_backdrop(::flatbuffers::Offset<bex::wire::Image> backdrop) {
    fbb_.AddOffset(ImageSet::VT_BACKDROP, backdrop);
  }
  void add_logo(::flatbuffers::Offset<bex::wire::Image> logo) {
    fbb_.AddOffset(ImageSet::VT_LOGO, logo);
  }
  explicit ImageSetBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ImageSet> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ImageSet>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ImageSet> CreateImageSet(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::Image> low = 0,
    ::flatbuffers::Offset<bex::wire::Image> medium = 0,
    ::flatbuffers::Offset<bex::wire::Image> high = 0,
    ::flatbuffers::Offset<bex::wire::Image> backdrop = 0,
    ::flatbuffers::Offset<bex::wire::Image> logo = 0) {
  ImageSetBuilder builder_(_fbb);
  builder_.add_logo(logo);
  builder_.add_backdrop(backdrop);
  builder_.add_high(high);
  builder_.add_medium(medium);
  builder_.add_low(low);
  return builder_.Finish();
}

struct LinkedId FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LinkedIdBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SOURCE = 4,
    VT_ID = 6
  };
  const ::flatbuffers::String *source() const {
    return GetPointer<const ::flatbuffers::String *>(VT_SOURCE);
  }
  ::flatbuffers::String *mutable_source() {
    return GetPointer<::flatbuffers::String *>(VT_SOURCE);
  }
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SOURCE) &&
           verifier.VerifyString(source()) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           verifier.EndTable();
  }
};

struct LinkedIdBuilder {
  typedef LinkedId Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_source(::flatbuffers::Offset<::flatbuffers::String> source) {
    fbb_.AddOffset(LinkedId::VT_SOURCE, source);
  }
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(LinkedId::VT_ID, id);
  }
  explicit LinkedIdBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LinkedId> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LinkedId>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LinkedId> CreateLinkedId(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> source = 0,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0) {
  LinkedIdBuilder builder_(_fbb);
  builder_.add_id(id);
  builder_.add_source(source);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<LinkedId> CreateLinkedIdDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *source = nullptr,
    const char *id = nullptr) {
  auto source__ = source ? _fbb.CreateString(source) : 0;
  auto id__ = id ? _fbb.CreateString(id) : 0;
  return bex::wire::CreateLinkedId(
      _fbb,
      source__,
      id__);
}

struct Attr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AttrBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_KEY = 4,
    VT_VALUE = 6
  };
  const ::flatbuffers::String *key() const {
    return GetPointer<const ::flatbuffers::String *>(VT_KEY);
  }
  ::flatbuffers::String *mutable_key() {
    return GetPointer<::flatbuffers::String *>(VT_KEY);
  }
  const ::flatbuffers::String *value() const {
    return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
  }
  ::flatbuffers::String *mutable_value() {
    return GetPointer<::flatbuffers::String *>(VT_VALUE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_KEY) &&
           verifier.VerifyString(key()) &&
           VerifyOffset(verifier, VT_VALUE) &&
           verifier.VerifyString(value()) &&
           verifier.EndTable();
  }
};

struct AttrBuilder {
  typedef Attr Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
    fbb_.AddOffset(Attr::VT_KEY, key);
  }
  void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
    fbb_.AddOffset(Attr::VT_VALUE, value);
  }
  explicit AttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Attr> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Attr>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Attr> CreateAttr(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> key = 0,
    ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
  AttrBuilder builder_(_fbb);
  builder_.add_value(value);
  builder_.add_key(key);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Attr> CreateAttrDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *key = nullptr,
    const char *value = nullptr) {
  auto key__ = key ? _fbb.CreateString(key) : 0;
  auto value__ = value ? _fbb.CreateString(value) : 0;
  return bex::wire::CreateAttr(
      _fbb,
      key__,
      value__);
}

struct MediaCard FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MediaCardBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_TITLE = 6,
    VT_KIND = 8,
    VT_IMAGES = 10,
    VT_ORIGINAL_TITLE = 12,
    VT_TAGLINE = 14,
    VT_YEAR = 16,
    VT_SCORE = 18,
    VT_GENRES = 20,
    VT_STATUS = 22,
    VT_CONTENT_RATING = 24,
    VT_URL = 26,
    VT_IDS = 28,
    VT_EXTRA = 30
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
  }
  ::flatbuffers::String *mutable_title() {
    return GetPointer<::flatbuffers::String *>(VT_TITLE);
  }
  bex::wire::MediaKind kind() const {
    return static_cast<bex::wire::MediaKind>(GetField<int8_t>(VT_KIND, 0));
  }
  bool mutate_kind(bex::wire::MediaKind _kind = static_cast<bex::wire::MediaKind>(0)) {
    return SetField<int8_t>(VT_KIND, static_cast<int8_t>(_kind), 0);
  }
  const bex::wire::ImageSet *images() const {
    return GetPointer<const bex::wire::ImageSet *>(VT_IMAGES);
  }
  bex::wire::ImageSet *mutable_images() {
    return GetPointer<bex::wire::ImageSet *>(VT_IMAGES);
  }
  const ::flatbuffers::String *original_title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ORIGINAL_TITLE);
  }
  ::flatbuffers::String *mutable_original_title() {
    return GetPointer<::flatbuffers::String *>(VT_ORIGINAL_TITLE);
  }
  const ::flatbuffers::String *tagline() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TAGLINE);
  }
  ::flatbuffers::String *mutable_tagline() {
    return GetPointer<::flatbuffers::String *>(VT_TAGLINE);
  }
  const ::flatbuffers::String *year() const {
    return GetPointer<const ::flatbuffers::String *>(VT_YEAR);
  }
  ::flatbuffers::String *mutable_year() {
    return GetPointer<::flatbuffers::String *>(VT_YEAR);
  }
  uint32_t score() const {
    return GetField<uint32_t>(VT_SCORE, 0);
  }
  bool mutate_score(uint32_t _score = 0) {
    return SetField<uint32_t>(VT_SCORE, _score, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *genres() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_genres() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES);
  }
  bex::wire::Status status() const {
    return static_cast<bex::wire::Status>(GetField<int8_t>(VT_STATUS, 0));
  }
  bool mutate_status(bex::wire::Status _status = static_cast<bex::wire::Status>(0)) {
    return SetField<int8_t>(VT_STATUS, static_cast<int8_t>(_status), 0);
  }
  const ::flatbuffers::String *content_rating() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CONTENT_RATING);
  }
  ::flatbuffers::String *mutable_content_rating() {
    return GetPointer<::flatbuffers::String *>(VT_CONTENT_RATING);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *mutable_ids() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_TITLE) &&
           verifier.VerifyString(title()) &&
           VerifyField<int8_t>(verifier, VT_KIND, 1) &&
           VerifyOffset(verifier, VT_IMAGES) &&
           verifier.VerifyTable(images()) &&
           VerifyOffset(verifier, VT_ORIGINAL_TITLE) &&
           verifier.VerifyString(original_title()) &&
           VerifyOffset(verifier, VT_TAGLINE) &&
           verifier.VerifyString(tagline()) &&
           VerifyOffset(verifier, VT_YEAR) &&
           verifier.VerifyString(year()) &&
           VerifyField<uint32_t>(verifier, VT_SCORE, 4) &&
           VerifyOffset(verifier, VT_GENRES) &&
           verifier.VerifyVector(genres()) &&
           verifier.VerifyVectorOfStrings(genres()) &&
           VerifyField<int8_t>(verifier, VT_STATUS, 1) &&
           VerifyOffset(verifier, VT_CONTENT_RATING) &&
           verifier.VerifyString(content_rating()) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyOffset(verifier, VT_IDS) &&
           verifier.VerifyVector(ids()) &&
           verifier.VerifyVectorOfTables(ids()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.VerifyVectorOfTables(extra()) &&
           verifier.EndTable();
  }
};

struct MediaCardBuilder {
  typedef MediaCard Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(MediaCard::VT_ID, id);
  }
  void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
    fbb_.AddOffset(MediaCard::VT_TITLE, title);
  }
  void add_kind(bex::wire::MediaKind kind) {
    fbb_.AddElement<int8_t>(MediaCard::VT_KIND, static_cast<int8_t>(kind), 0);
  }
  void add_images(::flatbuffers::Offset<bex::wire::ImageSet> images) {
    fbb_.AddOffset(MediaCard::VT_IMAGES, images);
  }
  void add_original_title(::flatbuffers::Offset<::flatbuffers::String> original_title) {
    fbb_.AddOffset(MediaCard::VT_ORIGINAL_TITLE, original_title);
  }
  void add_tagline(::flatbuffers::Offset<::flatbuffers::String> tagline) {
    fbb_.AddOffset(MediaCard::VT_TAGLINE, tagline);
  }
  void add_year(::flatbuffers::Offset<::flatbuffers::String> year) {
    fbb_.AddOffset(MediaCard::VT_YEAR, year);
  }
  void add_score(uint32_t score) {
    fbb_.AddElement<uint32_t>(MediaCard::VT_SCORE, score, 0);
  }
  void add_genres(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres) {
    fbb_.AddOffset(MediaCard::VT_GENRES, genres);
  }
  void add_status(bex::wire::Status status) {
    fbb_.AddElement<int8_t>(MediaCard::VT_STATUS, static_cast<int8_t>(status), 0);
  }
  void add_content_rating(::flatbuffers::Offset<::flatbuffers::String> content_rating) {
    fbb_.AddOffset(MediaCard::VT_CONTENT_RATING, content_rating);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(MediaCard::VT_URL, url);
  }
  void add_ids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids) {
    fbb_.AddOffset(MediaCard::VT_IDS, ids);
  }
  void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) {
    fbb_.AddOffset(MediaCard::VT_EXTRA, extra);
  }
  explicit MediaCardBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MediaCard> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MediaCard>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MediaCard> CreateMediaCard(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> title = 0,
    bex::wire::MediaKind kind = bex::wire::MediaKind_Movie,
    ::flatbuffers::Offset<bex::wire::ImageSet> images = 0,
    ::flatbuffers::Offset<::flatbuffers::String> original_title = 0,
    ::flatbuffers::Offset<::flatbuffers::String> tagline = 0,
    ::flatbuffers::Offset<::flatbuffers::String> year = 0,
    uint32_t score = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres = 0,
    bex::wire::Status status = bex::wire::Status_Unknown,
    ::flatbuffers::Offset<::flatbuffers::String> content_rating = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) {
  MediaCardBuilder builder_(_fbb);
  builder_.add_extra(extra);
  builder_.add_ids(ids);
  builder_.add_url(url);
  builder_.add_content_rating(content_rating);
  builder_.add_genres(genres);
  builder_.add_score(score);
  builder_.add_year(year);
  builder_.add_tagline(tagline);
  builder_.add_original_title(original_title);
  builder_.add_images(images);
  builder_.add_title(title);
  builder_.add_id(id);
  builder_.add_status(status);
  builder_.add_kind(kind);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<MediaCard> CreateMediaCardDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *title = nullptr,
    bex::wire::MediaKind kind = bex::wire::MediaKind_Movie,
    ::flatbuffers::Offset<bex::wire::ImageSet> images = 0,
    const char *original_title = nullptr,
    const char *tagline = nullptr,
    const char *year = nullptr,
    uint32_t score = 0,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *genres = nullptr,
    bex::wire::Status status = bex::wire::Status_Unknown,
    const char *content_rating = nullptr,
    const char *url = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto title__ = title ? _fbb.CreateString(title) : 0;
  auto original_title__ = original_title ? _fbb.CreateString(original_title) : 0;
  auto tagline__ = tagline ? _fbb.CreateString(tagline) : 0;
  auto year__ = year ? _fbb.CreateString(year) : 0;
  auto genres__ = genres ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*genres) : 0;
  auto content_rating__ = content_rating ? _fbb.CreateString(content_rating) : 0;
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto ids__ = ids ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::LinkedId>>(*ids) : 0;
  auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0;
  return bex::wire::CreateMediaCard(
      _fbb,
      id__,
      title__,
      kind,
      images,
      original_title__,
      tagline__,
      year__,
      score,
      genres__,
      status,
      content_rating__,
      url__,
      ids__,
      extra__);
}

struct CategoryLink FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CategoryLinkBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_TITLE = 6,
    VT_SUBTITLE = 8,
    VT_IMAGE = 10
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
  }
  ::flatbuffers::String *mutable_title() {
    return GetPointer<::flatbuffers::String *>(VT_TITLE);
  }
  const ::flatbuffers::String *subtitle() const {
    return GetPointer<const ::flatbuffers::String *>(VT_SUBTITLE);
  }
  ::flatbuffers::String *mutable_subtitle() {
    return GetPointer<::flatbuffers::String *>(VT_SUBTITLE);
  }
  const bex::wire::Image *image() const {
    return GetPointer<const bex::wire::Image *>(VT_IMAGE);
  }
  bex::wire::Image *mutable_image() {
    return GetPointer<bex::wire::Image *>(VT_IMAGE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_TITLE) &&
           verifier.VerifyString(title()) &&
           VerifyOffset(verifier, VT_SUBTITLE) &&
           verifier.VerifyString(subtitle()) &&
           VerifyOffset(verifier, VT_IMAGE) &&
           verifier.VerifyTable(image()) &&
           verifier.EndTable();
  }
};

struct CategoryLinkBuilder {
  typedef CategoryLink Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(CategoryLink::VT_ID, id);
  }
  void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
    fbb_.AddOffset(CategoryLink::VT_TITLE, title);
  }
  void add_subtitle(::flatbuffers::Offset<::flatbuffers::String> subtitle) {
    fbb_.AddOffset(CategoryLink::VT_SUBTITLE, subtitle);
  }
  void add_image(::flatbuffers::Offset<bex::wire::Image> image) {
    fbb_.AddOffset(CategoryLink::VT_IMAGE, image);
  }
  explicit CategoryLinkBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CategoryLink> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CategoryLink>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CategoryLink> CreateCategoryLink(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> title = 0,
    ::flatbuffers::Offset<::flatbuffers::String> subtitle = 0,
    ::flatbuffers::Offset<bex::wire::Image> image = 0) {
  CategoryLinkBuilder builder_(_fbb);
  builder_.add_image(image);
  builder_.add_subtitle(subtitle);
  builder_.add_title(title);
  builder_.add_id(id);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<CategoryLink> CreateCategoryLinkDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *title = nullptr,
    const char *subtitle = nullptr,
    ::flatbuffers::Offset<bex::wire::Image> image = 0) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto title__ = title ? _fbb.CreateString(title) : 0;
  auto subtitle__ = subtitle ? _fbb.CreateString(subtitle) : 0;
  return bex::wire::CreateCategoryLink(
      _fbb,
      id__,
      title__,
      subtitle__,
      image);
}

struct HomeSection FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HomeSectionBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_TITLE = 6,
    VT_SUBTITLE = 8,
    VT_ITEMS = 10,
    VT_NEXT_PAGE = 12,
    VT_LAYOUT = 14,
    VT_SHOW_RANK = 16,
    VT_CATEGORIES = 18,
    VT_EXTRA = 20
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
  }
  ::flatbuffers::String *mutable_title() {
    return GetPointer<::flatbuffers::String *>(VT_TITLE);
  }
  const ::flatbuffers::String *subtitle() const {
    return GetPointer<const ::flatbuffers::String *>(VT_SUBTITLE);
  }
  ::flatbuffers::String *mutable_subtitle() {
    return GetPointer<::flatbuffers::String *>(VT_SUBTITLE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *mutable_items() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS);
  }
  const ::flatbuffers::String *next_page() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NEXT_PAGE);
  }
  ::flatbuffers::String *mutable_next_page() {
    return GetPointer<::flatbuffers::String *>(VT_NEXT_PAGE);
  }
  const ::flatbuffers::String *layout() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LAYOUT);
  }
  ::flatbuffers::String *mutable_layout() {
    return GetPointer<::flatbuffers::String *>(VT_LAYOUT);
  }
  bool show_rank() const {
    return GetField<uint8_t>(VT_SHOW_RANK, 0) != 0;
  }
  bool mutate_show_rank(bool _show_rank = 0) {
    return SetField<uint8_t>(VT_SHOW_RANK, static_cast<uint8_t>(_show_rank), 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *mutable_categories() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_TITLE) &&
           verifier.VerifyString(title()) &&
           VerifyOffset(verifier, VT_SUBTITLE) &&
           verifier.VerifyString(subtitle()) &&
           VerifyOffset(verifier, VT_ITEMS) &&
           verifier.VerifyVector(items()) &&
           verifier.VerifyVectorOfTables(items()) &&
           VerifyOffset(verifier, VT_NEXT_PAGE) &&
           verifier.VerifyString(next_page()) &&
           VerifyOffset(verifier, VT_LAYOUT) &&
           verifier.VerifyString(layout()) &&
           VerifyField<uint8_t>(verifier, VT_SHOW_RANK, 1) &&
           VerifyOffset(verifier, VT_CATEGORIES) &&
           verifier.VerifyVector(categories()) &&
           verifier.VerifyVectorOfTables(categories()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.VerifyVectorOfTables(extra()) &&
           verifier.EndTable();
  }
};

struct HomeSectionBuilder {
  typedef HomeSection Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(HomeSection::VT_ID, id);
  }
  void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
    fbb_.AddOffset(HomeSection::VT_TITLE, title);
  }
  void add_subtitle(::flatbuffers::Offset<::flatbuffers::String> subtitle) {
    fbb_.AddOffset(HomeSection::VT_SUBTITLE, subtitle);
  }
  void add_items(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items) {
    fbb_.AddOffset(HomeSection::VT_ITEMS, items);
  }
  void add_next_page(::flatbuffers::Offset<::flatbuffers::String> next_page) {
    fbb_.AddOffset(HomeSection::VT_NEXT_PAGE, next_page);
  }
  void add_layout(::flatbuffers::Offset<::flatbuffers::String> layout) {
    fbb_.AddOffset(HomeSection::VT_LAYOUT, layout);
  }
  void add_show_rank(bool show_rank) {
    fbb_.AddElement<uint8_t>(HomeSection::VT_SHOW_RANK, static_cast<uint8_t>(show_rank), 0);
  }
  void add_categories(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories) {
    fbb_.AddOffset(HomeSection::VT_CATEGORIES, categories);
  }
  void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) {
    fbb_.AddOffset(HomeSection::VT_EXTRA, extra);
  }
  explicit HomeSectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HomeSection> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HomeSection>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HomeSection> CreateHomeSection(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> title = 0,
    ::flatbuffers::Offset<::flatbuffers::String> subtitle = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items = 0,
    ::flatbuffers::Offset<::flatbuffers::String> next_page = 0,
    ::flatbuffers::Offset<::flatbuffers::String> layout = 0,
    bool show_rank = false,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) {
  HomeSectionBuilder builder_(_fbb);
  builder_.add_extra(extra);
  builder_.add_categories(categories);
  builder_.add_layout(layout);
  builder_.add_next_page(next_page);
  builder_.add_items(items);
  builder_.add_subtitle(subtitle);
  builder_.add_title(title);
  builder_.add_id(id);
  builder_.add_show_rank(show_rank);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<HomeSection> CreateHomeSectionDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *title = nullptr,
    const char *subtitle = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items = nullptr,
    const char *next_page = nullptr,
    const char *layout = nullptr,
    bool show_rank = false,
    const std::vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto title__ = title ? _fbb.CreateString(title) : 0;
  auto subtitle__ = subtitle ? _fbb.CreateString(subtitle) : 0;
  auto items__ = items ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::MediaCard>>(*items) : 0;
  auto next_page__ = next_page ? _fbb.CreateString(next_page) : 0;
  auto layout__ = layout ? _fbb.CreateString(layout) : 0;
  auto categories__ = categories ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::CategoryLink>>(*categories) : 0;
  auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0;
  return bex::wire::CreateHomeSection(
      _fbb,
      id__,
      title__,
      subtitle__,
      items__,
      next_page__,
      layout__,
      show_rank,
      categories__,
      extra__);
}

struct PagedResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PagedResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ITEMS = 4,
    VT_CATEGORIES = 6,
    VT_NEXT_PAGE = 8
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *mutable_items() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *mutable_categories() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES);
  }
  const ::flatbuffers::String *next_page() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NEXT_PAGE);
  }
  ::flatbuffers::String *mutable_next_page() {
    return GetPointer<::flatbuffers::String *>(VT_NEXT_PAGE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ITEMS) &&
           verifier.VerifyVector(items()) &&
           verifier.VerifyVectorOfTables(items()) &&
           VerifyOffset(verifier, VT_CATEGORIES) &&
           verifier.VerifyVector(categories()) &&
           verifier.VerifyVectorOfTables(categories()) &&
           VerifyOffset(verifier, VT_NEXT_PAGE) &&
           verifier.VerifyString(next_page()) &&
           verifier.EndTable();
  }
};

struct PagedResultBuilder {
  typedef PagedResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_items(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items) {
    fbb_.AddOffset(PagedResult::VT_ITEMS, items);
  }
  void add_categories(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories) {
    fbb_.AddOffset(PagedResult::VT_CATEGORIES, categories);
  }
  void add_next_page(::flatbuffers::Offset<::flatbuffers::String> next_page) {
    fbb_.AddOffset(PagedResult::VT_NEXT_PAGE, next_page);
  }
  explicit PagedResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PagedResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PagedResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PagedResult> CreatePagedResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories = 0,
    ::flatbuffers::Offset<::flatbuffers::String> next_page = 0) {
  PagedResultBuilder builder_(_fbb);
  builder_.add_next_page(next_page);
  builder_.add_categories(categories);
  builder_.add_items(items);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<PagedResult> CreatePagedResultDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories = nullptr,
    const char *next_page = nullptr) {
  auto items__ = items ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::MediaCard>>(*items) : 0;
  auto categories__ = categories ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::CategoryLink>>(*categories) : 0;
  auto next_page__ = next_page ? _fbb.CreateString(next_page) : 0;
  return bex::wire::CreatePagedResult(
      _fbb,
      items__,
      categories__,
      next_page__);
}

struct Episode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EpisodeBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_TITLE = 6,
    VT_NUMBER = 8,
    VT_SEASON = 10,
    VT_IMAGES = 12,
    VT_DESCRIPTION = 14,
    VT_RELEASED = 16,
    VT_SCORE = 18,
    VT_URL = 20,
    VT_TAGS = 22,
    VT_EXTRA = 24
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
  }
  ::flatbuffers::String *mutable_title() {
    return GetPointer<::flatbuffers::String *>(VT_TITLE);
  }
  double number() const {
    return GetField<double>(VT_NUMBER, 0.0);
  }
  bool mutate_number(double _number = 0.0) {
    return SetField<double>(VT_NUMBER, _number, 0.0);
  }
  double season() const {
    return GetField<double>(VT_SEASON, 0.0);
  }
  bool mutate_season(double _season = 0.0) {
    return SetField<double>(VT_SEASON, _season, 0.0);
  }
  const bex::wire::ImageSet *images() const {
    return GetPointer<const bex::wire::ImageSet *>(VT_IMAGES);
  }
  bex::wire::ImageSet *mutable_images() {
    return GetPointer<bex::wire::ImageSet *>(VT_IMAGES);
  }
  const ::flatbuffers::String *description() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
  }
  ::flatbuffers::String *mutable_description() {
    return GetPointer<::flatbuffers::String *>(VT_DESCRIPTION);
  }
  const ::flatbuffers::String *released() const {
    return GetPointer<const ::flatbuffers::String *>(VT_RELEASED);
  }
  ::flatbuffers::String *mutable_released() {
    return GetPointer<::flatbuffers::String *>(VT_RELEASED);
  }
  uint32_t score() const {
    return GetField<uint32_t>(VT_SCORE, 0);
  }
  bool mutate_score(uint32_t _score = 0) {
    return SetField<uint32_t>(VT_SCORE, _score, 0);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_tags() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_TITLE) &&
           verifier.VerifyString(title()) &&
           VerifyField<double>(verifier, VT_NUMBER, 8) &&
           VerifyField<double>(verifier, VT_SEASON, 8) &&
           VerifyOffset(verifier, VT_IMAGES) &&
           verifier.VerifyTable(images()) &&
           VerifyOffset(verifier, VT_DESCRIPTION) &&
           verifier.VerifyString(description()) &&
           VerifyOffset(verifier, VT_RELEASED) &&
           verifier.VerifyString(released()) &&
           VerifyField<uint32_t>(verifier, VT_SCORE, 4) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyOffset(verifier, VT_TAGS) &&
           verifier.VerifyVector(tags()) &&
           verifier.VerifyVectorOfStrings(tags()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.VerifyVectorOfTables(extra()) &&
           verifier.EndTable();
  }
};

struct EpisodeBuilder {
  typedef Episode Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(Episode::VT_ID, id);
  }
  void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
    fbb_.AddOffset(Episode::VT_TITLE, title);
  }
  void add_number(double number) {
    fbb_.AddElement<double>(Episode::VT_NUMBER, number, 0.0);
  }
  void add_season(double season) {
    fbb_.AddElement<double>(Episode::VT_SEASON, season, 0.0);
  }
  void add_images(::flatbuffers::Offset<bex::wire::ImageSet> images) {
    fbb_.AddOffset(Episode::VT_IMAGES, images);
  }
  void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
    fbb_.AddOffset(Episode::VT_DESCRIPTION, description);
  }
  void add_released(::flatbuffers::Offset<::flatbuffers::String> released) {
    fbb_.AddOffset(Episode::VT_RELEASED, released);
  }
  void add_score(uint32_t score) {
    fbb_.AddElement<uint32_t>(Episode::VT_SCORE, score, 0);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(Episode::VT_URL, url);
  }
  void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) {
    fbb_.AddOffset(Episode::VT_TAGS, tags);
  }
  void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) {
    fbb_.AddOffset(Episode::VT_EXTRA, extra);
  }
  explicit EpisodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Episode> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Episode>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Episode> CreateEpisode(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> title = 0,
    double number = 0.0,
    double season = 0.0,
    ::flatbuffers::Offset<bex::wire::ImageSet> images = 0,
    ::flatbuffers::Offset<::flatbuffers::String> description = 0,
    ::flatbuffers::Offset<::flatbuffers::String> released = 0,
    uint32_t score = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) {
  EpisodeBuilder builder_(_fbb);
  builder_.add_season(season);
  builder_.add_number(number);
  builder_.add_extra(extra);
  builder_.add_tags(tags);
  builder_.add_url(url);
  builder_.add_score(score);
  builder_.add_released(released);
  builder_.add_description(description);
  builder_.add_images(images);
  builder_.add_title(title);
  builder_.add_id(id);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Episode> CreateEpisodeDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *title = nullptr,
    double number = 0.0,
    double season = 0.0,
    ::flatbuffers::Offset<bex::wire::ImageSet> images = 0,
    const char *description = nullptr,
    const char *released = nullptr,
    uint32_t score = 0,
    const char *url = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto title__ = title ? _fbb.CreateString(title) : 0;
  auto description__ = description ? _fbb.CreateString(description) : 0;
  auto released__ = released ? _fbb.CreateString(released) : 0;
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0;
  auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0;
  return bex::wire::CreateEpisode(
      _fbb,
      id__,
      title__,
      number,
      season,
      images,
      description__,
      released__,
      score,
      url__,
      tags__,
      extra__);
}

struct Season FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SeasonBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_TITLE = 6,
    VT_NUMBER = 8,
    VT_YEAR = 10,
    VT_EPISODES = 12
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
  }
  ::flatbuffers::String *mutable_title() {
    return GetPointer<::flatbuffers::String *>(VT_TITLE);
  }
  double number() const {
    return GetField<double>(VT_NUMBER, 0.0);
  }
  bool mutate_number(double _number = 0.0) {
    return SetField<double>(VT_NUMBER, _number, 0.0);
  }
  uint32_t year() const {
    return GetField<uint32_t>(VT_YEAR, 0);
  }
  bool mutate_year(uint32_t _year = 0) {
    return SetField<uint32_t>(VT_YEAR, _year, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *episodes() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *>(VT_EPISODES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *mutable_episodes() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *>(VT_EPISODES);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_TITLE) &&
           verifier.VerifyString(title()) &&
           VerifyField<double>(verifier, VT_NUMBER, 8) &&
           VerifyField<uint32_t>(verifier, VT_YEAR, 4) &&
           VerifyOffset(verifier, VT_EPISODES) &&
           verifier.VerifyVector(episodes()) &&
           verifier.VerifyVectorOfTables(episodes()) &&
           verifier.EndTable();
  }
};

struct SeasonBuilder {
  typedef Season Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(Season::VT_ID, id);
  }
  void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
    fbb_.AddOffset(Season::VT_TITLE, title);
  }
  void add_number(double number) {
    fbb_.AddElement<double>(Season::VT_NUMBER, number, 0.0);
  }
  void add_year(uint32_t year) {
    fbb_.AddElement<uint32_t>(Season::VT_YEAR, year, 0);
  }
  void add_episodes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>>> episodes) {
    fbb_.AddOffset(Season::VT_EPISODES, episodes);
  }
  explicit SeasonBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Season> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Season>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Season> CreateSeason(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> title = 0,
    double number = 0.0,
    uint32_t year = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>>> episodes = 0) {
  SeasonBuilder builder_(_fbb);
  builder_.add_number(number);
  builder_.add_episodes(episodes);
  builder_.add_year(year);
  builder_.add_title(title);
  builder_.add_id(id);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Season> CreateSeasonDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *title = nullptr,
    double number = 0.0,
    uint32_t year = 0,
    const std::vector<::flatbuffers::Offset<bex::wire::Episode>> *episodes = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto title__ = title ? _fbb.CreateString(title) : 0;
  auto episodes__ = episodes ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Episode>>(*episodes) : 0;
  return bex::wire::CreateSeason(
      _fbb,
      id__,
      title__,
      number,
      year,
      episodes__);
}

struct Person FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PersonBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NAME = 6,
    VT_IMAGE = 8,
    VT_ROLE = 10,
    VT_URL = 12
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  ::flatbuffers::String *mutable_name() {
    return GetPointer<::flatbuffers::String *>(VT_NAME);
  }
  const bex::wire::ImageSet *image() const {
    return GetPointer<const bex::wire::ImageSet *>(VT_IMAGE);
  }
  bex::wire::ImageSet *mutable_image() {
    return GetPointer<bex::wire::ImageSet *>(VT_IMAGE);
  }
  const ::flatbuffers::String *role() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ROLE);
  }
  ::flatbuffers::String *mutable_role() {
    return GetPointer<::flatbuffers::String *>(VT_ROLE);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_IMAGE) &&
           verifier.VerifyTable(image()) &&
           VerifyOffset(verifier, VT_ROLE) &&
           verifier.VerifyString(role()) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           verifier.EndTable();
  }
};

struct PersonBuilder {
  typedef Person Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(Person::VT_ID, id);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Person::VT_NAME, name);
  }
  void add_image(::flatbuffers::Offset<bex::wire::ImageSet> image) {
    fbb_.AddOffset(Person::VT_IMAGE, image);
  }
  void add_role(::flatbuffers::Offset<::flatbuffers::String> role) {
    fbb_.AddOffset(Person::VT_ROLE, role);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(Person::VT_URL, url);
  }
  explicit PersonBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Person> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Person>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Person> CreatePerson(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<bex::wire::ImageSet> image = 0,
    ::flatbuffers::Offset<::flatbuffers::String> role = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0) {
  PersonBuilder builder_(_fbb);
  builder_.add_url(url);
  builder_.add_role(role);
  builder_.add_image(image);
  builder_.add_name(name);
  builder_.add_id(id);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Person> CreatePersonDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *name = nullptr,
    ::flatbuffers::Offset<bex::wire::ImageSet> image = 0,
    const char *role = nullptr,
    const char *url = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto role__ = role ? _fbb.CreateString(role) : 0;
  auto url__ = url ? _fbb.CreateString(url) : 0;
  return bex::wire::CreatePerson(
      _fbb,
      id__,
      name__,
      image,
      role__,
      url__);
}

struct MediaInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MediaInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_TITLE = 6,
    VT_KIND = 8,
    VT_IMAGES = 10,
    VT_ORIGINAL_TITLE = 12,
    VT_DESCRIPTION = 14,
    VT_SCORE = 16,
    VT_SCORED_BY = 18,
    VT_YEAR = 20,
    VT_RELEASE_DATE = 22,
    VT_GENRES = 24,
    VT_TAGS = 26,
    VT_STATUS = 28,
    VT_CONTENT_RATING = 30,
    VT_SEASONS = 32,
    VT_CAST = 34,
    VT_CREW = 36,
    VT_RUNTIME_MINUTES = 38,
    VT_TRAILER_URL = 40,
    VT_IDS = 42,
    VT_STUDIO = 44,
    VT_COUNTRY = 46,
    VT_LANGUAGE = 48,
    VT_URL = 50,
    VT_EXTRA = 52
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
  }
  ::flatbuffers::String *mutable_title() {
    return GetPointer<::flatbuffers::String *>(VT_TITLE);
  }
  bex::wire::MediaKind kind() const {
    return static_cast<bex::wire::MediaKind>(GetField<int8_t>(VT_KIND, 0));
  }
  bool mutate_kind(bex::wire::MediaKind _kind = static_cast<bex::wire::MediaKind>(0)) {
    return SetField<int8_t>(VT_KIND, static_cast<int8_t>(_kind), 0);
  }
  const bex::wire::ImageSet *images() const {
    return GetPointer<const bex::wire::ImageSet *>(VT_IMAGES);
  }
  bex::wire::ImageSet *mutable_images() {
    return GetPointer<bex::wire::ImageSet *>(VT_IMAGES);
  }
  const ::flatbuffers::String *original_title() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ORIGINAL_TITLE);
  }
  ::flatbuffers::String *mutable_original_title() {
    return GetPointer<::flatbuffers::String *>(VT_ORIGINAL_TITLE);
  }
  const ::flatbuffers::String *description() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
  }
  ::flatbuffers::String *mutable_description() {
    return GetPointer<::flatbuffers::String *>(VT_DESCRIPTION);
  }
  uint32_t score() const {
    return GetField<uint32_t>(VT_SCORE, 0);
  }
  bool mutate_score(uint32_t _score = 0) {
    return SetField<uint32_t>(VT_SCORE, _score, 0);
  }
  uint64_t scored_by() const {
    return GetField<uint64_t>(VT_SCORED_BY, 0);
  }
  bool mutate_scored_by(uint64_t _scored_by = 0) {
    return SetField<uint64_t>(VT_SCORED_BY, _scored_by, 0);
  }
  const ::flatbuffers::String *year() const {
    return GetPointer<const ::flatbuffers::String *>(VT_YEAR);
  }
  ::flatbuffers::String *mutable_year() {
    return GetPointer<::flatbuffers::String *>(VT_YEAR);
  }
  const ::flatbuffers::String *release_date() const {
    return GetPointer<const ::flatbuffers::String *>(VT_RELEASE_DATE);
  }
  ::flatbuffers::String *mutable_release_date() {
    return GetPointer<::flatbuffers::String *>(VT_RELEASE_DATE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *genres() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_genres() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_tags() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS);
  }
  bex::wire::Status status() const {
    return static_cast<bex::wire::Status>(GetField<int8_t>(VT_STATUS, 0));
  }
  bool mutate_status(bex::wire::Status _status = static_cast<bex::wire::Status>(0)) {
    return SetField<int8_t>(VT_STATUS, static_cast<int8_t>(_status), 0);
  }
  const ::flatbuffers::String *content_rating() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CONTENT_RATING);
  }
  ::flatbuffers::String *mutable_content_rating() {
    return GetPointer<::flatbuffers::String *>(VT_CONTENT_RATING);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *seasons() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *>(VT_SEASONS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *mutable_seasons() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *>(VT_SEASONS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *cast() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CAST);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *mutable_cast() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CAST);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *crew() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CREW);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *mutable_crew() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CREW);
  }
  uint32_t runtime_minutes() const {
    return GetField<uint32_t>(VT_RUNTIME_MINUTES, 0);
  }
  bool mutate_runtime_minutes(uint32_t _runtime_minutes = 0) {
    return SetField<uint32_t>(VT_RUNTIME_MINUTES, _runtime_minutes, 0);
  }
  const ::flatbuffers::String *trailer_url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TRAILER_URL);
  }
  ::flatbuffers::String *mutable_trailer_url() {
    return GetPointer<::flatbuffers::String *>(VT_TRAILER_URL);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *mutable_ids() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS);
  }
  const ::flatbuffers::String *studio() const {
    return GetPointer<const ::flatbuffers::String *>(VT_STUDIO);
  }
  ::flatbuffers::String *mutable_studio() {
    return GetPointer<::flatbuffers::String *>(VT_STUDIO);
  }
  const ::flatbuffers::String *country() const {
    return GetPointer<const ::flatbuffers::String *>(VT_COUNTRY);
  }
  ::flatbuffers::String *mutable_country() {
    return GetPointer<::flatbuffers::String *>(VT_COUNTRY);
  }
  const ::flatbuffers::String *language() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LANGUAGE);
  }
  ::flatbuffers::String *mutable_language() {
    return GetPointer<::flatbuffers::String *>(VT_LANGUAGE);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_TITLE) &&
           verifier.VerifyString(title()) &&
           VerifyField<int8_t>(verifier, VT_KIND, 1) &&
           VerifyOffset(verifier, VT_IMAGES) &&
           verifier.VerifyTable(images()) &&
           VerifyOffset(verifier, VT_ORIGINAL_TITLE) &&
           verifier.VerifyString(original_title()) &&
           VerifyOffset(verifier, VT_DESCRIPTION) &&
           verifier.VerifyString(description()) &&
           VerifyField<uint32_t>(verifier, VT_SCORE, 4) &&
           VerifyField<uint64_t>(verifier, VT_SCORED_BY, 8) &&
           VerifyOffset(verifier, VT_YEAR) &&
           verifier.VerifyString(year()) &&
           VerifyOffset(verifier, VT_RELEASE_DATE) &&
           verifier.VerifyString(release_date()) &&
           VerifyOffset(verifier, VT_GENRES) &&
           verifier.VerifyVector(genres()) &&
           verifier.VerifyVectorOfStrings(genres()) &&
           VerifyOffset(verifier, VT_TAGS) &&
           verifier.VerifyVector(tags()) &&
           verifier.VerifyVectorOfStrings(tags()) &&
           VerifyField<int8_t>(verifier, VT_STATUS, 1) &&
           VerifyOffset(verifier, VT_CONTENT_RATING) &&
           verifier.VerifyString(content_rating()) &&
           VerifyOffset(verifier, VT_SEASONS) &&
           verifier.VerifyVector(seasons()) &&
           verifier.VerifyVectorOfTables(seasons()) &&
           VerifyOffset(verifier, VT_CAST) &&
           verifier.VerifyVector(cast()) &&
           verifier.VerifyVectorOfTables(cast()) &&
           VerifyOffset(verifier, VT_CREW) &&
           verifier.VerifyVector(crew()) &&
           verifier.VerifyVectorOfTables(crew()) &&
           VerifyField<uint32_t>(verifier, VT_RUNTIME_MINUTES, 4) &&
           VerifyOffset(verifier, VT_TRAILER_URL) &&
           verifier.VerifyString(trailer_url()) &&
           VerifyOffset(verifier, VT_IDS) &&
           verifier.VerifyVector(ids()) &&
           verifier.VerifyVectorOfTables(ids()) &&
           VerifyOffset(verifier, VT_STUDIO) &&
           verifier.VerifyString(studio()) &&
           VerifyOffset(verifier, VT_COUNTRY) &&
           verifier.VerifyString(country()) &&
           VerifyOffset(verifier, VT_LANGUAGE) &&
           verifier.VerifyString(language()) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.VerifyVectorOfTables(extra()) &&
           verifier.EndTable();
  }
};

struct MediaInfoBuilder {
  typedef MediaInfo Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(MediaInfo::VT_ID, id);
  }
  void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
    fbb_.AddOffset(MediaInfo::VT_TITLE, title);
  }
  void add_kind(bex::wire::MediaKind kind) {
    fbb_.AddElement<int8_t>(MediaInfo::VT_KIND, static_cast<int8_t>(kind), 0);
  }
  void add_images(::flatbuffers::Offset<bex::wire::ImageSet> images) {
    fbb_.AddOffset(MediaInfo::VT_IMAGES, images);
  }
  void add_original_title(::flatbuffers::Offset<::flatbuffers::String> original_title) {
    fbb_.AddOffset(MediaInfo::VT_ORIGINAL_TITLE, original_title);
  }
  void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
    fbb_.AddOffset(MediaInfo::VT_DESCRIPTION, description);
  }
  void add_score(uint32_t score) {
    fbb_.AddElement<uint32_t>(MediaInfo::VT_SCORE, score, 0);
  }
  void add_scored_by(uint64_t scored_by) {
    fbb_.AddElement<uint64_t>(MediaInfo::VT_SCORED_BY, scored_by, 0);
  }
  void add_year(::flatbuffers::Offset<::flatbuffers::String> year) {
    fbb_.AddOffset(MediaInfo::VT_YEAR, year);
  }
  void add_release_date(::flatbuffers::Offset<::flatbuffers::String> release_date) {
    fbb_.AddOffset(MediaInfo::VT_RELEASE_DATE, release_date);
  }
  void add_genres(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres) {
    fbb_.AddOffset(MediaInfo::VT_GENRES, genres);
  }
  void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) {
    fbb_.AddOffset(MediaInfo::VT_TAGS, tags);
  }
  void add_status(bex::wire::Status status) {
    fbb_.AddElement<int8_t>(MediaInfo::VT_STATUS, static_cast<int8_t>(status), 0);
  }
  void add_content_rating(::flatbuffers::Offset<::flatbuffers::String> content_rating) {
    fbb_.AddOffset(MediaInfo::VT_CONTENT_RATING, content_rating);
  }
  void add_seasons(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>>> seasons) {
    fbb_.AddOffset(MediaInfo::VT_SEASONS, seasons);
  }
  void add_cast(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> cast) {
    fbb_.AddOffset(MediaInfo::VT_CAST, cast);
  }
  void add_crew(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> crew) {
    fbb_.AddOffset(MediaInfo::VT_CREW, crew);
  }
  void add_runtime_minutes(uint32_t runtime_minutes) {
    fbb_.AddElement<uint32_t>(MediaInfo::VT_RUNTIME_MINUTES, runtime_minutes, 0);
  }
  void add_trailer_url(::flatbuffers::Offset<::flatbuffers::String> trailer_url) {
    fbb_.AddOffset(MediaInfo::VT_TRAILER_URL, trailer_url);
  }
  void add_ids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids) {
    fbb_.AddOffset(MediaInfo::VT_IDS, ids);
  }
  void add_studio(::flatbuffers::Offset<::flatbuffers::String> studio) {
    fbb_.AddOffset(MediaInfo::VT_STUDIO, studio);
  }
  void add_country(::flatbuffers::Offset<::flatbuffers::String> country) {
    fbb_.AddOffset(MediaInfo::VT_COUNTRY, country);
  }
  void add_language(::flatbuffers::Offset<::flatbuffers::String> language) {
    fbb_.AddOffset(MediaInfo::VT_LANGUAGE, language);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(MediaInfo::VT_URL, url);
  }
  void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) {
    fbb_.AddOffset(MediaInfo::VT_EXTRA, extra);
  }
  explicit MediaInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MediaInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MediaInfo>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MediaInfo> CreateMediaInfo(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> title = 0,
    bex::wire::MediaKind kind = bex::wire::MediaKind_Movie,
    ::flatbuffers::Offset<bex::wire::ImageSet> images = 0,
    ::flatbuffers::Offset<::flatbuffers::String> original_title = 0,
    ::flatbuffers::Offset<::flatbuffers::String> description = 0,
    uint32_t score = 0,
    uint64_t scored_by = 0,
    ::flatbuffers::Offset<::flatbuffers::String> year = 0,
    ::flatbuffers::Offset<::flatbuffers::String> release_date = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0,
    bex::wire::Status status = bex::wire::Status_Unknown,
    ::flatbuffers::Offset<::flatbuffers::String> content_rating = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>>> seasons = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> cast = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> crew = 0,
    uint32_t runtime_minutes = 0,
    ::flatbuffers::Offset<::flatbuffers::String> trailer_url = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids = 0,
    ::flatbuffers::Offset<::flatbuffers::String> studio = 0,
    ::flatbuffers::Offset<::flatbuffers::String> country = 0,
    ::flatbuffers::Offset<::flatbuffers::String> language = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) {
  MediaInfoBuilder builder_(_fbb);
  builder_.add_scored_by(scored_by);
  builder_.add_extra(extra);
  builder_.add_url(url);
  builder_.add_language(language);
  builder_.add_country(country);
  builder_.add_studio(studio);
  builder_.add_ids(ids);
  builder_.add_trailer_url(trailer_url);
  builder_.add_runtime_minutes(runtime_minutes);
  builder_.add_crew(crew);
  builder_.add_cast(cast);
  builder_.add_seasons(seasons);
  builder_.add_content_rating(content_rating);
  builder_.add_tags(tags);
  builder_.add_genres(genres);
  builder_.add_release_date(release_date);
  builder_.add_year(year);
  builder_.add_score(score);
  builder_.add_description(description);
  builder_.add_original_title(original_title);
  builder_.add_images(images);
  builder_.add_title(title);
  builder_.add_id(id);
  builder_.add_status(status);
  builder_.add_kind(kind);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<MediaInfo> CreateMediaInfoDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *title = nullptr,
    bex::wire::MediaKind kind = bex::wire::MediaKind_Movie,
    ::flatbuffers::Offset<bex::wire::ImageSet> images = 0,
    const char *original_title = nullptr,
    const char *description = nullptr,
    uint32_t score = 0,
    uint64_t scored_by = 0,
    const char *year = nullptr,
    const char *release_date = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *genres = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr,
    bex::wire::Status status = bex::wire::Status_Unknown,
    const char *content_rating = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Season>> *seasons = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Person>> *cast = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Person>> *crew = nullptr,
    uint32_t runtime_minutes = 0,
    const char *trailer_url = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids = nullptr,
    const char *studio = nullptr,
    const char *country = nullptr,
    const char *language = nullptr,
    const char *url = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto title__ = title ? _fbb.CreateString(title) : 0;
  auto original_title__ = original_title ? _fbb.CreateString(original_title) : 0;
  auto description__ = description ? _fbb.CreateString(description) : 0;
  auto year__ = year ? _fbb.CreateString(year) : 0;
  auto release_date__ = release_date ? _fbb.CreateString(release_date) : 0;
  auto genres__ = genres ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*genres) : 0;
  auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0;
  auto content_rating__ = content_rating ? _fbb.CreateString(content_rating) : 0;
  auto seasons__ = seasons ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Season>>(*seasons) : 0;
  auto cast__ = cast ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Person>>(*cast) : 0;
  auto crew__ = crew ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Person>>(*crew) : 0;
  auto trailer_url__ = trailer_url ? _fbb.CreateString(trailer_url) : 0;
  auto ids__ = ids ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::LinkedId>>(*ids) : 0;
  auto studio__ = studio ? _fbb.CreateString(studio) : 0;
  auto country__ = country ? _fbb.CreateString(country) : 0;
  auto language__ = language ? _fbb.CreateString(language) : 0;
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0;
  return bex::wire::CreateMediaInfo(
      _fbb,
      id__,
      title__,
      kind,
      images,
      original_title__,
      description__,
      score,
      scored_by,
      year__,
      release_date__,
      genres__,
      tags__,
      status,
      content_rating__,
      seasons__,
      cast__,
      crew__,
      runtime_minutes,
      trailer_url__,
      ids__,
      studio__,
      country__,
      language__,
      url__,
      extra__);
}

struct VideoResolution FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VideoResolutionBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WIDTH = 4,
    VT_HEIGHT = 6,
    VT_HDR = 8,
    VT_LABEL = 10
  };
  uint32_t width() const {
    return GetField<uint32_t>(VT_WIDTH, 0);
  }
  bool mutate_width(uint32_t _width = 0) {
    return SetField<uint32_t>(VT_WIDTH, _width, 0);
  }
  uint32_t height() const {
    return GetField<uint32_t>(VT_HEIGHT, 0);
  }
  bool mutate_height(uint32_t _height = 0) {
    return SetField<uint32_t>(VT_HEIGHT, _height, 0);
  }
  bool hdr() const {
    return GetField<uint8_t>(VT_HDR, 0) != 0;
  }
  bool mutate_hdr(bool _hdr = 0) {
    return SetField<uint8_t>(VT_HDR, static_cast<uint8_t>(_hdr), 0);
  }
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LABEL);
  }
  ::flatbuffers::String *mutable_label() {
    return GetPointer<::flatbuffers::String *>(VT_LABEL);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) &&
           VerifyField<uint8_t>(verifier, VT_HDR, 1) &&
           VerifyOffset(verifier, VT_LABEL) &&
           verifier.VerifyString(label()) &&
           verifier.EndTable();
  }
};

struct VideoResolutionBuilder {
  typedef VideoResolution Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_width(uint32_t width) {
    fbb_.AddElement<uint32_t>(VideoResolution::VT_WIDTH, width, 0);
  }
  void add_height(uint32_t height) {
    fbb_.AddElement<uint32_t>(VideoResolution::VT_HEIGHT, height, 0);
  }
  void add_hdr(bool hdr) {
    fbb_.AddElement<uint8_t>(VideoResolution::VT_HDR, static_cast<uint8_t>(hdr), 0);
  }
  void add_label(::flatbuffers::Offset<::flatbuffers::String> label) {
    fbb_.AddOffset(VideoResolution::VT_LABEL, label);
  }
  explicit VideoResolutionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VideoResolution> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VideoResolution>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VideoResolution> CreateVideoResolution(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t width = 0,
    uint32_t height = 0,
    bool hdr = false,
    ::flatbuffers::Offset<::flatbuffers::String> label = 0) {
  VideoResolutionBuilder builder_(_fbb);
  builder_.add_label(label);
  builder_.add_height(height);
  builder_.add_width(width);
  builder_.add_hdr(hdr);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VideoResolution> CreateVideoResolutionDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t width = 0,
    uint32_t height = 0,
    bool hdr = false,
    const char *label = nullptr) {
  auto label__ = label ? _fbb.CreateString(label) : 0;
  return bex::wire::CreateVideoResolution(
      _fbb,
      width,
      height,
      hdr,
      label__);
}

struct VideoTrack FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VideoTrackBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RESOLUTION = 4,
    VT_URL = 6,
    VT_MIME_TYPE = 8,
    VT_BITRATE = 10,
    VT_CODECS = 12
  };
  const bex::wire::VideoResolution *resolution() const {
    return GetPointer<const bex::wire::VideoResolution *>(VT_RESOLUTION);
  }
  bex::wire::VideoResolution *mutable_resolution() {
    return GetPointer<bex::wire::VideoResolution *>(VT_RESOLUTION);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::String *mime_type() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MIME_TYPE);
  }
  ::flatbuffers::String *mutable_mime_type() {
    return GetPointer<::flatbuffers::String *>(VT_MIME_TYPE);
  }
  uint64_t bitrate() const {
    return GetField<uint64_t>(VT_BITRATE, 0);
  }
  bool mutate_bitrate(uint64_t _bitrate = 0) {
    return SetField<uint64_t>(VT_BITRATE, _bitrate, 0);
  }
  const ::flatbuffers::String *codecs() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CODECS);
  }
  ::flatbuffers::String *mutable_codecs() {
    return GetPointer<::flatbuffers::String *>(VT_CODECS);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_RESOLUTION) &&
           verifier.VerifyTable(resolution()) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyOffset(verifier, VT_MIME_TYPE) &&
           verifier.VerifyString(mime_type()) &&
           VerifyField<uint64_t>(verifier, VT_BITRATE, 8) &&
           VerifyOffset(verifier, VT_CODECS) &&
           verifier.VerifyString(codecs()) &&
           verifier.EndTable();
  }
};

struct VideoTrackBuilder {
  typedef VideoTrack Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_resolution(::flatbuffers::Offset<bex::wire::VideoResolution> resolution) {
    fbb_.AddOffset(VideoTrack::VT_RESOLUTION, resolution);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(VideoTrack::VT_URL, url);
  }
  void add_mime_type(::flatbuffers::Offset<::flatbuffers::String> mime_type) {
    fbb_.AddOffset(VideoTrack::VT_MIME_TYPE, mime_type);
  }
  void add_bitrate(uint64_t bitrate) {
    fbb_.AddElement<uint64_t>(VideoTrack::VT_BITRATE, bitrate, 0);
  }
  void add_codecs(::flatbuffers::Offset<::flatbuffers::String> codecs) {
    fbb_.AddOffset(VideoTrack::VT_CODECS, codecs);
  }
  explicit VideoTrackBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VideoTrack> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VideoTrack>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VideoTrack> CreateVideoTrack(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::VideoResolution> resolution = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    ::flatbuffers::Offset<::flatbuffers::String> mime_type = 0,
    uint64_t bitrate = 0,
    ::flatbuffers::Offset<::flatbuffers::String> codecs = 0) {
  VideoTrackBuilder builder_(_fbb);
  builder_.add_bitrate(bitrate);
  builder_.add_codecs(codecs);
  builder_.add_mime_type(mime_type);
  builder_.add_url(url);
  builder_.add_resolution(resolution);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VideoTrack> CreateVideoTrackDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::VideoResolution> resolution = 0,
    const char *url = nullptr,
    const char *mime_type = nullptr,
    uint64_t bitrate = 0,
    const char *codecs = nullptr) {
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto mime_type__ = mime_type ? _fbb.CreateString(mime_type) : 0;
  auto codecs__ = codecs ? _fbb.CreateString(codecs) : 0;
  return bex::wire::CreateVideoTrack(
      _fbb,
      resolution,
      url__,
      mime_type__,
      bitrate,
      codecs__);
}

struct SubtitleTrack FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SubtitleTrackBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LABEL = 4,
    VT_URL = 6,
    VT_LANGUAGE = 8,
    VT_FORMAT = 10
  };
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LABEL);
  }
  ::flatbuffers::String *mutable_label() {
    return GetPointer<::flatbuffers::String *>(VT_LABEL);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::String *language() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LANGUAGE);
  }
  ::flatbuffers::String *mutable_language() {
    return GetPointer<::flatbuffers::String *>(VT_LANGUAGE);
  }
  const ::flatbuffers::String *format() const {
    return GetPointer<const ::flatbuffers::String *>(VT_FORMAT);
  }
  ::flatbuffers::String *mutable_format() {
    return GetPointer<::flatbuffers::String *>(VT_FORMAT);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LABEL) &&
           verifier.VerifyString(label()) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyOffset(verifier, VT_LANGUAGE) &&
           verifier.VerifyString(language()) &&
           VerifyOffset(verifier, VT_FORMAT) &&
           verifier.VerifyString(format()) &&
           verifier.EndTable();
  }
};

struct SubtitleTrackBuilder {
  typedef SubtitleTrack Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_label(::flatbuffers::Offset<::flatbuffers::String> label) {
    fbb_.AddOffset(SubtitleTrack::VT_LABEL, label);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(SubtitleTrack::VT_URL, url);
  }
  void add_language(::flatbuffers::Offset<::flatbuffers::String> language) {
    fbb_.AddOffset(SubtitleTrack::VT_LANGUAGE, language);
  }
  void add_format(::flatbuffers::Offset<::flatbuffers::String> format) {
    fbb_.AddOffset(SubtitleTrack::VT_FORMAT, format);
  }
  explicit SubtitleTrackBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SubtitleTrack> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SubtitleTrack>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SubtitleTrack> CreateSubtitleTrack(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> label = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    ::flatbuffers::Offset<::flatbuffers::String> language = 0,
    ::flatbuffers::Offset<::flatbuffers::String> format = 0) {
  SubtitleTrackBuilder builder_(_fbb);
  builder_.add_format(format);
  builder_.add_language(language);
  builder_.add_url(url);
  builder_.add_label(label);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<SubtitleTrack> CreateSubtitleTrackDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *label = nullptr,
    const char *url = nullptr,
    const char *language = nullptr,
    const char *format = nullptr) {
  auto label__ = label ? _fbb.CreateString(label) : 0;
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto language__ = language ? _fbb.CreateString(language) : 0;
  auto format__ = format ? _fbb.CreateString(format) : 0;
  return bex::wire::CreateSubtitleTrack(
      _fbb,
      label__,
      url__,
      language__,
      format__);
}

struct Server FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ServerBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_LABEL = 6,
    VT_URL = 8,
    VT_PRIORITY = 10,
    VT_EXTRA = 12
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LABEL);
  }
  ::flatbuffers::String *mutable_label() {
    return GetPointer<::flatbuffers::String *>(VT_LABEL);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  ::flatbuffers::String *mutable_url() {
    return GetPointer<::flatbuffers::String *>(VT_URL);
  }
  uint8_t priority() const {
    return GetField<uint8_t>(VT_PRIORITY, 0);
  }
  bool mutate_priority(uint8_t _priority = 0) {
    return SetField<uint8_t>(VT_PRIORITY, _priority, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_LABEL) &&
           verifier.VerifyString(label()) &&
           VerifyOffset(verifier, VT_URL) &&
           verifier.VerifyString(url()) &&
           VerifyField<uint8_t>(verifier, VT_PRIORITY, 1) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.VerifyVectorOfTables(extra()) &&
           verifier.EndTable();
  }
};

struct ServerBuilder {
  typedef Server Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(Server::VT_ID, id);
  }
  void add_label(::flatbuffers::Offset<::flatbuffers::String> label) {
    fbb_.AddOffset(Server::VT_LABEL, label);
  }
  void add_url(::flatbuffers::Offset<::flatbuffers::String> url) {
    fbb_.AddOffset(Server::VT_URL, url);
  }
  void add_priority(uint8_t priority) {
    fbb_.AddElement<uint8_t>(Server::VT_PRIORITY, priority, 0);
  }
  void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) {
    fbb_.AddOffset(Server::VT_EXTRA, extra);
  }
  explicit ServerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Server> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Server>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Server> CreateServer(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> label = 0,
    ::flatbuffers::Offset<::flatbuffers::String> url = 0,
    uint8_t priority = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) {
  ServerBuilder builder_(_fbb);
  builder_.add_extra(extra);
  builder_.add_url(url);
  builder_.add_label(label);
  builder_.add_id(id);
  builder_.add_priority(priority);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Server> CreateServerDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *label = nullptr,
    const char *url = nullptr,
    uint8_t priority = 0,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto label__ = label ? _fbb.CreateString(label) : 0;
  auto url__ = url ? _fbb.CreateString(url) : 0;
  auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0;
  return bex::wire::CreateServer(
      _fbb,
      id__,
      label__,
      url__,
      priority,
      extra__);
}

struct StreamSource FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StreamSourceBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_LABEL = 6,
    VT_FORMAT = 8,
    VT_MANIFEST_URL = 10,
    VT_VIDEOS = 12,
    VT_SUBTITLES = 14,
    VT_HEADERS = 16,
    VT_EXTRA = 18
  };
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ID);
  }
  ::flatbuffers::String *mutable_id() {
    return GetPointer<::flatbuffers::String *>(VT_ID);
  }
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LABEL);
  }
  ::flatbuffers::String *mutable_label() {
    return GetPointer<::flatbuffers::String *>(VT_LABEL);
  }
  bex::wire::StreamFormat format() const {
    return static_cast<bex::wire::StreamFormat>(GetField<int8_t>(VT_FORMAT, 0));
  }
  bool mutate_format(bex::wire::StreamFormat _format = static_cast<bex::wire::StreamFormat>(0)) {
    return SetField<int8_t>(VT_FORMAT, static_cast<int8_t>(_format), 0);
  }
  const ::flatbuffers::String *manifest_url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MANIFEST_URL);
  }
  ::flatbuffers::String *mutable_manifest_url() {
    return GetPointer<::flatbuffers::String *>(VT_MANIFEST_URL);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *videos() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *>(VT_VIDEOS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *mutable_videos() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *>(VT_VIDEOS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *subtitles() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *>(VT_SUBTITLES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *mutable_subtitles() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *>(VT_SUBTITLES);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *headers() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_HEADERS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_headers() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_HEADERS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ID) &&
           verifier.VerifyString(id()) &&
           VerifyOffset(verifier, VT_LABEL) &&
           verifier.VerifyString(label()) &&
           VerifyField<int8_t>(verifier, VT_FORMAT, 1) &&
           VerifyOffset(verifier, VT_MANIFEST_URL) &&
           verifier.VerifyString(manifest_url()) &&
           VerifyOffset(verifier, VT_VIDEOS) &&
           verifier.VerifyVector(videos()) &&
           verifier.VerifyVectorOfTables(videos()) &&
           VerifyOffset(verifier, VT_SUBTITLES) &&
           verifier.VerifyVector(subtitles()) &&
           verifier.VerifyVectorOfTables(subtitles()) &&
           VerifyOffset(verifier, VT_HEADERS) &&
           verifier.VerifyVector(headers()) &&
           verifier.VerifyVectorOfTables(headers()) &&
           VerifyOffset(verifier, VT_EXTRA) &&
           verifier.VerifyVector(extra()) &&
           verifier.VerifyVectorOfTables(extra()) &&
           verifier.EndTable();
  }
};

struct StreamSourceBuilder {
  typedef StreamSource Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(::flatbuffers::Offset<::flatbuffers::String> id) {
    fbb_.AddOffset(StreamSource::VT_ID, id);
  }
  void add_label(::flatbuffers::Offset<::flatbuffers::String> label) {
    fbb_.AddOffset(StreamSource::VT_LABEL, label);
  }
  void add_format(bex::wire::StreamFormat format) {
    fbb_.AddElement<int8_t>(StreamSource::VT_FORMAT, static_cast<int8_t>(format), 0);
  }
  void add_manifest_url(::flatbuffers::Offset<::flatbuffers::String> manifest_url) {
    fbb_.AddOffset(StreamSource::VT_MANIFEST_URL, manifest_url);
  }
  void add_videos(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>>> videos) {
    fbb_.AddOffset(StreamSource::VT_VIDEOS, videos);
  }
  void add_subtitles(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>>> subtitles) {
    fbb_.AddOffset(StreamSource::VT_SUBTITLES, subtitles);
  }
  void add_headers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> headers) {
    fbb_.AddOffset(StreamSource::VT_HEADERS, headers);
  }
  void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) {
    fbb_.AddOffset(StreamSource::VT_EXTRA, extra);
  }
  explicit StreamSourceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StreamSource> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StreamSource>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StreamSource> CreateStreamSource(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> label = 0,
    bex::wire::StreamFormat format = bex::wire::StreamFormat_Hls,
    ::flatbuffers::Offset<::flatbuffers::String> manifest_url = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>>> videos = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>>> subtitles = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> headers = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) {
  StreamSourceBuilder builder_(_fbb);
  builder_.add_extra(extra);
  builder_.add_headers(headers);
  builder_.add_subtitles(subtitles);
  builder_.add_videos(videos);
  builder_.add_manifest_url(manifest_url);
  builder_.add_label(label);
  builder_.add_id(id);
  builder_.add_format(format);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StreamSource> CreateStreamSourceDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    const char *label = nullptr,
    bex::wire::StreamFormat format = bex::wire::StreamFormat_Hls,
    const char *manifest_url = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *videos = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *subtitles = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *headers = nullptr,
    const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) {
  auto id__ = id ? _fbb.CreateString(id) : 0;
  auto label__ = label ? _fbb.CreateString(label) : 0;
  auto manifest_url__ = manifest_url ? _fbb.CreateString(manifest_url) : 0;
  auto videos__ = videos ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::VideoTrack>>(*videos) : 0;
  auto subtitles__ = subtitles ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::SubtitleTrack>>(*subtitles) : 0;
  auto headers__ = headers ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*headers) : 0;
  auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0;
  return bex::wire::CreateStreamSource(
      _fbb,
      id__,
      label__,
      format,
      manifest_url__,
      videos__,
      subtitles__,
      headers__,
      extra__);
}

struct HomeResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HomeResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SECTIONS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *sections() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *>(VT_SECTIONS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *mutable_sections() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *>(VT_SECTIONS);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SECTIONS) &&
           verifier.VerifyVector(sections()) &&
           verifier.VerifyVectorOfTables(sections()) &&
           verifier.EndTable();
  }
};

struct HomeResultBuilder {
  typedef HomeResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_sections(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>>> sections) {
    fbb_.AddOffset(HomeResult::VT_SECTIONS, sections);
  }
  explicit HomeResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HomeResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HomeResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HomeResult> CreateHomeResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>>> sections = 0) {
  HomeResultBuilder builder_(_fbb);
  builder_.add_sections(sections);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<HomeResult> CreateHomeResultDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<bex::wire::HomeSection>> *sections = nullptr) {
  auto sections__ = sections ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::HomeSection>>(*sections) : 0;
  return bex::wire::CreateHomeResult(
      _fbb,
      sections__);
}

struct CategoryResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CategoryResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RESULT = 4
  };
  const bex::wire::PagedResult *result() const {
    return GetPointer<const bex::wire::PagedResult *>(VT_RESULT);
  }
  bex::wire::PagedResult *mutable_result() {
    return GetPointer<bex::wire::PagedResult *>(VT_RESULT);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_RESULT) &&
           verifier.VerifyTable(result()) &&
           verifier.EndTable();
  }
};

struct CategoryResultBuilder {
  typedef CategoryResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_result(::flatbuffers::Offset<bex::wire::PagedResult> result) {
    fbb_.AddOffset(CategoryResult::VT_RESULT, result);
  }
  explicit CategoryResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CategoryResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CategoryResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CategoryResult> CreateCategoryResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::PagedResult> result = 0) {
  CategoryResultBuilder builder_(_fbb);
  builder_.add_result(result);
  return builder_.Finish();
}

struct SearchResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SearchResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RESULT = 4
  };
  const bex::wire::PagedResult *result() const {
    return GetPointer<const bex::wire::PagedResult *>(VT_RESULT);
  }
  bex::wire::PagedResult *mutable_result() {
    return GetPointer<bex::wire::PagedResult *>(VT_RESULT);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_RESULT) &&
           verifier.VerifyTable(result()) &&
           verifier.EndTable();
  }
};

struct SearchResultBuilder {
  typedef SearchResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_result(::flatbuffers::Offset<bex::wire::PagedResult> result) {
    fbb_.AddOffset(SearchResult::VT_RESULT, result);
  }
  explicit SearchResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SearchResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SearchResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SearchResult> CreateSearchResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::PagedResult> result = 0) {
  SearchResultBuilder builder_(_fbb);
  builder_.add_result(result);
  return builder_.Finish();
}

struct InfoResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef InfoResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INFO = 4
  };
  const bex::wire::MediaInfo *info() const {
    return GetPointer<const bex::wire::MediaInfo *>(VT_INFO);
  }
  bex::wire::MediaInfo *mutable_info() {
    return GetPointer<bex::wire::MediaInfo *>(VT_INFO);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INFO) &&
           verifier.VerifyTable(info()) &&
           verifier.EndTable();
  }
};

struct InfoResultBuilder {
  typedef InfoResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_info(::flatbuffers::Offset<bex::wire::MediaInfo> info) {
    fbb_.AddOffset(InfoResult::VT_INFO, info);
  }
  explicit InfoResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<InfoResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<InfoResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<InfoResult> CreateInfoResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::MediaInfo> info = 0) {
  InfoResultBuilder builder_(_fbb);
  builder_.add_info(info);
  return builder_.Finish();
}

struct ServersResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ServersResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SERVERS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *servers() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *>(VT_SERVERS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *mutable_servers() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *>(VT_SERVERS);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SERVERS) &&
           verifier.VerifyVector(servers()) &&
           verifier.VerifyVectorOfTables(servers()) &&
           verifier.EndTable();
  }
};

struct ServersResultBuilder {
  typedef ServersResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_servers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>>> servers) {
    fbb_.AddOffset(ServersResult::VT_SERVERS, servers);
  }
  explicit ServersResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ServersResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ServersResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ServersResult> CreateServersResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>>> servers = 0) {
  ServersResultBuilder builder_(_fbb);
  builder_.add_servers(servers);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<ServersResult> CreateServersResultDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<bex::wire::Server>> *servers = nullptr) {
  auto servers__ = servers ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Server>>(*servers) : 0;
  return bex::wire::CreateServersResult(
      _fbb,
      servers__);
}

struct StreamResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StreamResultBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SOURCE = 4
  };
  const bex::wire::StreamSource *source() const {
    return GetPointer<const bex::wire::StreamSource *>(VT_SOURCE);
  }
  bex::wire::StreamSource *mutable_source() {
    return GetPointer<bex::wire::StreamSource *>(VT_SOURCE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SOURCE) &&
           verifier.VerifyTable(source()) &&
           verifier.EndTable();
  }
};

struct StreamResultBuilder {
  typedef StreamResult Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_source(::flatbuffers::Offset<bex::wire::StreamSource> source) {
    fbb_.AddOffset(StreamResult::VT_SOURCE, source);
  }
  explicit StreamResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StreamResult> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StreamResult>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StreamResult> CreateStreamResult(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<bex::wire::StreamSource> source = 0) {
  StreamResultBuilder builder_(_fbb);
  builder_.add_source(source);
  return builder_.Finish();
}

struct ErrorInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ErrorInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CODE = 4,
    VT_MESSAGE = 6,
    VT_PLUGIN_ID = 8,
    VT_REQUEST_ID = 10
  };
  const ::flatbuffers::String *code() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CODE);
  }
  ::flatbuffers::String *mutable_code() {
    return GetPointer<::flatbuffers::String *>(VT_CODE);
  }
  const ::flatbuffers::String *message() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
  }
  ::flatbuffers::String *mutable_message() {
    return GetPointer<::flatbuffers::String *>(VT_MESSAGE);
  }
  const ::flatbuffers::String *plugin_id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PLUGIN_ID);
  }
  ::flatbuffers::String *mutable_plugin_id() {
    return GetPointer<::flatbuffers::String *>(VT_PLUGIN_ID);
  }
  uint64_t request_id() const {
    return GetField<uint64_t>(VT_REQUEST_ID, 0);
  }
  bool mutate_request_id(uint64_t _request_id = 0) {
    return SetField<uint64_t>(VT_REQUEST_ID, _request_id, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CODE) &&
           verifier.VerifyString(code()) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           verifier.VerifyString(message()) &&
           VerifyOffset(verifier, VT_PLUGIN_ID) &&
           verifier.VerifyString(plugin_id()) &&
           VerifyField<uint64_t>(verifier, VT_REQUEST_ID, 8) &&
           verifier.EndTable();
  }
};

struct ErrorInfoBuilder {
  typedef ErrorInfo Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_code(::flatbuffers::Offset<::flatbuffers::String> code) {
    fbb_.AddOffset(ErrorInfo::VT_CODE, code);
  }
  void add_message(::flatbuffers::Offset<::flatbuffers::String> message) {
    fbb_.AddOffset(ErrorInfo::VT_MESSAGE, message);
  }
  void add_plugin_id(::flatbuffers::Offset<::flatbuffers::String> plugin_id) {
    fbb_.AddOffset(ErrorInfo::VT_PLUGIN_ID, plugin_id);
  }
  void add_request_id(uint64_t request_id) {
    fbb_.AddElement<uint64_t>(ErrorInfo::VT_REQUEST_ID, request_id, 0);
  }
  explicit ErrorInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ErrorInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ErrorInfo>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ErrorInfo> CreateErrorInfo(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> code = 0,
    ::flatbuffers::Offset<::flatbuffers::String> message = 0,
    ::flatbuffers::Offset<::flatbuffers::String> plugin_id = 0,
    uint64_t request_id = 0) {
  ErrorInfoBuilder builder_(_fbb);
  builder_.add_request_id(request_id);
  builder_.add_plugin_id(plugin_id);
  builder_.add_message(message);
  builder_.add_code(code);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<ErrorInfo> CreateErrorInfoDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *code = nullptr,
    const char *message = nullptr,
    const char *plugin_id = nullptr,
    uint64_t request_id = 0) {
  auto code__ = code ? _fbb.CreateString(code) : 0;
  auto message__ = message ? _fbb.CreateString(message) : 0;
  auto plugin_id__ = plugin_id ? _fbb.CreateString(plugin_id) : 0;
  return bex::wire::CreateErrorInfo(
      _fbb,
      code__,
      message__,
      plugin_id__,
      request_id);
}

inline const bex::wire::HomeResult *GetHomeResult(const void *buf) {
  return ::flatbuffers::GetRoot<bex::wire::HomeResult>(buf);
}

inline const bex::wire::HomeResult *GetSizePrefixedHomeResult(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<bex::wire::HomeResult>(buf);
}

inline HomeResult *GetMutableHomeResult(void *buf) {
  return ::flatbuffers::GetMutableRoot<HomeResult>(buf);
}

inline bex::wire::HomeResult *GetMutableSizePrefixedHomeResult(void *buf) {
  return ::flatbuffers::GetMutableSizePrefixedRoot<bex::wire::HomeResult>(buf);
}

template <bool B = false>
inline bool VerifyHomeResultBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifyBuffer<bex::wire::HomeResult>(nullptr);
}

template <bool B = false>
inline bool VerifySizePrefixedHomeResultBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifySizePrefixedBuffer<bex::wire::HomeResult>(nullptr);
}

inline void FinishHomeResultBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<bex::wire::HomeResult> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedHomeResultBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<bex::wire::HomeResult> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace wire
}  // namespace bex

#endif  // FLATBUFFERS_GENERATED_BEXALL_BEX_WIRE_H_