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


#ifndef FLATBUFFERS_GENERATED_BEXEVENT_BEX_WIRE_H_
#define FLATBUFFERS_GENERATED_BEXEVENT_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");

#include "bex_media_generated.h"
#include "bex_stream_generated.h"

namespace bex {
namespace wire {

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;

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);
  }
  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);
  }
  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);
  }
  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);
  }
  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);
  }
  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);
  }
  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);
  }
  const ::flatbuffers::String *message() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
  }
  const ::flatbuffers::String *plugin_id() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PLUGIN_ID);
  }
  uint64_t request_id() const {
    return GetField<uint64_t>(VT_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);
}

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_BEXEVENT_BEX_WIRE_H_