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


#ifndef FLATBUFFERS_GENERATED_ASSETC_FLAT_BIGFOOT_H_
#define FLATBUFFERS_GENERATED_ASSETC_FLAT_BIGFOOT_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");
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
#ifndef FLATBUFFERS_BIGFOOT_VERSION
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
#endif
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
             "Non-compatible Bigfoot flatbuffers fork version included");

#include "System/UUID/UUID.hpp"
#include "Engine/Asset/Reference.hpp"
#include "Engine/Asset/Reference_generated.hpp"

#include "EASTL/unique_ptr.h"
#include "EASTL/string.h"
#include "EASTL/vector.h"

namespace Flat {
namespace Bigfoot {

struct InnerTable;
struct InnerTableBuilder;
struct InnerTableT;

struct AssetC;
struct AssetCBuilder;
struct AssetCT;

}  // namespace Bigfoot
}  // namespace Flat

namespace Bigfoot {
class AssetA;
}  // namespace Bigfoot

namespace Bigfoot {
class AssetBase;
}  // namespace Bigfoot

namespace Bigfoot {
class AssetB;
}  // namespace Bigfoot

namespace flatbuffers {
Flat::Bigfoot::HardReference PackHardReferenceAssetA(const ::Bigfoot::HardReference<::Bigfoot::AssetA>& p_asset);
::Bigfoot::HardReference<::Bigfoot::AssetA> UnPackHardReferenceAssetA(const Flat::Bigfoot::HardReference& p_asset);
Flat::Bigfoot::HardReference PackHardReferenceAssetBase(const ::Bigfoot::HardReference<::Bigfoot::AssetBase>& p_asset);
::Bigfoot::HardReference<::Bigfoot::AssetBase> UnPackHardReferenceAssetBase(const Flat::Bigfoot::HardReference& p_asset);
Flat::Bigfoot::SoftReference PackSoftReferenceAssetBase(const ::Bigfoot::SoftReference<::Bigfoot::AssetBase>& p_asset);
::Bigfoot::SoftReference<::Bigfoot::AssetBase> UnPackSoftReferenceAssetBase(const Flat::Bigfoot::SoftReference& p_asset);
Flat::Bigfoot::HardReference PackHardReferenceAssetB(const ::Bigfoot::HardReference<::Bigfoot::AssetB>& p_asset);
::Bigfoot::HardReference<::Bigfoot::AssetB> UnPackHardReferenceAssetB(const Flat::Bigfoot::HardReference& p_asset);
Flat::Bigfoot::SoftReference PackSoftReferenceAssetB(const ::Bigfoot::SoftReference<::Bigfoot::AssetB>& p_asset);
::Bigfoot::SoftReference<::Bigfoot::AssetB> UnPackSoftReferenceAssetB(const Flat::Bigfoot::SoftReference& p_asset);
}  // namespace flatbuffers

namespace Flat {
namespace Bigfoot {

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

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

struct InnerTableT : public ::flatbuffers::NativeTable {
  typedef InnerTable TableType;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "Flat.Bigfoot.InnerTableT";
  }
  ::Bigfoot::HardReference<::Bigfoot::AssetA> asset_a_ref{};
  eastl::vector<::Bigfoot::HardReference<::Bigfoot::AssetA>> asset_a_refs{};
  ::Bigfoot::HardReference<::Bigfoot::AssetBase> any_asset{};
  eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetBase>> any_assets{};
};

struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef InnerTableT NativeTableType;
  typedef InnerTableBuilder Builder;
  struct Traits;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return InnerTableTypeTable();
  }
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "Flat.Bigfoot.InnerTable";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ASSET_A_REF = 4,
    VT_ASSET_A_REFS = 6,
    VT_ANY_ASSET = 8,
    VT_ANY_ASSETS = 10
  };
  const Flat::Bigfoot::HardReference *asset_a_ref() const {
    return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_A_REF);
  }
  const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *asset_a_refs() const {
    return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *>(VT_ASSET_A_REFS);
  }
  const Flat::Bigfoot::HardReference *any_asset() const {
    return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ANY_ASSET);
  }
  const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *any_assets() const {
    return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *>(VT_ANY_ASSETS);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_A_REF, 1) &&
           VerifyOffset(verifier, VT_ASSET_A_REFS) &&
           verifier.VerifyVector(asset_a_refs()) &&
           VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ANY_ASSET, 1) &&
           VerifyOffset(verifier, VT_ANY_ASSETS) &&
           verifier.VerifyVector(any_assets()) &&
           verifier.EndTable();
  }
  InnerTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(InnerTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<InnerTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct InnerTableBuilder {
  typedef InnerTable Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_asset_a_ref(const Flat::Bigfoot::HardReference *asset_a_ref) {
    fbb_.AddStruct(InnerTable::VT_ASSET_A_REF, asset_a_ref);
  }
  void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> asset_a_refs) {
    fbb_.AddOffset(InnerTable::VT_ASSET_A_REFS, asset_a_refs);
  }
  void add_any_asset(const Flat::Bigfoot::HardReference *any_asset) {
    fbb_.AddStruct(InnerTable::VT_ANY_ASSET, any_asset);
  }
  void add_any_assets(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> any_assets) {
    fbb_.AddOffset(InnerTable::VT_ANY_ASSETS, any_assets);
  }
  explicit InnerTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<InnerTable> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<InnerTable>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<InnerTable> CreateInnerTable(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const Flat::Bigfoot::HardReference *asset_a_ref = nullptr,
    ::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> asset_a_refs = 0,
    const Flat::Bigfoot::HardReference *any_asset = nullptr,
    ::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> any_assets = 0) {
  InnerTableBuilder builder_(_fbb);
  builder_.add_any_assets(any_assets);
  builder_.add_any_asset(any_asset);
  builder_.add_asset_a_refs(asset_a_refs);
  builder_.add_asset_a_ref(asset_a_ref);
  return builder_.Finish();
}

struct InnerTable::Traits {
  using type = InnerTable;
  static auto constexpr Create = CreateInnerTable;
};

::flatbuffers::Offset<InnerTable> CreateInnerTable(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct AssetCT : public ::flatbuffers::NativeTable {
  typedef AssetC TableType;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "Flat.Bigfoot.AssetCT";
  }
  eastl::unique_ptr<Flat::Bigfoot::InnerTableT> inner_table{};
  ::Bigfoot::HardReference<::Bigfoot::AssetB> asset_b_ref{};
  eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetB>> asset_b_refs{};
  AssetCT() = default;
  AssetCT(const AssetCT &o);
  AssetCT(AssetCT&&) FLATBUFFERS_NOEXCEPT = default;
  AssetCT &operator=(AssetCT o) FLATBUFFERS_NOEXCEPT;
};

struct AssetC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AssetCT NativeTableType;
  typedef AssetCBuilder Builder;
  struct Traits;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AssetCTypeTable();
  }
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "Flat.Bigfoot.AssetC";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INNER_TABLE = 4,
    VT_ASSET_B_REF = 6,
    VT_ASSET_B_REFS = 8
  };
  const Flat::Bigfoot::InnerTable *inner_table() const {
    return GetPointer<const Flat::Bigfoot::InnerTable *>(VT_INNER_TABLE);
  }
  const Flat::Bigfoot::HardReference *asset_b_ref() const {
    return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_B_REF);
  }
  const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *asset_b_refs() const {
    return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *>(VT_ASSET_B_REFS);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_INNER_TABLE) &&
           verifier.VerifyTable(inner_table()) &&
           VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_B_REF, 1) &&
           VerifyOffset(verifier, VT_ASSET_B_REFS) &&
           verifier.VerifyVector(asset_b_refs()) &&
           verifier.EndTable();
  }
  AssetCT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(AssetCT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<AssetC> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct AssetCBuilder {
  typedef AssetC Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_inner_table(::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table) {
    fbb_.AddOffset(AssetC::VT_INNER_TABLE, inner_table);
  }
  void add_asset_b_ref(const Flat::Bigfoot::HardReference *asset_b_ref) {
    fbb_.AddStruct(AssetC::VT_ASSET_B_REF, asset_b_ref);
  }
  void add_asset_b_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_b_refs) {
    fbb_.AddOffset(AssetC::VT_ASSET_B_REFS, asset_b_refs);
  }
  explicit AssetCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AssetC> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AssetC>(end);
    fbb_.Required(o, AssetC::VT_INNER_TABLE);
    return o;
  }
};

inline ::flatbuffers::Offset<AssetC> CreateAssetC(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table = 0,
    const Flat::Bigfoot::HardReference *asset_b_ref = nullptr,
    ::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_b_refs = 0) {
  AssetCBuilder builder_(_fbb);
  builder_.add_asset_b_refs(asset_b_refs);
  builder_.add_asset_b_ref(asset_b_ref);
  builder_.add_inner_table(inner_table);
  return builder_.Finish();
}

struct AssetC::Traits {
  using type = AssetC;
  static auto constexpr Create = CreateAssetC;
};

::flatbuffers::Offset<AssetC> CreateAssetC(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

inline InnerTableT *InnerTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::make_unique<InnerTableT>();
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void InnerTable::UnPackTo(InnerTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardReferenceAssetA(*_e); }
  { auto _e = asset_a_refs(); if (_e) { _o->asset_a_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_a_refs[_i] = ::flatbuffers::UnPackHardReferenceAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } }
  { auto _e = any_asset(); if (_e) _o->any_asset = ::flatbuffers::UnPackHardReferenceAssetBase(*_e); }
  { auto _e = any_assets(); if (_e) { _o->any_assets.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->any_assets[_i] = ::flatbuffers::UnPackSoftReferenceAssetBase(*_e->Get(_i)); } } else { _o->any_assets.resize(0); } }
}

inline ::flatbuffers::Offset<InnerTable> CreateInnerTable(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return InnerTable::Pack(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<InnerTable> InnerTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InnerTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _asset_a_ref = ::flatbuffers::PackHardReferenceAssetA(_o->asset_a_ref);
  auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::HardReference, ::Bigfoot::HardReference<::Bigfoot::AssetA>>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackHardReferenceAssetA);
  auto _any_asset = ::flatbuffers::PackHardReferenceAssetBase(_o->any_asset);
  auto _any_assets = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftReference, ::Bigfoot::SoftReference<::Bigfoot::AssetBase>>(_o->any_assets.data(), _o->any_assets.size(), ::flatbuffers::PackSoftReferenceAssetBase);
  return Flat::Bigfoot::CreateInnerTable(
      _fbb,
      &_asset_a_ref,
      _asset_a_refs,
      &_any_asset,
      _any_assets);
}

inline AssetCT::AssetCT(const AssetCT &o)
      : inner_table((o.inner_table) ? new Flat::Bigfoot::InnerTableT(*o.inner_table) : nullptr),
        asset_b_ref(o.asset_b_ref),
        asset_b_refs(o.asset_b_refs) {
}

inline AssetCT &AssetCT::operator=(AssetCT o) FLATBUFFERS_NOEXCEPT {
  std::swap(inner_table, o.inner_table);
  std::swap(asset_b_ref, o.asset_b_ref);
  std::swap(asset_b_refs, o.asset_b_refs);
  return *this;
}

inline AssetCT *AssetC::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::make_unique<AssetCT>();
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void AssetC::UnPackTo(AssetCT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = inner_table(); if (_e) { if(_o->inner_table) { _e->UnPackTo(_o->inner_table.get(), _resolver); } else { _o->inner_table = eastl::unique_ptr<Flat::Bigfoot::InnerTableT>(_e->UnPack(_resolver)); } } else if (_o->inner_table) { _o->inner_table.reset(); } }
  { auto _e = asset_b_ref(); if (_e) _o->asset_b_ref = ::flatbuffers::UnPackHardReferenceAssetB(*_e); }
  { auto _e = asset_b_refs(); if (_e) { _o->asset_b_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_b_refs[_i] = ::flatbuffers::UnPackSoftReferenceAssetB(*_e->Get(_i)); } } else { _o->asset_b_refs.resize(0); } }
}

inline ::flatbuffers::Offset<AssetC> CreateAssetC(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return AssetC::Pack(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<AssetC> AssetC::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetCT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _inner_table = _o->inner_table ? CreateInnerTable(_fbb, _o->inner_table.get(), _rehasher) : 0;
  auto _asset_b_ref = ::flatbuffers::PackHardReferenceAssetB(_o->asset_b_ref);
  auto _asset_b_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftReference, ::Bigfoot::SoftReference<::Bigfoot::AssetB>>(_o->asset_b_refs.data(), _o->asset_b_refs.size(), ::flatbuffers::PackSoftReferenceAssetB);
  return Flat::Bigfoot::CreateAssetC(
      _fbb,
      _inner_table,
      &_asset_b_ref,
      _asset_b_refs);
}

inline const ::flatbuffers::TypeTable *InnerTableTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 1, 1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    Flat::Bigfoot::HardReferenceTypeTable,
    Flat::Bigfoot::SoftReferenceTypeTable
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *AssetCTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 2 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    Flat::Bigfoot::InnerTableTypeTable,
    Flat::Bigfoot::HardReferenceTypeTable,
    Flat::Bigfoot::SoftReferenceTypeTable
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const Flat::Bigfoot::AssetC *GetAssetC(const void *buf) {
  return ::flatbuffers::GetRoot<Flat::Bigfoot::AssetC>(buf);
}

inline const Flat::Bigfoot::AssetC *GetSizePrefixedAssetC(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<Flat::Bigfoot::AssetC>(buf);
}

template <bool B = false>
inline bool VerifyAssetCBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifyBuffer<Flat::Bigfoot::AssetC>(nullptr);
}

template <bool B = false>
inline bool VerifySizePrefixedAssetCBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifySizePrefixedBuffer<Flat::Bigfoot::AssetC>(nullptr);
}

inline const char *AssetCExtension() {
  return "bfbs";
}

inline void FinishAssetCBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Flat::Bigfoot::AssetC> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedAssetCBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Flat::Bigfoot::AssetC> root) {
  fbb.FinishSizePrefixed(root);
}

inline eastl::unique_ptr<Flat::Bigfoot::AssetCT> UnPackAssetC(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) {
  return eastl::unique_ptr<Flat::Bigfoot::AssetCT>(GetAssetC(buf)->UnPack(res));
}

inline eastl::unique_ptr<Flat::Bigfoot::AssetCT> UnPackSizePrefixedAssetC(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) {
  return eastl::unique_ptr<Flat::Bigfoot::AssetCT>(GetSizePrefixedAssetC(buf)->UnPack(res));
}

}  // namespace Bigfoot
}  // namespace Flat

namespace flatbuffers {
#ifndef FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETA
#define FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETA
inline Flat::Bigfoot::HardReference PackHardReferenceAssetA(const ::Bigfoot::HardReference<::Bigfoot::AssetA>& p_asset) { return {Pack(p_asset.GetUUID())}; }
inline ::Bigfoot::HardReference<::Bigfoot::AssetA> UnPackHardReferenceAssetA(const Flat::Bigfoot::HardReference& p_asset) { return {UnPack(p_asset.uuid())}; }
#endif  // FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETA
#ifndef FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETBASE
#define FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETBASE
inline Flat::Bigfoot::HardReference PackHardReferenceAssetBase(const ::Bigfoot::HardReference<::Bigfoot::AssetBase>& p_asset) { return {Pack(p_asset.GetUUID())}; }
inline ::Bigfoot::HardReference<::Bigfoot::AssetBase> UnPackHardReferenceAssetBase(const Flat::Bigfoot::HardReference& p_asset) { return {UnPack(p_asset.uuid())}; }
#endif  // FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETBASE
#ifndef FLATBUFFERS_BIGFOOT_REF_SOFTREFERENCEASSETBASE
#define FLATBUFFERS_BIGFOOT_REF_SOFTREFERENCEASSETBASE
inline Flat::Bigfoot::SoftReference PackSoftReferenceAssetBase(const ::Bigfoot::SoftReference<::Bigfoot::AssetBase>& p_asset) { return {Pack(p_asset.GetUUID())}; }
inline ::Bigfoot::SoftReference<::Bigfoot::AssetBase> UnPackSoftReferenceAssetBase(const Flat::Bigfoot::SoftReference& p_asset) { return {UnPack(p_asset.uuid())}; }
#endif  // FLATBUFFERS_BIGFOOT_REF_SOFTREFERENCEASSETBASE
#ifndef FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETB
#define FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETB
inline Flat::Bigfoot::HardReference PackHardReferenceAssetB(const ::Bigfoot::HardReference<::Bigfoot::AssetB>& p_asset) { return {Pack(p_asset.GetUUID())}; }
inline ::Bigfoot::HardReference<::Bigfoot::AssetB> UnPackHardReferenceAssetB(const Flat::Bigfoot::HardReference& p_asset) { return {UnPack(p_asset.uuid())}; }
#endif  // FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEASSETB
#ifndef FLATBUFFERS_BIGFOOT_REF_SOFTREFERENCEASSETB
#define FLATBUFFERS_BIGFOOT_REF_SOFTREFERENCEASSETB
inline Flat::Bigfoot::SoftReference PackSoftReferenceAssetB(const ::Bigfoot::SoftReference<::Bigfoot::AssetB>& p_asset) { return {Pack(p_asset.GetUUID())}; }
inline ::Bigfoot::SoftReference<::Bigfoot::AssetB> UnPackSoftReferenceAssetB(const Flat::Bigfoot::SoftReference& p_asset) { return {UnPack(p_asset.uuid())}; }
#endif  // FLATBUFFERS_BIGFOOT_REF_SOFTREFERENCEASSETB
}  // namespace flatbuffers

#endif  // FLATBUFFERS_GENERATED_ASSETC_FLAT_BIGFOOT_H_
