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


#ifndef FLATBUFFERS_GENERATED_BEXCOMMON_BEX_WIRE_H_
#define FLATBUFFERS_GENERATED_BEXCOMMON_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;

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);
  }
  const ::flatbuffers::String *layout() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LAYOUT);
  }
  uint32_t width() const {
    return GetField<uint32_t>(VT_WIDTH, 0);
  }
  uint32_t height() const {
    return GetField<uint32_t>(VT_HEIGHT, 0);
  }
  const ::flatbuffers::String *blurhash() const {
    return GetPointer<const ::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);
  }
  const bex::wire::Image *medium() const {
    return GetPointer<const bex::wire::Image *>(VT_MEDIUM);
  }
  const bex::wire::Image *high() const {
    return GetPointer<const bex::wire::Image *>(VT_HIGH);
  }
  const bex::wire::Image *backdrop() const {
    return GetPointer<const bex::wire::Image *>(VT_BACKDROP);
  }
  const bex::wire::Image *logo() const {
    return GetPointer<const 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);
  }
  const ::flatbuffers::String *id() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::String *value() const {
    return GetPointer<const ::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__);
}

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

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

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

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

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

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

}  // namespace wire
}  // namespace bex

#endif  // FLATBUFFERS_GENERATED_BEXCOMMON_BEX_WIRE_H_