axmol/extensions/cocostudio/CSParseBinary_generated.h

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

#ifndef FLATBUFFERS_GENERATED_CSPARSEBINARY_FLATBUFFERS_H_
#define FLATBUFFERS_GENERATED_CSPARSEBINARY_FLATBUFFERS_H_

#include "flatbuffers/flatbuffers.h"

namespace flatbuffers
{

struct CSParseBinary;

struct NodeTree;

struct Options;

struct WidgetOptions;

struct LayoutComponentTable;

struct SingleNodeOptions;

struct SpriteOptions;

struct ParticleSystemOptions;

struct SpineSkeletonOptions;

struct ControlSwitchOptions;

struct LayerColorOptions;

struct GameMapOptions;

struct ButtonOptions;

struct CheckBoxOptions;

struct RadioButtonOptions;

struct RadioButtonGroupOptions;

struct ImageViewOptions;

struct TextAtlasOptions;

struct TextBMFontOptions;

struct TextOptions;

struct RichTextOptions;

struct TextFieldOptions;

struct LoadingBarOptions;

struct SliderOptions;

struct PanelOptions;

struct ScrollViewOptions;

struct PageViewOptions;

struct ListViewOptions;

struct TextFieldExOptions;

struct ProjectNodeOptions;

struct ComponentOptions;

struct ComAudioOptions;

struct AnimationInfo;

struct NodeAction;

struct TimeLine;

struct Frame;

struct PointFrame;

struct ScaleFrame;

struct ColorFrame;

struct TextureFrame;

struct EventFrame;

struct IntFrame;

struct BoolFrame;

struct InnerActionFrame;

struct EasingData;

struct RotationSkew;

struct FVec2;

struct FVec3;

struct Scale;

struct AnchorPoint;

struct Color;

struct ColorVector;

struct FlatSize;

struct CapInsets;

struct BlendFunc;

struct ResourceData;

struct BlendFrame;

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) RotationSkew FLATBUFFERS_FINAL_CLASS
{
private:
    float rotationSkewX_;
    float rotationSkewY_;

public:
    RotationSkew() { memset(static_cast<void*>(this), 0, sizeof(RotationSkew)); }
    RotationSkew(float _rotationSkewX, float _rotationSkewY)
        : rotationSkewX_(flatbuffers::EndianScalar(_rotationSkewX))
        , rotationSkewY_(flatbuffers::EndianScalar(_rotationSkewY))
    {}
    float rotationSkewX() const { return flatbuffers::EndianScalar(rotationSkewX_); }
    float rotationSkewY() const { return flatbuffers::EndianScalar(rotationSkewY_); }
};
FLATBUFFERS_STRUCT_END(RotationSkew, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FVec2 FLATBUFFERS_FINAL_CLASS
{
private:
    float x_;
    float y_;

public:
    FVec2() { memset(static_cast<void*>(this), 0, sizeof(FVec2)); }
    FVec2(float _x, float _y) : x_(flatbuffers::EndianScalar(_x)), y_(flatbuffers::EndianScalar(_y)) {}
    float x() const { return flatbuffers::EndianScalar(x_); }
    float y() const { return flatbuffers::EndianScalar(y_); }
};
FLATBUFFERS_STRUCT_END(FVec2, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FVec3 FLATBUFFERS_FINAL_CLASS
{
private:
    float x_;
    float y_;
    float z_;

public:
    FVec3() { memset(static_cast<void*>(this), 0, sizeof(FVec3)); }
    FVec3(float _x, float _y, float _z)
        : x_(flatbuffers::EndianScalar(_x)), y_(flatbuffers::EndianScalar(_y)), z_(flatbuffers::EndianScalar(_z))
    {}
    float x() const { return flatbuffers::EndianScalar(x_); }
    float y() const { return flatbuffers::EndianScalar(y_); }
    float z() const { return flatbuffers::EndianScalar(z_); }
};
FLATBUFFERS_STRUCT_END(FVec3, 12);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Scale FLATBUFFERS_FINAL_CLASS
{
private:
    float scaleX_;
    float scaleY_;

public:
    Scale() { memset(static_cast<void*>(this), 0, sizeof(Scale)); }
    Scale(float _scaleX, float _scaleY)
        : scaleX_(flatbuffers::EndianScalar(_scaleX)), scaleY_(flatbuffers::EndianScalar(_scaleY))
    {}
    float scaleX() const { return flatbuffers::EndianScalar(scaleX_); }
    float scaleY() const { return flatbuffers::EndianScalar(scaleY_); }
};
FLATBUFFERS_STRUCT_END(Scale, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) AnchorPoint FLATBUFFERS_FINAL_CLASS
{
private:
    float scaleX_;
    float scaleY_;

public:
    AnchorPoint() { memset(static_cast<void*>(this), 0, sizeof(AnchorPoint)); }
    AnchorPoint(float _scaleX, float _scaleY)
        : scaleX_(flatbuffers::EndianScalar(_scaleX)), scaleY_(flatbuffers::EndianScalar(_scaleY))
    {}
    float scaleX() const { return flatbuffers::EndianScalar(scaleX_); }
    float scaleY() const { return flatbuffers::EndianScalar(scaleY_); }
};
FLATBUFFERS_STRUCT_END(AnchorPoint, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Color FLATBUFFERS_FINAL_CLASS
{
private:
    uint8_t a_;
    uint8_t r_;
    uint8_t g_;
    uint8_t b_;

public:
    Color() { memset(static_cast<void*>(this), 0, sizeof(Color)); }
    Color(uint8_t _a, uint8_t _r, uint8_t _g, uint8_t _b)
        : a_(flatbuffers::EndianScalar(_a))
        , r_(flatbuffers::EndianScalar(_r))
        , g_(flatbuffers::EndianScalar(_g))
        , b_(flatbuffers::EndianScalar(_b))
    {}
    uint8_t a() const { return flatbuffers::EndianScalar(a_); }
    uint8_t r() const { return flatbuffers::EndianScalar(r_); }
    uint8_t g() const { return flatbuffers::EndianScalar(g_); }
    uint8_t b() const { return flatbuffers::EndianScalar(b_); }
};
FLATBUFFERS_STRUCT_END(Color, 4);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) ColorVector FLATBUFFERS_FINAL_CLASS
{
private:
    float vectorX_;
    float vectorY_;

public:
    ColorVector() { memset(static_cast<void*>(this), 0, sizeof(ColorVector)); }
    ColorVector(float _vectorX, float _vectorY)
        : vectorX_(flatbuffers::EndianScalar(_vectorX)), vectorY_(flatbuffers::EndianScalar(_vectorY))
    {}
    float vectorX() const { return flatbuffers::EndianScalar(vectorX_); }
    float vectorY() const { return flatbuffers::EndianScalar(vectorY_); }
};
FLATBUFFERS_STRUCT_END(ColorVector, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FlatSize FLATBUFFERS_FINAL_CLASS
{
private:
    float width_;
    float height_;

public:
    FlatSize() { memset(static_cast<void*>(this), 0, sizeof(FlatSize)); }
    FlatSize(float _width, float _height)
        : width_(flatbuffers::EndianScalar(_width)), height_(flatbuffers::EndianScalar(_height))
    {}
    float width() const { return flatbuffers::EndianScalar(width_); }
    float height() const { return flatbuffers::EndianScalar(height_); }
};
FLATBUFFERS_STRUCT_END(FlatSize, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) CapInsets FLATBUFFERS_FINAL_CLASS
{
private:
    float x_;
    float y_;
    float width_;
    float height_;

public:
    CapInsets() { memset(static_cast<void*>(this), 0, sizeof(CapInsets)); }
    CapInsets(float _x, float _y, float _width, float _height)
        : x_(flatbuffers::EndianScalar(_x))
        , y_(flatbuffers::EndianScalar(_y))
        , width_(flatbuffers::EndianScalar(_width))
        , height_(flatbuffers::EndianScalar(_height))
    {}
    float x() const { return flatbuffers::EndianScalar(x_); }
    float y() const { return flatbuffers::EndianScalar(y_); }
    float width() const { return flatbuffers::EndianScalar(width_); }
    float height() const { return flatbuffers::EndianScalar(height_); }
};
FLATBUFFERS_STRUCT_END(CapInsets, 16);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BlendFunc FLATBUFFERS_FINAL_CLASS
{
private:
    int32_t src_;
    int32_t dst_;

public:
    BlendFunc() { memset(static_cast<void*>(this), 0, sizeof(BlendFunc)); }
    BlendFunc(int32_t _src, int32_t _dst) : src_(flatbuffers::EndianScalar(_src)), dst_(flatbuffers::EndianScalar(_dst))
    {}
    int32_t src() const { return flatbuffers::EndianScalar(src_); }
    int32_t dst() const { return flatbuffers::EndianScalar(dst_); }
};
FLATBUFFERS_STRUCT_END(BlendFunc, 8);

struct CSParseBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_VERSION       = 4,
        VT_TEXTURES      = 6,
        VT_TEXTUREPNGS   = 8,
        VT_NODETREE      = 10,
        VT_ACTION        = 12,
        VT_ANIMATIONLIST = 14
    };
    const flatbuffers::String* version() const { return GetPointer<const flatbuffers::String*>(VT_VERSION); }
    const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>* textures() const
    {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(VT_TEXTURES);
    }
    const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>* texturePngs() const
    {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*>(VT_TEXTUREPNGS);
    }
    const NodeTree* nodeTree() const { return GetPointer<const NodeTree*>(VT_NODETREE); }
    const NodeAction* action() const { return GetPointer<const NodeAction*>(VT_ACTION); }
    const flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>>* animationList() const
    {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>>*>(VT_ANIMATIONLIST);
    }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VERSION) && verifier.VerifyString(version()) &&
               VerifyOffset(verifier, VT_TEXTURES) && verifier.VerifyVector(textures()) &&
               verifier.VerifyVectorOfStrings(textures()) && VerifyOffset(verifier, VT_TEXTUREPNGS) &&
               verifier.VerifyVector(texturePngs()) && verifier.VerifyVectorOfStrings(texturePngs()) &&
               VerifyOffset(verifier, VT_NODETREE) && verifier.VerifyTable(nodeTree()) &&
               VerifyOffset(verifier, VT_ACTION) && verifier.VerifyTable(action()) &&
               VerifyOffset(verifier, VT_ANIMATIONLIST) && verifier.VerifyVector(animationList()) &&
               verifier.VerifyVectorOfTables(animationList()) && verifier.EndTable();
    }
};

struct CSParseBinaryBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_version(flatbuffers::Offset<flatbuffers::String> version)
    {
        fbb_.AddOffset(CSParseBinary::VT_VERSION, version);
    }
    void add_textures(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> textures)
    {
        fbb_.AddOffset(CSParseBinary::VT_TEXTURES, textures);
    }
    void add_texturePngs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> texturePngs)
    {
        fbb_.AddOffset(CSParseBinary::VT_TEXTUREPNGS, texturePngs);
    }
    void add_nodeTree(flatbuffers::Offset<NodeTree> nodeTree) { fbb_.AddOffset(CSParseBinary::VT_NODETREE, nodeTree); }
    void add_action(flatbuffers::Offset<NodeAction> action) { fbb_.AddOffset(CSParseBinary::VT_ACTION, action); }
    void add_animationList(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>>> animationList)
    {
        fbb_.AddOffset(CSParseBinary::VT_ANIMATIONLIST, animationList);
    }
    explicit CSParseBinaryBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    CSParseBinaryBuilder& operator=(const CSParseBinaryBuilder&);
    flatbuffers::Offset<CSParseBinary> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<CSParseBinary>(end);
        return o;
    }
};

inline flatbuffers::Offset<CSParseBinary> CreateCSParseBinary(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::String> version                                               = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> textures    = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> texturePngs = 0,
    flatbuffers::Offset<NodeTree> nodeTree                                                         = 0,
    flatbuffers::Offset<NodeAction> action                                                         = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<AnimationInfo>>> animationList     = 0)
{
    CSParseBinaryBuilder builder_(_fbb);
    builder_.add_animationList(animationList);
    builder_.add_action(action);
    builder_.add_nodeTree(nodeTree);
    builder_.add_texturePngs(texturePngs);
    builder_.add_textures(textures);
    builder_.add_version(version);
    return builder_.Finish();
}

inline flatbuffers::Offset<CSParseBinary> CreateCSParseBinaryDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    const char* version                                                      = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>>* textures    = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>>* texturePngs = nullptr,
    flatbuffers::Offset<NodeTree> nodeTree                                   = 0,
    flatbuffers::Offset<NodeAction> action                                   = 0,
    const std::vector<flatbuffers::Offset<AnimationInfo>>* animationList     = nullptr)
{
    auto version__       = version ? _fbb.CreateString(version) : 0;
    auto textures__      = textures ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*textures) : 0;
    auto texturePngs__   = texturePngs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*texturePngs) : 0;
    auto animationList__ = animationList ? _fbb.CreateVector<flatbuffers::Offset<AnimationInfo>>(*animationList) : 0;
    return flatbuffers::CreateCSParseBinary(_fbb, version__, textures__, texturePngs__, nodeTree, action,
                                            animationList__);
}

struct NodeTree FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_CLASSNAME       = 4,
        VT_CHILDREN        = 6,
        VT_OPTIONS         = 8,
        VT_CUSTOMCLASSNAME = 10
    };
    const flatbuffers::String* classname() const { return GetPointer<const flatbuffers::String*>(VT_CLASSNAME); }
    const flatbuffers::Vector<flatbuffers::Offset<NodeTree>>* children() const
    {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NodeTree>>*>(VT_CHILDREN);
    }
    const Options* options() const { return GetPointer<const Options*>(VT_OPTIONS); }
    const flatbuffers::String* customClassName() const
    {
        return GetPointer<const flatbuffers::String*>(VT_CUSTOMCLASSNAME);
    }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CLASSNAME) &&
               verifier.VerifyString(classname()) && VerifyOffset(verifier, VT_CHILDREN) &&
               verifier.VerifyVector(children()) && verifier.VerifyVectorOfTables(children()) &&
               VerifyOffset(verifier, VT_OPTIONS) && verifier.VerifyTable(options()) &&
               VerifyOffset(verifier, VT_CUSTOMCLASSNAME) && verifier.VerifyString(customClassName()) &&
               verifier.EndTable();
    }
};

struct NodeTreeBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_classname(flatbuffers::Offset<flatbuffers::String> classname)
    {
        fbb_.AddOffset(NodeTree::VT_CLASSNAME, classname);
    }
    void add_children(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeTree>>> children)
    {
        fbb_.AddOffset(NodeTree::VT_CHILDREN, children);
    }
    void add_options(flatbuffers::Offset<Options> options) { fbb_.AddOffset(NodeTree::VT_OPTIONS, options); }
    void add_customClassName(flatbuffers::Offset<flatbuffers::String> customClassName)
    {
        fbb_.AddOffset(NodeTree::VT_CUSTOMCLASSNAME, customClassName);
    }
    explicit NodeTreeBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    NodeTreeBuilder& operator=(const NodeTreeBuilder&);
    flatbuffers::Offset<NodeTree> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<NodeTree>(end);
        return o;
    }
};

inline flatbuffers::Offset<NodeTree> CreateNodeTree(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::String> classname                               = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NodeTree>>> children = 0,
    flatbuffers::Offset<Options> options                                             = 0,
    flatbuffers::Offset<flatbuffers::String> customClassName                         = 0)
{
    NodeTreeBuilder builder_(_fbb);
    builder_.add_customClassName(customClassName);
    builder_.add_options(options);
    builder_.add_children(children);
    builder_.add_classname(classname);
    return builder_.Finish();
}

inline flatbuffers::Offset<NodeTree> CreateNodeTreeDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    const char* classname                                      = nullptr,
    const std::vector<flatbuffers::Offset<NodeTree>>* children = nullptr,
    flatbuffers::Offset<Options> options                       = 0,
    const char* customClassName                                = nullptr)
{
    auto classname__       = classname ? _fbb.CreateString(classname) : 0;
    auto children__        = children ? _fbb.CreateVector<flatbuffers::Offset<NodeTree>>(*children) : 0;
    auto customClassName__ = customClassName ? _fbb.CreateString(customClassName) : 0;
    return flatbuffers::CreateNodeTree(_fbb, classname__, children__, options, customClassName__);
}

struct Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_DATA = 4
    };
    const WidgetOptions* data() const { return GetPointer<const WidgetOptions*>(VT_DATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) && verifier.VerifyTable(data()) &&
               verifier.EndTable();
    }
};

struct OptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_data(flatbuffers::Offset<WidgetOptions> data) { fbb_.AddOffset(Options::VT_DATA, data); }
    explicit OptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    OptionsBuilder& operator=(const OptionsBuilder&);
    flatbuffers::Offset<Options> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<Options>(end);
        return o;
    }
};

inline flatbuffers::Offset<Options> CreateOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                  flatbuffers::Offset<WidgetOptions> data = 0)
{
    OptionsBuilder builder_(_fbb);
    builder_.add_data(data);
    return builder_.Finish();
}

struct WidgetOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NAME                  = 4,
        VT_ACTIONTAG             = 6,
        VT_ROTATIONSKEW          = 8,
        VT_ZORDER                = 10,
        VT_VISIBLE               = 12,
        VT_ALPHA                 = 14,
        VT_TAG                   = 16,
        VT_POSITION              = 18,
        VT_SCALE                 = 20,
        VT_ANCHORPOINT           = 22,
        VT_COLOR                 = 24,
        VT_SIZE                  = 26,
        VT_FLIPX                 = 28,
        VT_FLIPY                 = 30,
        VT_IGNORESIZE            = 32,
        VT_TOUCHENABLED          = 34,
        VT_FRAMEEVENT            = 36,
        VT_CUSTOMPROPERTY        = 38,
        VT_CALLBACKTYPE          = 40,
        VT_CALLBACKNAME          = 42,
        VT_LAYOUTCOMPONENT       = 44,
        VT_CASCADECOLORENABLED   = 46,
        VT_CASCADEOPACITYENABLED = 48
    };
    const flatbuffers::String* name() const { return GetPointer<const flatbuffers::String*>(VT_NAME); }
    int32_t actionTag() const { return GetField<int32_t>(VT_ACTIONTAG, 0); }
    const RotationSkew* rotationSkew() const { return GetStruct<const RotationSkew*>(VT_ROTATIONSKEW); }
    int32_t zOrder() const { return GetField<int32_t>(VT_ZORDER, 0); }
    bool visible() const { return GetField<uint8_t>(VT_VISIBLE, 1) != 0; }
    uint8_t alpha() const { return GetField<uint8_t>(VT_ALPHA, 255); }
    int32_t tag() const { return GetField<int32_t>(VT_TAG, 0); }
    const FVec2* position() const { return GetStruct<const FVec2*>(VT_POSITION); }
    const Scale* scale() const { return GetStruct<const Scale*>(VT_SCALE); }
    const AnchorPoint* anchorPoint() const { return GetStruct<const AnchorPoint*>(VT_ANCHORPOINT); }
    const Color* color() const { return GetStruct<const Color*>(VT_COLOR); }
    const FlatSize* size() const { return GetStruct<const FlatSize*>(VT_SIZE); }
    bool flipX() const { return GetField<uint8_t>(VT_FLIPX, 0) != 0; }
    bool flipY() const { return GetField<uint8_t>(VT_FLIPY, 0) != 0; }
    bool ignoreSize() const { return GetField<uint8_t>(VT_IGNORESIZE, 0) != 0; }
    bool touchEnabled() const { return GetField<uint8_t>(VT_TOUCHENABLED, 0) != 0; }
    const flatbuffers::String* frameEvent() const { return GetPointer<const flatbuffers::String*>(VT_FRAMEEVENT); }
    const flatbuffers::String* customProperty() const
    {
        return GetPointer<const flatbuffers::String*>(VT_CUSTOMPROPERTY);
    }
    const flatbuffers::String* callBackType() const { return GetPointer<const flatbuffers::String*>(VT_CALLBACKTYPE); }
    const flatbuffers::String* callBackName() const { return GetPointer<const flatbuffers::String*>(VT_CALLBACKNAME); }
    const LayoutComponentTable* layoutComponent() const
    {
        return GetPointer<const LayoutComponentTable*>(VT_LAYOUTCOMPONENT);
    }
    bool cascadeColorEnabled() const { return GetField<uint8_t>(VT_CASCADECOLORENABLED, 0) != 0; }
    bool cascadeOpacityEnabled() const { return GetField<uint8_t>(VT_CASCADEOPACITYENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) &&
               VerifyField<int32_t>(verifier, VT_ACTIONTAG) && VerifyField<RotationSkew>(verifier, VT_ROTATIONSKEW) &&
               VerifyField<int32_t>(verifier, VT_ZORDER) && VerifyField<uint8_t>(verifier, VT_VISIBLE) &&
               VerifyField<uint8_t>(verifier, VT_ALPHA) && VerifyField<int32_t>(verifier, VT_TAG) &&
               VerifyField<FVec2>(verifier, VT_POSITION) && VerifyField<Scale>(verifier, VT_SCALE) &&
               VerifyField<AnchorPoint>(verifier, VT_ANCHORPOINT) && VerifyField<Color>(verifier, VT_COLOR) &&
               VerifyField<FlatSize>(verifier, VT_SIZE) && VerifyField<uint8_t>(verifier, VT_FLIPX) &&
               VerifyField<uint8_t>(verifier, VT_FLIPY) && VerifyField<uint8_t>(verifier, VT_IGNORESIZE) &&
               VerifyField<uint8_t>(verifier, VT_TOUCHENABLED) && VerifyOffset(verifier, VT_FRAMEEVENT) &&
               verifier.VerifyString(frameEvent()) && VerifyOffset(verifier, VT_CUSTOMPROPERTY) &&
               verifier.VerifyString(customProperty()) && VerifyOffset(verifier, VT_CALLBACKTYPE) &&
               verifier.VerifyString(callBackType()) && VerifyOffset(verifier, VT_CALLBACKNAME) &&
               verifier.VerifyString(callBackName()) && VerifyOffset(verifier, VT_LAYOUTCOMPONENT) &&
               verifier.VerifyTable(layoutComponent()) && VerifyField<uint8_t>(verifier, VT_CASCADECOLORENABLED) &&
               VerifyField<uint8_t>(verifier, VT_CASCADEOPACITYENABLED) && verifier.EndTable();
    }
};

struct WidgetOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(WidgetOptions::VT_NAME, name); }
    void add_actionTag(int32_t actionTag) { fbb_.AddElement<int32_t>(WidgetOptions::VT_ACTIONTAG, actionTag, 0); }
    void add_rotationSkew(const RotationSkew* rotationSkew)
    {
        fbb_.AddStruct(WidgetOptions::VT_ROTATIONSKEW, rotationSkew);
    }
    void add_zOrder(int32_t zOrder) { fbb_.AddElement<int32_t>(WidgetOptions::VT_ZORDER, zOrder, 0); }
    void add_visible(bool visible)
    {
        fbb_.AddElement<uint8_t>(WidgetOptions::VT_VISIBLE, static_cast<uint8_t>(visible), 1);
    }
    void add_alpha(uint8_t alpha) { fbb_.AddElement<uint8_t>(WidgetOptions::VT_ALPHA, alpha, 255); }
    void add_tag(int32_t tag) { fbb_.AddElement<int32_t>(WidgetOptions::VT_TAG, tag, 0); }
    void add_position(const FVec2* position) { fbb_.AddStruct(WidgetOptions::VT_POSITION, position); }
    void add_scale(const Scale* scale) { fbb_.AddStruct(WidgetOptions::VT_SCALE, scale); }
    void add_anchorPoint(const AnchorPoint* anchorPoint) { fbb_.AddStruct(WidgetOptions::VT_ANCHORPOINT, anchorPoint); }
    void add_color(const Color* color) { fbb_.AddStruct(WidgetOptions::VT_COLOR, color); }
    void add_size(const FlatSize* size) { fbb_.AddStruct(WidgetOptions::VT_SIZE, size); }
    void add_flipX(bool flipX) { fbb_.AddElement<uint8_t>(WidgetOptions::VT_FLIPX, static_cast<uint8_t>(flipX), 0); }
    void add_flipY(bool flipY) { fbb_.AddElement<uint8_t>(WidgetOptions::VT_FLIPY, static_cast<uint8_t>(flipY), 0); }
    void add_ignoreSize(bool ignoreSize)
    {
        fbb_.AddElement<uint8_t>(WidgetOptions::VT_IGNORESIZE, static_cast<uint8_t>(ignoreSize), 0);
    }
    void add_touchEnabled(bool touchEnabled)
    {
        fbb_.AddElement<uint8_t>(WidgetOptions::VT_TOUCHENABLED, static_cast<uint8_t>(touchEnabled), 0);
    }
    void add_frameEvent(flatbuffers::Offset<flatbuffers::String> frameEvent)
    {
        fbb_.AddOffset(WidgetOptions::VT_FRAMEEVENT, frameEvent);
    }
    void add_customProperty(flatbuffers::Offset<flatbuffers::String> customProperty)
    {
        fbb_.AddOffset(WidgetOptions::VT_CUSTOMPROPERTY, customProperty);
    }
    void add_callBackType(flatbuffers::Offset<flatbuffers::String> callBackType)
    {
        fbb_.AddOffset(WidgetOptions::VT_CALLBACKTYPE, callBackType);
    }
    void add_callBackName(flatbuffers::Offset<flatbuffers::String> callBackName)
    {
        fbb_.AddOffset(WidgetOptions::VT_CALLBACKNAME, callBackName);
    }
    void add_layoutComponent(flatbuffers::Offset<LayoutComponentTable> layoutComponent)
    {
        fbb_.AddOffset(WidgetOptions::VT_LAYOUTCOMPONENT, layoutComponent);
    }
    void add_cascadeColorEnabled(bool cascadeColorEnabled)
    {
        fbb_.AddElement<uint8_t>(WidgetOptions::VT_CASCADECOLORENABLED, static_cast<uint8_t>(cascadeColorEnabled), 0);
    }
    void add_cascadeOpacityEnabled(bool cascadeOpacityEnabled)
    {
        fbb_.AddElement<uint8_t>(WidgetOptions::VT_CASCADEOPACITYENABLED, static_cast<uint8_t>(cascadeOpacityEnabled),
                                 0);
    }
    explicit WidgetOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    WidgetOptionsBuilder& operator=(const WidgetOptionsBuilder&);
    flatbuffers::Offset<WidgetOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<WidgetOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<WidgetOptions> CreateWidgetOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::String> name             = 0,
    int32_t actionTag                                         = 0,
    const RotationSkew* rotationSkew                          = 0,
    int32_t zOrder                                            = 0,
    bool visible                                              = true,
    uint8_t alpha                                             = 255,
    int32_t tag                                               = 0,
    const FVec2* position                                     = 0,
    const Scale* scale                                        = 0,
    const AnchorPoint* anchorPoint                            = 0,
    const Color* color                                        = 0,
    const FlatSize* size                                      = 0,
    bool flipX                                                = false,
    bool flipY                                                = false,
    bool ignoreSize                                           = false,
    bool touchEnabled                                         = false,
    flatbuffers::Offset<flatbuffers::String> frameEvent       = 0,
    flatbuffers::Offset<flatbuffers::String> customProperty   = 0,
    flatbuffers::Offset<flatbuffers::String> callBackType     = 0,
    flatbuffers::Offset<flatbuffers::String> callBackName     = 0,
    flatbuffers::Offset<LayoutComponentTable> layoutComponent = 0,
    bool cascadeColorEnabled                                  = false,
    bool cascadeOpacityEnabled                                = false)
{
    WidgetOptionsBuilder builder_(_fbb);
    builder_.add_layoutComponent(layoutComponent);
    builder_.add_callBackName(callBackName);
    builder_.add_callBackType(callBackType);
    builder_.add_customProperty(customProperty);
    builder_.add_frameEvent(frameEvent);
    builder_.add_size(size);
    builder_.add_color(color);
    builder_.add_anchorPoint(anchorPoint);
    builder_.add_scale(scale);
    builder_.add_position(position);
    builder_.add_tag(tag);
    builder_.add_zOrder(zOrder);
    builder_.add_rotationSkew(rotationSkew);
    builder_.add_actionTag(actionTag);
    builder_.add_name(name);
    builder_.add_cascadeOpacityEnabled(cascadeOpacityEnabled);
    builder_.add_cascadeColorEnabled(cascadeColorEnabled);
    builder_.add_touchEnabled(touchEnabled);
    builder_.add_ignoreSize(ignoreSize);
    builder_.add_flipY(flipY);
    builder_.add_flipX(flipX);
    builder_.add_alpha(alpha);
    builder_.add_visible(visible);
    return builder_.Finish();
}

inline flatbuffers::Offset<WidgetOptions> CreateWidgetOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    const char* name                                          = nullptr,
    int32_t actionTag                                         = 0,
    const RotationSkew* rotationSkew                          = 0,
    int32_t zOrder                                            = 0,
    bool visible                                              = true,
    uint8_t alpha                                             = 255,
    int32_t tag                                               = 0,
    const FVec2* position                                     = 0,
    const Scale* scale                                        = 0,
    const AnchorPoint* anchorPoint                            = 0,
    const Color* color                                        = 0,
    const FlatSize* size                                      = 0,
    bool flipX                                                = false,
    bool flipY                                                = false,
    bool ignoreSize                                           = false,
    bool touchEnabled                                         = false,
    const char* frameEvent                                    = nullptr,
    const char* customProperty                                = nullptr,
    const char* callBackType                                  = nullptr,
    const char* callBackName                                  = nullptr,
    flatbuffers::Offset<LayoutComponentTable> layoutComponent = 0,
    bool cascadeColorEnabled                                  = false,
    bool cascadeOpacityEnabled                                = false)
{
    auto name__           = name ? _fbb.CreateString(name) : 0;
    auto frameEvent__     = frameEvent ? _fbb.CreateString(frameEvent) : 0;
    auto customProperty__ = customProperty ? _fbb.CreateString(customProperty) : 0;
    auto callBackType__   = callBackType ? _fbb.CreateString(callBackType) : 0;
    auto callBackName__   = callBackName ? _fbb.CreateString(callBackName) : 0;
    return flatbuffers::CreateWidgetOptions(
        _fbb, name__, actionTag, rotationSkew, zOrder, visible, alpha, tag, position, scale, anchorPoint, color, size,
        flipX, flipY, ignoreSize, touchEnabled, frameEvent__, customProperty__, callBackType__, callBackName__,
        layoutComponent, cascadeColorEnabled, cascadeOpacityEnabled);
}

struct LayoutComponentTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_POSITIONXPERCENTENABLED  = 4,
        VT_POSITIONYPERCENTENABLED  = 6,
        VT_POSITIONXPERCENT         = 8,
        VT_POSITIONYPERCENT         = 10,
        VT_SIZEXPERCENTENABLE       = 12,
        VT_SIZEYPERCENTENABLE       = 14,
        VT_SIZEXPERCENT             = 16,
        VT_SIZEYPERCENT             = 18,
        VT_STRETCHHORIZONTALENABLED = 20,
        VT_STRETCHVERTICALENABLED   = 22,
        VT_HORIZONTALEDGE           = 24,
        VT_VERTICALEDGE             = 26,
        VT_LEFTMARGIN               = 28,
        VT_RIGHTMARGIN              = 30,
        VT_TOPMARGIN                = 32,
        VT_BOTTOMMARGIN             = 34
    };
    bool positionXPercentEnabled() const { return GetField<uint8_t>(VT_POSITIONXPERCENTENABLED, 0) != 0; }
    bool positionYPercentEnabled() const { return GetField<uint8_t>(VT_POSITIONYPERCENTENABLED, 0) != 0; }
    float positionXPercent() const { return GetField<float>(VT_POSITIONXPERCENT, 0.0f); }
    float positionYPercent() const { return GetField<float>(VT_POSITIONYPERCENT, 0.0f); }
    bool sizeXPercentEnable() const { return GetField<uint8_t>(VT_SIZEXPERCENTENABLE, 0) != 0; }
    bool sizeYPercentEnable() const { return GetField<uint8_t>(VT_SIZEYPERCENTENABLE, 0) != 0; }
    float sizeXPercent() const { return GetField<float>(VT_SIZEXPERCENT, 0.0f); }
    float sizeYPercent() const { return GetField<float>(VT_SIZEYPERCENT, 0.0f); }
    bool stretchHorizontalEnabled() const { return GetField<uint8_t>(VT_STRETCHHORIZONTALENABLED, 0) != 0; }
    bool stretchVerticalEnabled() const { return GetField<uint8_t>(VT_STRETCHVERTICALENABLED, 0) != 0; }
    const flatbuffers::String* horizontalEdge() const
    {
        return GetPointer<const flatbuffers::String*>(VT_HORIZONTALEDGE);
    }
    const flatbuffers::String* verticalEdge() const { return GetPointer<const flatbuffers::String*>(VT_VERTICALEDGE); }
    float leftMargin() const { return GetField<float>(VT_LEFTMARGIN, 0.0f); }
    float rightMargin() const { return GetField<float>(VT_RIGHTMARGIN, 0.0f); }
    float topMargin() const { return GetField<float>(VT_TOPMARGIN, 0.0f); }
    float bottomMargin() const { return GetField<float>(VT_BOTTOMMARGIN, 0.0f); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_POSITIONXPERCENTENABLED) &&
               VerifyField<uint8_t>(verifier, VT_POSITIONYPERCENTENABLED) &&
               VerifyField<float>(verifier, VT_POSITIONXPERCENT) && VerifyField<float>(verifier, VT_POSITIONYPERCENT) &&
               VerifyField<uint8_t>(verifier, VT_SIZEXPERCENTENABLE) &&
               VerifyField<uint8_t>(verifier, VT_SIZEYPERCENTENABLE) && VerifyField<float>(verifier, VT_SIZEXPERCENT) &&
               VerifyField<float>(verifier, VT_SIZEYPERCENT) &&
               VerifyField<uint8_t>(verifier, VT_STRETCHHORIZONTALENABLED) &&
               VerifyField<uint8_t>(verifier, VT_STRETCHVERTICALENABLED) && VerifyOffset(verifier, VT_HORIZONTALEDGE) &&
               verifier.VerifyString(horizontalEdge()) && VerifyOffset(verifier, VT_VERTICALEDGE) &&
               verifier.VerifyString(verticalEdge()) && VerifyField<float>(verifier, VT_LEFTMARGIN) &&
               VerifyField<float>(verifier, VT_RIGHTMARGIN) && VerifyField<float>(verifier, VT_TOPMARGIN) &&
               VerifyField<float>(verifier, VT_BOTTOMMARGIN) && verifier.EndTable();
    }
};

struct LayoutComponentTableBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_positionXPercentEnabled(bool positionXPercentEnabled)
    {
        fbb_.AddElement<uint8_t>(LayoutComponentTable::VT_POSITIONXPERCENTENABLED,
                                 static_cast<uint8_t>(positionXPercentEnabled), 0);
    }
    void add_positionYPercentEnabled(bool positionYPercentEnabled)
    {
        fbb_.AddElement<uint8_t>(LayoutComponentTable::VT_POSITIONYPERCENTENABLED,
                                 static_cast<uint8_t>(positionYPercentEnabled), 0);
    }
    void add_positionXPercent(float positionXPercent)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_POSITIONXPERCENT, positionXPercent, 0.0f);
    }
    void add_positionYPercent(float positionYPercent)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_POSITIONYPERCENT, positionYPercent, 0.0f);
    }
    void add_sizeXPercentEnable(bool sizeXPercentEnable)
    {
        fbb_.AddElement<uint8_t>(LayoutComponentTable::VT_SIZEXPERCENTENABLE, static_cast<uint8_t>(sizeXPercentEnable),
                                 0);
    }
    void add_sizeYPercentEnable(bool sizeYPercentEnable)
    {
        fbb_.AddElement<uint8_t>(LayoutComponentTable::VT_SIZEYPERCENTENABLE, static_cast<uint8_t>(sizeYPercentEnable),
                                 0);
    }
    void add_sizeXPercent(float sizeXPercent)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_SIZEXPERCENT, sizeXPercent, 0.0f);
    }
    void add_sizeYPercent(float sizeYPercent)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_SIZEYPERCENT, sizeYPercent, 0.0f);
    }
    void add_stretchHorizontalEnabled(bool stretchHorizontalEnabled)
    {
        fbb_.AddElement<uint8_t>(LayoutComponentTable::VT_STRETCHHORIZONTALENABLED,
                                 static_cast<uint8_t>(stretchHorizontalEnabled), 0);
    }
    void add_stretchVerticalEnabled(bool stretchVerticalEnabled)
    {
        fbb_.AddElement<uint8_t>(LayoutComponentTable::VT_STRETCHVERTICALENABLED,
                                 static_cast<uint8_t>(stretchVerticalEnabled), 0);
    }
    void add_horizontalEdge(flatbuffers::Offset<flatbuffers::String> horizontalEdge)
    {
        fbb_.AddOffset(LayoutComponentTable::VT_HORIZONTALEDGE, horizontalEdge);
    }
    void add_verticalEdge(flatbuffers::Offset<flatbuffers::String> verticalEdge)
    {
        fbb_.AddOffset(LayoutComponentTable::VT_VERTICALEDGE, verticalEdge);
    }
    void add_leftMargin(float leftMargin)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_LEFTMARGIN, leftMargin, 0.0f);
    }
    void add_rightMargin(float rightMargin)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_RIGHTMARGIN, rightMargin, 0.0f);
    }
    void add_topMargin(float topMargin) { fbb_.AddElement<float>(LayoutComponentTable::VT_TOPMARGIN, topMargin, 0.0f); }
    void add_bottomMargin(float bottomMargin)
    {
        fbb_.AddElement<float>(LayoutComponentTable::VT_BOTTOMMARGIN, bottomMargin, 0.0f);
    }
    explicit LayoutComponentTableBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    LayoutComponentTableBuilder& operator=(const LayoutComponentTableBuilder&);
    flatbuffers::Offset<LayoutComponentTable> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<LayoutComponentTable>(end);
        return o;
    }
};

inline flatbuffers::Offset<LayoutComponentTable> CreateLayoutComponentTable(
    flatbuffers::FlatBufferBuilder& _fbb,
    bool positionXPercentEnabled                            = false,
    bool positionYPercentEnabled                            = false,
    float positionXPercent                                  = 0.0f,
    float positionYPercent                                  = 0.0f,
    bool sizeXPercentEnable                                 = false,
    bool sizeYPercentEnable                                 = false,
    float sizeXPercent                                      = 0.0f,
    float sizeYPercent                                      = 0.0f,
    bool stretchHorizontalEnabled                           = false,
    bool stretchVerticalEnabled                             = false,
    flatbuffers::Offset<flatbuffers::String> horizontalEdge = 0,
    flatbuffers::Offset<flatbuffers::String> verticalEdge   = 0,
    float leftMargin                                        = 0.0f,
    float rightMargin                                       = 0.0f,
    float topMargin                                         = 0.0f,
    float bottomMargin                                      = 0.0f)
{
    LayoutComponentTableBuilder builder_(_fbb);
    builder_.add_bottomMargin(bottomMargin);
    builder_.add_topMargin(topMargin);
    builder_.add_rightMargin(rightMargin);
    builder_.add_leftMargin(leftMargin);
    builder_.add_verticalEdge(verticalEdge);
    builder_.add_horizontalEdge(horizontalEdge);
    builder_.add_sizeYPercent(sizeYPercent);
    builder_.add_sizeXPercent(sizeXPercent);
    builder_.add_positionYPercent(positionYPercent);
    builder_.add_positionXPercent(positionXPercent);
    builder_.add_stretchVerticalEnabled(stretchVerticalEnabled);
    builder_.add_stretchHorizontalEnabled(stretchHorizontalEnabled);
    builder_.add_sizeYPercentEnable(sizeYPercentEnable);
    builder_.add_sizeXPercentEnable(sizeXPercentEnable);
    builder_.add_positionYPercentEnabled(positionYPercentEnabled);
    builder_.add_positionXPercentEnabled(positionXPercentEnabled);
    return builder_.Finish();
}

inline flatbuffers::Offset<LayoutComponentTable> CreateLayoutComponentTableDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                                                  bool positionXPercentEnabled  = false,
                                                                                  bool positionYPercentEnabled  = false,
                                                                                  float positionXPercent        = 0.0f,
                                                                                  float positionYPercent        = 0.0f,
                                                                                  bool sizeXPercentEnable       = false,
                                                                                  bool sizeYPercentEnable       = false,
                                                                                  float sizeXPercent            = 0.0f,
                                                                                  float sizeYPercent            = 0.0f,
                                                                                  bool stretchHorizontalEnabled = false,
                                                                                  bool stretchVerticalEnabled   = false,
                                                                                  const char* horizontalEdge = nullptr,
                                                                                  const char* verticalEdge   = nullptr,
                                                                                  float leftMargin           = 0.0f,
                                                                                  float rightMargin          = 0.0f,
                                                                                  float topMargin            = 0.0f,
                                                                                  float bottomMargin         = 0.0f)
{
    auto horizontalEdge__ = horizontalEdge ? _fbb.CreateString(horizontalEdge) : 0;
    auto verticalEdge__   = verticalEdge ? _fbb.CreateString(verticalEdge) : 0;
    return flatbuffers::CreateLayoutComponentTable(
        _fbb, positionXPercentEnabled, positionYPercentEnabled, positionXPercent, positionYPercent, sizeXPercentEnable,
        sizeYPercentEnable, sizeXPercent, sizeYPercent, stretchHorizontalEnabled, stretchVerticalEnabled,
        horizontalEdge__, verticalEdge__, leftMargin, rightMargin, topMargin, bottomMargin);
}

struct SingleNodeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS = 4
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && verifier.EndTable();
    }
};

struct SingleNodeOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(SingleNodeOptions::VT_NODEOPTIONS, nodeOptions);
    }
    explicit SingleNodeOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    SingleNodeOptionsBuilder& operator=(const SingleNodeOptionsBuilder&);
    flatbuffers::Offset<SingleNodeOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<SingleNodeOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<SingleNodeOptions> CreateSingleNodeOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0)
{
    SingleNodeOptionsBuilder builder_(_fbb);
    builder_.add_nodeOptions(nodeOptions);
    return builder_.Finish();
}

struct SpriteOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS           = 4,
        VT_FILENAMEDATA          = 6,
        VT_BLENDFUNC             = 8,
        VT_INTELLISHADINGENABLED = 10,
        VT_HSV                   = 12,
        VT_FILTER                = 14
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const ResourceData* fileNameData() const { return GetPointer<const ResourceData*>(VT_FILENAMEDATA); }
    const BlendFunc* blendFunc() const { return GetStruct<const BlendFunc*>(VT_BLENDFUNC); }
    bool intelliShadingEnabled() const { return GetField<uint8_t>(VT_INTELLISHADINGENABLED, 0) != 0; }
    const FVec3* hsv() const { return GetStruct<const FVec3*>(VT_HSV); }
    const FVec3* filter() const { return GetStruct<const FVec3*>(VT_FILTER); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_FILENAMEDATA) &&
               verifier.VerifyTable(fileNameData()) && VerifyField<BlendFunc>(verifier, VT_BLENDFUNC) &&
               VerifyField<uint8_t>(verifier, VT_INTELLISHADINGENABLED) && VerifyField<FVec3>(verifier, VT_HSV) &&
               VerifyField<FVec3>(verifier, VT_FILTER) && verifier.EndTable();
    }
};

struct SpriteOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(SpriteOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData)
    {
        fbb_.AddOffset(SpriteOptions::VT_FILENAMEDATA, fileNameData);
    }
    void add_blendFunc(const BlendFunc* blendFunc) { fbb_.AddStruct(SpriteOptions::VT_BLENDFUNC, blendFunc); }
    void add_intelliShadingEnabled(bool intelliShadingEnabled)
    {
        fbb_.AddElement<uint8_t>(SpriteOptions::VT_INTELLISHADINGENABLED, static_cast<uint8_t>(intelliShadingEnabled),
                                 0);
    }
    void add_hsv(const FVec3* hsv) { fbb_.AddStruct(SpriteOptions::VT_HSV, hsv); }
    void add_filter(const FVec3* filter) { fbb_.AddStruct(SpriteOptions::VT_FILTER, filter); }
    explicit SpriteOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    SpriteOptionsBuilder& operator=(const SpriteOptionsBuilder&);
    flatbuffers::Offset<SpriteOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<SpriteOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<SpriteOptions> CreateSpriteOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                              flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
                                                              flatbuffers::Offset<ResourceData> fileNameData = 0,
                                                              const BlendFunc* blendFunc                     = 0,
                                                              bool intelliShadingEnabled                     = false,
                                                              const FVec3* hsv                               = 0,
                                                              const FVec3* filter                            = 0)
{
    SpriteOptionsBuilder builder_(_fbb);
    builder_.add_filter(filter);
    builder_.add_hsv(hsv);
    builder_.add_blendFunc(blendFunc);
    builder_.add_fileNameData(fileNameData);
    builder_.add_nodeOptions(nodeOptions);
    builder_.add_intelliShadingEnabled(intelliShadingEnabled);
    return builder_.Finish();
}

struct ParticleSystemOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS  = 4,
        VT_FILENAMEDATA = 6,
        VT_BLENDFUNC    = 8
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const ResourceData* fileNameData() const { return GetPointer<const ResourceData*>(VT_FILENAMEDATA); }
    const BlendFunc* blendFunc() const { return GetStruct<const BlendFunc*>(VT_BLENDFUNC); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_FILENAMEDATA) &&
               verifier.VerifyTable(fileNameData()) && VerifyField<BlendFunc>(verifier, VT_BLENDFUNC) &&
               verifier.EndTable();
    }
};

struct ParticleSystemOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(ParticleSystemOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData)
    {
        fbb_.AddOffset(ParticleSystemOptions::VT_FILENAMEDATA, fileNameData);
    }
    void add_blendFunc(const BlendFunc* blendFunc) { fbb_.AddStruct(ParticleSystemOptions::VT_BLENDFUNC, blendFunc); }
    explicit ParticleSystemOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    ParticleSystemOptionsBuilder& operator=(const ParticleSystemOptionsBuilder&);
    flatbuffers::Offset<ParticleSystemOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ParticleSystemOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ParticleSystemOptions> CreateParticleSystemOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    flatbuffers::Offset<ResourceData> fileNameData = 0,
    const BlendFunc* blendFunc                     = 0)
{
    ParticleSystemOptionsBuilder builder_(_fbb);
    builder_.add_blendFunc(blendFunc);
    builder_.add_fileNameData(fileNameData);
    builder_.add_nodeOptions(nodeOptions);
    return builder_.Finish();
}

struct SpineSkeletonOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS = 4,
        VT_DATAFILE    = 6,
        VT_ATLASFILE   = 8,
        VT_ANIMATION   = 10,
        VT_SKIN        = 12,
        VT_LOOP        = 14,
        VT_TIMESCALE   = 16
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const flatbuffers::String* dataFile() const { return GetPointer<const flatbuffers::String*>(VT_DATAFILE); }
    const flatbuffers::String* atlasFile() const { return GetPointer<const flatbuffers::String*>(VT_ATLASFILE); }
    const flatbuffers::String* animation() const { return GetPointer<const flatbuffers::String*>(VT_ANIMATION); }
    const flatbuffers::String* skin() const { return GetPointer<const flatbuffers::String*>(VT_SKIN); }
    bool loop() const { return GetField<uint8_t>(VT_LOOP, 0) != 0; }
    float timeScale() const { return GetField<float>(VT_TIMESCALE, 0.0f); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_DATAFILE) &&
               verifier.VerifyString(dataFile()) && VerifyOffset(verifier, VT_ATLASFILE) &&
               verifier.VerifyString(atlasFile()) && VerifyOffset(verifier, VT_ANIMATION) &&
               verifier.VerifyString(animation()) && VerifyOffset(verifier, VT_SKIN) && verifier.VerifyString(skin()) &&
               VerifyField<uint8_t>(verifier, VT_LOOP) && VerifyField<float>(verifier, VT_TIMESCALE) &&
               verifier.EndTable();
    }
};

struct SpineSkeletonOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(SpineSkeletonOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_dataFile(flatbuffers::Offset<flatbuffers::String> dataFile)
    {
        fbb_.AddOffset(SpineSkeletonOptions::VT_DATAFILE, dataFile);
    }
    void add_atlasFile(flatbuffers::Offset<flatbuffers::String> atlasFile)
    {
        fbb_.AddOffset(SpineSkeletonOptions::VT_ATLASFILE, atlasFile);
    }
    void add_animation(flatbuffers::Offset<flatbuffers::String> animation)
    {
        fbb_.AddOffset(SpineSkeletonOptions::VT_ANIMATION, animation);
    }
    void add_skin(flatbuffers::Offset<flatbuffers::String> skin)
    {
        fbb_.AddOffset(SpineSkeletonOptions::VT_SKIN, skin);
    }
    void add_loop(bool loop) { fbb_.AddElement<uint8_t>(SpineSkeletonOptions::VT_LOOP, static_cast<uint8_t>(loop), 0); }
    void add_timeScale(float timeScale) { fbb_.AddElement<float>(SpineSkeletonOptions::VT_TIMESCALE, timeScale, 0.0f); }
    explicit SpineSkeletonOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    SpineSkeletonOptionsBuilder& operator=(const SpineSkeletonOptionsBuilder&);
    flatbuffers::Offset<SpineSkeletonOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<SpineSkeletonOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<SpineSkeletonOptions> CreateSpineSkeletonOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions     = 0,
    flatbuffers::Offset<flatbuffers::String> dataFile  = 0,
    flatbuffers::Offset<flatbuffers::String> atlasFile = 0,
    flatbuffers::Offset<flatbuffers::String> animation = 0,
    flatbuffers::Offset<flatbuffers::String> skin      = 0,
    bool loop                                          = false,
    float timeScale                                    = 0.0f)
{
    SpineSkeletonOptionsBuilder builder_(_fbb);
    builder_.add_timeScale(timeScale);
    builder_.add_skin(skin);
    builder_.add_animation(animation);
    builder_.add_atlasFile(atlasFile);
    builder_.add_dataFile(dataFile);
    builder_.add_nodeOptions(nodeOptions);
    builder_.add_loop(loop);
    return builder_.Finish();
}

inline flatbuffers::Offset<SpineSkeletonOptions> CreateSpineSkeletonOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    const char* dataFile                           = nullptr,
    const char* atlasFile                          = nullptr,
    const char* animation                          = nullptr,
    const char* skin                               = nullptr,
    bool loop                                      = false,
    float timeScale                                = 0.0f)
{
    auto dataFile__  = dataFile ? _fbb.CreateString(dataFile) : 0;
    auto atlasFile__ = atlasFile ? _fbb.CreateString(atlasFile) : 0;
    auto animation__ = animation ? _fbb.CreateString(animation) : 0;
    auto skin__      = skin ? _fbb.CreateString(skin) : 0;
    return flatbuffers::CreateSpineSkeletonOptions(_fbb, nodeOptions, dataFile__, atlasFile__, animation__, skin__,
                                                   loop, timeScale);
}

struct ControlSwitchOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS = 4,
        VT_MASKIMAGE   = 6,
        VT_ONIMAGE     = 8,
        VT_OFFIMAGE    = 10,
        VT_THUMBIMAGE  = 12,
        VT_ON          = 14,
        VT_ENABLED     = 16
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const ResourceData* maskImage() const { return GetPointer<const ResourceData*>(VT_MASKIMAGE); }
    const ResourceData* onImage() const { return GetPointer<const ResourceData*>(VT_ONIMAGE); }
    const ResourceData* offImage() const { return GetPointer<const ResourceData*>(VT_OFFIMAGE); }
    const ResourceData* thumbImage() const { return GetPointer<const ResourceData*>(VT_THUMBIMAGE); }
    bool on() const { return GetField<uint8_t>(VT_ON, 0) != 0; }
    bool enabled() const { return GetField<uint8_t>(VT_ENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_MASKIMAGE) &&
               verifier.VerifyTable(maskImage()) && VerifyOffset(verifier, VT_ONIMAGE) &&
               verifier.VerifyTable(onImage()) && VerifyOffset(verifier, VT_OFFIMAGE) &&
               verifier.VerifyTable(offImage()) && VerifyOffset(verifier, VT_THUMBIMAGE) &&
               verifier.VerifyTable(thumbImage()) && VerifyField<uint8_t>(verifier, VT_ON) &&
               VerifyField<uint8_t>(verifier, VT_ENABLED) && verifier.EndTable();
    }
};

struct ControlSwitchOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(ControlSwitchOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_maskImage(flatbuffers::Offset<ResourceData> maskImage)
    {
        fbb_.AddOffset(ControlSwitchOptions::VT_MASKIMAGE, maskImage);
    }
    void add_onImage(flatbuffers::Offset<ResourceData> onImage)
    {
        fbb_.AddOffset(ControlSwitchOptions::VT_ONIMAGE, onImage);
    }
    void add_offImage(flatbuffers::Offset<ResourceData> offImage)
    {
        fbb_.AddOffset(ControlSwitchOptions::VT_OFFIMAGE, offImage);
    }
    void add_thumbImage(flatbuffers::Offset<ResourceData> thumbImage)
    {
        fbb_.AddOffset(ControlSwitchOptions::VT_THUMBIMAGE, thumbImage);
    }
    void add_on(bool on) { fbb_.AddElement<uint8_t>(ControlSwitchOptions::VT_ON, static_cast<uint8_t>(on), 0); }
    void add_enabled(bool enabled)
    {
        fbb_.AddElement<uint8_t>(ControlSwitchOptions::VT_ENABLED, static_cast<uint8_t>(enabled), 0);
    }
    explicit ControlSwitchOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    ControlSwitchOptionsBuilder& operator=(const ControlSwitchOptionsBuilder&);
    flatbuffers::Offset<ControlSwitchOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ControlSwitchOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ControlSwitchOptions> CreateControlSwitchOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    flatbuffers::Offset<ResourceData> maskImage    = 0,
    flatbuffers::Offset<ResourceData> onImage      = 0,
    flatbuffers::Offset<ResourceData> offImage     = 0,
    flatbuffers::Offset<ResourceData> thumbImage   = 0,
    bool on                                        = false,
    bool enabled                                   = false)
{
    ControlSwitchOptionsBuilder builder_(_fbb);
    builder_.add_thumbImage(thumbImage);
    builder_.add_offImage(offImage);
    builder_.add_onImage(onImage);
    builder_.add_maskImage(maskImage);
    builder_.add_nodeOptions(nodeOptions);
    builder_.add_enabled(enabled);
    builder_.add_on(on);
    return builder_.Finish();
}

struct LayerColorOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS = 4
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && verifier.EndTable();
    }
};

struct LayerColorOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(LayerColorOptions::VT_NODEOPTIONS, nodeOptions);
    }
    explicit LayerColorOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    LayerColorOptionsBuilder& operator=(const LayerColorOptionsBuilder&);
    flatbuffers::Offset<LayerColorOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<LayerColorOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<LayerColorOptions> CreateLayerColorOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0)
{
    LayerColorOptionsBuilder builder_(_fbb);
    builder_.add_nodeOptions(nodeOptions);
    return builder_.Finish();
}

struct GameMapOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS  = 4,
        VT_FILENAMEDATA = 6
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const ResourceData* fileNameData() const { return GetPointer<const ResourceData*>(VT_FILENAMEDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_FILENAMEDATA) &&
               verifier.VerifyTable(fileNameData()) && verifier.EndTable();
    }
};

struct GameMapOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(GameMapOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData)
    {
        fbb_.AddOffset(GameMapOptions::VT_FILENAMEDATA, fileNameData);
    }
    explicit GameMapOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    GameMapOptionsBuilder& operator=(const GameMapOptionsBuilder&);
    flatbuffers::Offset<GameMapOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<GameMapOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<GameMapOptions> CreateGameMapOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                                flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
                                                                flatbuffers::Offset<ResourceData> fileNameData = 0)
{
    GameMapOptionsBuilder builder_(_fbb);
    builder_.add_fileNameData(fileNameData);
    builder_.add_nodeOptions(nodeOptions);
    return builder_.Finish();
}

struct ButtonOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS        = 4,
        VT_NORMALDATA           = 6,
        VT_PRESSEDDATA          = 8,
        VT_DISABLEDDATA         = 10,
        VT_FONTRESOURCE         = 12,
        VT_TEXT                 = 14,
        VT_FONTNAME             = 16,
        VT_FONTSIZE             = 18,
        VT_TEXTCOLOR            = 20,
        VT_CAPINSETS            = 22,
        VT_SCALE9SIZE           = 24,
        VT_SCALE9ENABLED        = 26,
        VT_DISPLAYSTATE         = 28,
        VT_OUTLINEENABLED       = 30,
        VT_OUTLINECOLOR         = 32,
        VT_OUTLINESIZE          = 34,
        VT_SHADOWENABLED        = 36,
        VT_SHADOWCOLOR          = 38,
        VT_SHADOWOFFSETX        = 40,
        VT_SHADOWOFFSETY        = 42,
        VT_SHADOWBLURRADIUS     = 44,
        VT_ISLOCALIZED          = 46,
        VT_GLOWENABLED          = 48,
        VT_GLOWCOLOR            = 50,
        VT_BOLDENABLED          = 52,
        VT_UNDERLINEENABLED     = 54,
        VT_ITALICSENABLED       = 56,
        VT_STRIKETHROUGHENABLED = 58
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* normalData() const { return GetPointer<const ResourceData*>(VT_NORMALDATA); }
    const ResourceData* pressedData() const { return GetPointer<const ResourceData*>(VT_PRESSEDDATA); }
    const ResourceData* disabledData() const { return GetPointer<const ResourceData*>(VT_DISABLEDDATA); }
    const ResourceData* fontResource() const { return GetPointer<const ResourceData*>(VT_FONTRESOURCE); }
    const flatbuffers::String* text() const { return GetPointer<const flatbuffers::String*>(VT_TEXT); }
    const flatbuffers::String* fontName() const { return GetPointer<const flatbuffers::String*>(VT_FONTNAME); }
    int32_t fontSize() const { return GetField<int32_t>(VT_FONTSIZE, 0); }
    const Color* textColor() const { return GetStruct<const Color*>(VT_TEXTCOLOR); }
    const CapInsets* capInsets() const { return GetStruct<const CapInsets*>(VT_CAPINSETS); }
    const FlatSize* scale9Size() const { return GetStruct<const FlatSize*>(VT_SCALE9SIZE); }
    bool scale9Enabled() const { return GetField<uint8_t>(VT_SCALE9ENABLED, 0) != 0; }
    bool displaystate() const { return GetField<uint8_t>(VT_DISPLAYSTATE, 1) != 0; }
    bool outlineEnabled() const { return GetField<uint8_t>(VT_OUTLINEENABLED, 0) != 0; }
    const Color* outlineColor() const { return GetStruct<const Color*>(VT_OUTLINECOLOR); }
    int32_t outlineSize() const { return GetField<int32_t>(VT_OUTLINESIZE, 1); }
    bool shadowEnabled() const { return GetField<uint8_t>(VT_SHADOWENABLED, 0) != 0; }
    const Color* shadowColor() const { return GetStruct<const Color*>(VT_SHADOWCOLOR); }
    float shadowOffsetX() const { return GetField<float>(VT_SHADOWOFFSETX, 2.0f); }
    float shadowOffsetY() const { return GetField<float>(VT_SHADOWOFFSETY, -2.0f); }
    int32_t shadowBlurRadius() const { return GetField<int32_t>(VT_SHADOWBLURRADIUS, 0); }
    bool isLocalized() const { return GetField<uint8_t>(VT_ISLOCALIZED, 0) != 0; }
    bool glowEnabled() const { return GetField<uint8_t>(VT_GLOWENABLED, 0) != 0; }
    const Color* glowColor() const { return GetStruct<const Color*>(VT_GLOWCOLOR); }
    bool boldEnabled() const { return GetField<uint8_t>(VT_BOLDENABLED, 0) != 0; }
    bool underlineEnabled() const { return GetField<uint8_t>(VT_UNDERLINEENABLED, 0) != 0; }
    bool italicsEnabled() const { return GetField<uint8_t>(VT_ITALICSENABLED, 0) != 0; }
    bool strikethroughEnabled() const { return GetField<uint8_t>(VT_STRIKETHROUGHENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_NORMALDATA) &&
               verifier.VerifyTable(normalData()) && VerifyOffset(verifier, VT_PRESSEDDATA) &&
               verifier.VerifyTable(pressedData()) && VerifyOffset(verifier, VT_DISABLEDDATA) &&
               verifier.VerifyTable(disabledData()) && VerifyOffset(verifier, VT_FONTRESOURCE) &&
               verifier.VerifyTable(fontResource()) && VerifyOffset(verifier, VT_TEXT) &&
               verifier.VerifyString(text()) && VerifyOffset(verifier, VT_FONTNAME) &&
               verifier.VerifyString(fontName()) && VerifyField<int32_t>(verifier, VT_FONTSIZE) &&
               VerifyField<Color>(verifier, VT_TEXTCOLOR) && VerifyField<CapInsets>(verifier, VT_CAPINSETS) &&
               VerifyField<FlatSize>(verifier, VT_SCALE9SIZE) && VerifyField<uint8_t>(verifier, VT_SCALE9ENABLED) &&
               VerifyField<uint8_t>(verifier, VT_DISPLAYSTATE) && VerifyField<uint8_t>(verifier, VT_OUTLINEENABLED) &&
               VerifyField<Color>(verifier, VT_OUTLINECOLOR) && VerifyField<int32_t>(verifier, VT_OUTLINESIZE) &&
               VerifyField<uint8_t>(verifier, VT_SHADOWENABLED) && VerifyField<Color>(verifier, VT_SHADOWCOLOR) &&
               VerifyField<float>(verifier, VT_SHADOWOFFSETX) && VerifyField<float>(verifier, VT_SHADOWOFFSETY) &&
               VerifyField<int32_t>(verifier, VT_SHADOWBLURRADIUS) && VerifyField<uint8_t>(verifier, VT_ISLOCALIZED) &&
               VerifyField<uint8_t>(verifier, VT_GLOWENABLED) && VerifyField<Color>(verifier, VT_GLOWCOLOR) &&
               VerifyField<uint8_t>(verifier, VT_BOLDENABLED) && VerifyField<uint8_t>(verifier, VT_UNDERLINEENABLED) &&
               VerifyField<uint8_t>(verifier, VT_ITALICSENABLED) &&
               VerifyField<uint8_t>(verifier, VT_STRIKETHROUGHENABLED) && verifier.EndTable();
    }
};

struct ButtonOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(ButtonOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_normalData(flatbuffers::Offset<ResourceData> normalData)
    {
        fbb_.AddOffset(ButtonOptions::VT_NORMALDATA, normalData);
    }
    void add_pressedData(flatbuffers::Offset<ResourceData> pressedData)
    {
        fbb_.AddOffset(ButtonOptions::VT_PRESSEDDATA, pressedData);
    }
    void add_disabledData(flatbuffers::Offset<ResourceData> disabledData)
    {
        fbb_.AddOffset(ButtonOptions::VT_DISABLEDDATA, disabledData);
    }
    void add_fontResource(flatbuffers::Offset<ResourceData> fontResource)
    {
        fbb_.AddOffset(ButtonOptions::VT_FONTRESOURCE, fontResource);
    }
    void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(ButtonOptions::VT_TEXT, text); }
    void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName)
    {
        fbb_.AddOffset(ButtonOptions::VT_FONTNAME, fontName);
    }
    void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(ButtonOptions::VT_FONTSIZE, fontSize, 0); }
    void add_textColor(const Color* textColor) { fbb_.AddStruct(ButtonOptions::VT_TEXTCOLOR, textColor); }
    void add_capInsets(const CapInsets* capInsets) { fbb_.AddStruct(ButtonOptions::VT_CAPINSETS, capInsets); }
    void add_scale9Size(const FlatSize* scale9Size) { fbb_.AddStruct(ButtonOptions::VT_SCALE9SIZE, scale9Size); }
    void add_scale9Enabled(bool scale9Enabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_SCALE9ENABLED, static_cast<uint8_t>(scale9Enabled), 0);
    }
    void add_displaystate(bool displaystate)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_DISPLAYSTATE, static_cast<uint8_t>(displaystate), 1);
    }
    void add_outlineEnabled(bool outlineEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_OUTLINEENABLED, static_cast<uint8_t>(outlineEnabled), 0);
    }
    void add_outlineColor(const Color* outlineColor) { fbb_.AddStruct(ButtonOptions::VT_OUTLINECOLOR, outlineColor); }
    void add_outlineSize(int32_t outlineSize)
    {
        fbb_.AddElement<int32_t>(ButtonOptions::VT_OUTLINESIZE, outlineSize, 1);
    }
    void add_shadowEnabled(bool shadowEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_SHADOWENABLED, static_cast<uint8_t>(shadowEnabled), 0);
    }
    void add_shadowColor(const Color* shadowColor) { fbb_.AddStruct(ButtonOptions::VT_SHADOWCOLOR, shadowColor); }
    void add_shadowOffsetX(float shadowOffsetX)
    {
        fbb_.AddElement<float>(ButtonOptions::VT_SHADOWOFFSETX, shadowOffsetX, 2.0f);
    }
    void add_shadowOffsetY(float shadowOffsetY)
    {
        fbb_.AddElement<float>(ButtonOptions::VT_SHADOWOFFSETY, shadowOffsetY, -2.0f);
    }
    void add_shadowBlurRadius(int32_t shadowBlurRadius)
    {
        fbb_.AddElement<int32_t>(ButtonOptions::VT_SHADOWBLURRADIUS, shadowBlurRadius, 0);
    }
    void add_isLocalized(bool isLocalized)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_ISLOCALIZED, static_cast<uint8_t>(isLocalized), 0);
    }
    void add_glowEnabled(bool glowEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_GLOWENABLED, static_cast<uint8_t>(glowEnabled), 0);
    }
    void add_glowColor(const Color* glowColor) { fbb_.AddStruct(ButtonOptions::VT_GLOWCOLOR, glowColor); }
    void add_boldEnabled(bool boldEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_BOLDENABLED, static_cast<uint8_t>(boldEnabled), 0);
    }
    void add_underlineEnabled(bool underlineEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_UNDERLINEENABLED, static_cast<uint8_t>(underlineEnabled), 0);
    }
    void add_italicsEnabled(bool italicsEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_ITALICSENABLED, static_cast<uint8_t>(italicsEnabled), 0);
    }
    void add_strikethroughEnabled(bool strikethroughEnabled)
    {
        fbb_.AddElement<uint8_t>(ButtonOptions::VT_STRIKETHROUGHENABLED, static_cast<uint8_t>(strikethroughEnabled), 0);
    }
    explicit ButtonOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ButtonOptionsBuilder& operator=(const ButtonOptionsBuilder&);
    flatbuffers::Offset<ButtonOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ButtonOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ButtonOptions> CreateButtonOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                              flatbuffers::Offset<WidgetOptions> widgetOptions  = 0,
                                                              flatbuffers::Offset<ResourceData> normalData      = 0,
                                                              flatbuffers::Offset<ResourceData> pressedData     = 0,
                                                              flatbuffers::Offset<ResourceData> disabledData    = 0,
                                                              flatbuffers::Offset<ResourceData> fontResource    = 0,
                                                              flatbuffers::Offset<flatbuffers::String> text     = 0,
                                                              flatbuffers::Offset<flatbuffers::String> fontName = 0,
                                                              int32_t fontSize                                  = 0,
                                                              const Color* textColor                            = 0,
                                                              const CapInsets* capInsets                        = 0,
                                                              const FlatSize* scale9Size                        = 0,
                                                              bool scale9Enabled                                = false,
                                                              bool displaystate                                 = true,
                                                              bool outlineEnabled                               = false,
                                                              const Color* outlineColor                         = 0,
                                                              int32_t outlineSize                               = 1,
                                                              bool shadowEnabled                                = false,
                                                              const Color* shadowColor                          = 0,
                                                              float shadowOffsetX                               = 2.0f,
                                                              float shadowOffsetY                               = -2.0f,
                                                              int32_t shadowBlurRadius                          = 0,
                                                              bool isLocalized                                  = false,
                                                              bool glowEnabled                                  = false,
                                                              const Color* glowColor                            = 0,
                                                              bool boldEnabled                                  = false,
                                                              bool underlineEnabled                             = false,
                                                              bool italicsEnabled                               = false,
                                                              bool strikethroughEnabled                         = false)
{
    ButtonOptionsBuilder builder_(_fbb);
    builder_.add_glowColor(glowColor);
    builder_.add_shadowBlurRadius(shadowBlurRadius);
    builder_.add_shadowOffsetY(shadowOffsetY);
    builder_.add_shadowOffsetX(shadowOffsetX);
    builder_.add_shadowColor(shadowColor);
    builder_.add_outlineSize(outlineSize);
    builder_.add_outlineColor(outlineColor);
    builder_.add_scale9Size(scale9Size);
    builder_.add_capInsets(capInsets);
    builder_.add_textColor(textColor);
    builder_.add_fontSize(fontSize);
    builder_.add_fontName(fontName);
    builder_.add_text(text);
    builder_.add_fontResource(fontResource);
    builder_.add_disabledData(disabledData);
    builder_.add_pressedData(pressedData);
    builder_.add_normalData(normalData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_strikethroughEnabled(strikethroughEnabled);
    builder_.add_italicsEnabled(italicsEnabled);
    builder_.add_underlineEnabled(underlineEnabled);
    builder_.add_boldEnabled(boldEnabled);
    builder_.add_glowEnabled(glowEnabled);
    builder_.add_isLocalized(isLocalized);
    builder_.add_shadowEnabled(shadowEnabled);
    builder_.add_outlineEnabled(outlineEnabled);
    builder_.add_displaystate(displaystate);
    builder_.add_scale9Enabled(scale9Enabled);
    return builder_.Finish();
}

inline flatbuffers::Offset<ButtonOptions> CreateButtonOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    flatbuffers::Offset<ResourceData> normalData     = 0,
    flatbuffers::Offset<ResourceData> pressedData    = 0,
    flatbuffers::Offset<ResourceData> disabledData   = 0,
    flatbuffers::Offset<ResourceData> fontResource   = 0,
    const char* text                                 = nullptr,
    const char* fontName                             = nullptr,
    int32_t fontSize                                 = 0,
    const Color* textColor                           = 0,
    const CapInsets* capInsets                       = 0,
    const FlatSize* scale9Size                       = 0,
    bool scale9Enabled                               = false,
    bool displaystate                                = true,
    bool outlineEnabled                              = false,
    const Color* outlineColor                        = 0,
    int32_t outlineSize                              = 1,
    bool shadowEnabled                               = false,
    const Color* shadowColor                         = 0,
    float shadowOffsetX                              = 2.0f,
    float shadowOffsetY                              = -2.0f,
    int32_t shadowBlurRadius                         = 0,
    bool isLocalized                                 = false,
    bool glowEnabled                                 = false,
    const Color* glowColor                           = 0,
    bool boldEnabled                                 = false,
    bool underlineEnabled                            = false,
    bool italicsEnabled                              = false,
    bool strikethroughEnabled                        = false)
{
    auto text__     = text ? _fbb.CreateString(text) : 0;
    auto fontName__ = fontName ? _fbb.CreateString(fontName) : 0;
    return flatbuffers::CreateButtonOptions(
        _fbb, widgetOptions, normalData, pressedData, disabledData, fontResource, text__, fontName__, fontSize,
        textColor, capInsets, scale9Size, scale9Enabled, displaystate, outlineEnabled, outlineColor, outlineSize,
        shadowEnabled, shadowColor, shadowOffsetX, shadowOffsetY, shadowBlurRadius, isLocalized, glowEnabled, glowColor,
        boldEnabled, underlineEnabled, italicsEnabled, strikethroughEnabled);
}

struct CheckBoxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS             = 4,
        VT_BACKGROUNDBOXDATA         = 6,
        VT_BACKGROUNDBOXSELECTEDDATA = 8,
        VT_FRONTCROSSDATA            = 10,
        VT_BACKGROUNDBOXDISABLEDDATA = 12,
        VT_FRONTCROSSDISABLEDDATA    = 14,
        VT_SELECTEDSTATE             = 16,
        VT_DISPLAYSTATE              = 18
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* backGroundBoxData() const { return GetPointer<const ResourceData*>(VT_BACKGROUNDBOXDATA); }
    const ResourceData* backGroundBoxSelectedData() const
    {
        return GetPointer<const ResourceData*>(VT_BACKGROUNDBOXSELECTEDDATA);
    }
    const ResourceData* frontCrossData() const { return GetPointer<const ResourceData*>(VT_FRONTCROSSDATA); }
    const ResourceData* backGroundBoxDisabledData() const
    {
        return GetPointer<const ResourceData*>(VT_BACKGROUNDBOXDISABLEDDATA);
    }
    const ResourceData* frontCrossDisabledData() const
    {
        return GetPointer<const ResourceData*>(VT_FRONTCROSSDISABLEDDATA);
    }
    bool selectedState() const { return GetField<uint8_t>(VT_SELECTEDSTATE, 1) != 0; }
    bool displaystate() const { return GetField<uint8_t>(VT_DISPLAYSTATE, 1) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BACKGROUNDBOXDATA) &&
               verifier.VerifyTable(backGroundBoxData()) && VerifyOffset(verifier, VT_BACKGROUNDBOXSELECTEDDATA) &&
               verifier.VerifyTable(backGroundBoxSelectedData()) && VerifyOffset(verifier, VT_FRONTCROSSDATA) &&
               verifier.VerifyTable(frontCrossData()) && VerifyOffset(verifier, VT_BACKGROUNDBOXDISABLEDDATA) &&
               verifier.VerifyTable(backGroundBoxDisabledData()) && VerifyOffset(verifier, VT_FRONTCROSSDISABLEDDATA) &&
               verifier.VerifyTable(frontCrossDisabledData()) && VerifyField<uint8_t>(verifier, VT_SELECTEDSTATE) &&
               VerifyField<uint8_t>(verifier, VT_DISPLAYSTATE) && verifier.EndTable();
    }
};

struct CheckBoxOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(CheckBoxOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_backGroundBoxData(flatbuffers::Offset<ResourceData> backGroundBoxData)
    {
        fbb_.AddOffset(CheckBoxOptions::VT_BACKGROUNDBOXDATA, backGroundBoxData);
    }
    void add_backGroundBoxSelectedData(flatbuffers::Offset<ResourceData> backGroundBoxSelectedData)
    {
        fbb_.AddOffset(CheckBoxOptions::VT_BACKGROUNDBOXSELECTEDDATA, backGroundBoxSelectedData);
    }
    void add_frontCrossData(flatbuffers::Offset<ResourceData> frontCrossData)
    {
        fbb_.AddOffset(CheckBoxOptions::VT_FRONTCROSSDATA, frontCrossData);
    }
    void add_backGroundBoxDisabledData(flatbuffers::Offset<ResourceData> backGroundBoxDisabledData)
    {
        fbb_.AddOffset(CheckBoxOptions::VT_BACKGROUNDBOXDISABLEDDATA, backGroundBoxDisabledData);
    }
    void add_frontCrossDisabledData(flatbuffers::Offset<ResourceData> frontCrossDisabledData)
    {
        fbb_.AddOffset(CheckBoxOptions::VT_FRONTCROSSDISABLEDDATA, frontCrossDisabledData);
    }
    void add_selectedState(bool selectedState)
    {
        fbb_.AddElement<uint8_t>(CheckBoxOptions::VT_SELECTEDSTATE, static_cast<uint8_t>(selectedState), 1);
    }
    void add_displaystate(bool displaystate)
    {
        fbb_.AddElement<uint8_t>(CheckBoxOptions::VT_DISPLAYSTATE, static_cast<uint8_t>(displaystate), 1);
    }
    explicit CheckBoxOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    CheckBoxOptionsBuilder& operator=(const CheckBoxOptionsBuilder&);
    flatbuffers::Offset<CheckBoxOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<CheckBoxOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<CheckBoxOptions> CreateCheckBoxOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions            = 0,
    flatbuffers::Offset<ResourceData> backGroundBoxData         = 0,
    flatbuffers::Offset<ResourceData> backGroundBoxSelectedData = 0,
    flatbuffers::Offset<ResourceData> frontCrossData            = 0,
    flatbuffers::Offset<ResourceData> backGroundBoxDisabledData = 0,
    flatbuffers::Offset<ResourceData> frontCrossDisabledData    = 0,
    bool selectedState                                          = true,
    bool displaystate                                           = true)
{
    CheckBoxOptionsBuilder builder_(_fbb);
    builder_.add_frontCrossDisabledData(frontCrossDisabledData);
    builder_.add_backGroundBoxDisabledData(backGroundBoxDisabledData);
    builder_.add_frontCrossData(frontCrossData);
    builder_.add_backGroundBoxSelectedData(backGroundBoxSelectedData);
    builder_.add_backGroundBoxData(backGroundBoxData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_displaystate(displaystate);
    builder_.add_selectedState(selectedState);
    return builder_.Finish();
}

struct RadioButtonOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS             = 4,
        VT_BACKGROUNDBOXDATA         = 6,
        VT_BACKGROUNDBOXSELECTEDDATA = 8,
        VT_FRONTCROSSDATA            = 10,
        VT_BACKGROUNDBOXDISABLEDDATA = 12,
        VT_FRONTCROSSDISABLEDDATA    = 14,
        VT_SELECTEDSTATE             = 16,
        VT_DISPLAYSTATE              = 18
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* backGroundBoxData() const { return GetPointer<const ResourceData*>(VT_BACKGROUNDBOXDATA); }
    const ResourceData* backGroundBoxSelectedData() const
    {
        return GetPointer<const ResourceData*>(VT_BACKGROUNDBOXSELECTEDDATA);
    }
    const ResourceData* frontCrossData() const { return GetPointer<const ResourceData*>(VT_FRONTCROSSDATA); }
    const ResourceData* backGroundBoxDisabledData() const
    {
        return GetPointer<const ResourceData*>(VT_BACKGROUNDBOXDISABLEDDATA);
    }
    const ResourceData* frontCrossDisabledData() const
    {
        return GetPointer<const ResourceData*>(VT_FRONTCROSSDISABLEDDATA);
    }
    bool selectedState() const { return GetField<uint8_t>(VT_SELECTEDSTATE, 0) != 0; }
    bool displaystate() const { return GetField<uint8_t>(VT_DISPLAYSTATE, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BACKGROUNDBOXDATA) &&
               verifier.VerifyTable(backGroundBoxData()) && VerifyOffset(verifier, VT_BACKGROUNDBOXSELECTEDDATA) &&
               verifier.VerifyTable(backGroundBoxSelectedData()) && VerifyOffset(verifier, VT_FRONTCROSSDATA) &&
               verifier.VerifyTable(frontCrossData()) && VerifyOffset(verifier, VT_BACKGROUNDBOXDISABLEDDATA) &&
               verifier.VerifyTable(backGroundBoxDisabledData()) && VerifyOffset(verifier, VT_FRONTCROSSDISABLEDDATA) &&
               verifier.VerifyTable(frontCrossDisabledData()) && VerifyField<uint8_t>(verifier, VT_SELECTEDSTATE) &&
               VerifyField<uint8_t>(verifier, VT_DISPLAYSTATE) && verifier.EndTable();
    }
};

struct RadioButtonOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(RadioButtonOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_backGroundBoxData(flatbuffers::Offset<ResourceData> backGroundBoxData)
    {
        fbb_.AddOffset(RadioButtonOptions::VT_BACKGROUNDBOXDATA, backGroundBoxData);
    }
    void add_backGroundBoxSelectedData(flatbuffers::Offset<ResourceData> backGroundBoxSelectedData)
    {
        fbb_.AddOffset(RadioButtonOptions::VT_BACKGROUNDBOXSELECTEDDATA, backGroundBoxSelectedData);
    }
    void add_frontCrossData(flatbuffers::Offset<ResourceData> frontCrossData)
    {
        fbb_.AddOffset(RadioButtonOptions::VT_FRONTCROSSDATA, frontCrossData);
    }
    void add_backGroundBoxDisabledData(flatbuffers::Offset<ResourceData> backGroundBoxDisabledData)
    {
        fbb_.AddOffset(RadioButtonOptions::VT_BACKGROUNDBOXDISABLEDDATA, backGroundBoxDisabledData);
    }
    void add_frontCrossDisabledData(flatbuffers::Offset<ResourceData> frontCrossDisabledData)
    {
        fbb_.AddOffset(RadioButtonOptions::VT_FRONTCROSSDISABLEDDATA, frontCrossDisabledData);
    }
    void add_selectedState(bool selectedState)
    {
        fbb_.AddElement<uint8_t>(RadioButtonOptions::VT_SELECTEDSTATE, static_cast<uint8_t>(selectedState), 0);
    }
    void add_displaystate(bool displaystate)
    {
        fbb_.AddElement<uint8_t>(RadioButtonOptions::VT_DISPLAYSTATE, static_cast<uint8_t>(displaystate), 0);
    }
    explicit RadioButtonOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    RadioButtonOptionsBuilder& operator=(const RadioButtonOptionsBuilder&);
    flatbuffers::Offset<RadioButtonOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<RadioButtonOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<RadioButtonOptions> CreateRadioButtonOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions            = 0,
    flatbuffers::Offset<ResourceData> backGroundBoxData         = 0,
    flatbuffers::Offset<ResourceData> backGroundBoxSelectedData = 0,
    flatbuffers::Offset<ResourceData> frontCrossData            = 0,
    flatbuffers::Offset<ResourceData> backGroundBoxDisabledData = 0,
    flatbuffers::Offset<ResourceData> frontCrossDisabledData    = 0,
    bool selectedState                                          = false,
    bool displaystate                                           = false)
{
    RadioButtonOptionsBuilder builder_(_fbb);
    builder_.add_frontCrossDisabledData(frontCrossDisabledData);
    builder_.add_backGroundBoxDisabledData(backGroundBoxDisabledData);
    builder_.add_frontCrossData(frontCrossData);
    builder_.add_backGroundBoxSelectedData(backGroundBoxSelectedData);
    builder_.add_backGroundBoxData(backGroundBoxData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_displaystate(displaystate);
    builder_.add_selectedState(selectedState);
    return builder_.Finish();
}

struct RadioButtonGroupOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS      = 4,
        VT_ALLOWEDNOSELECTION = 6
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    bool allowedNoSelection() const { return GetField<uint8_t>(VT_ALLOWEDNOSELECTION, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyField<uint8_t>(verifier, VT_ALLOWEDNOSELECTION) &&
               verifier.EndTable();
    }
};

struct RadioButtonGroupOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(RadioButtonGroupOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_allowedNoSelection(bool allowedNoSelection)
    {
        fbb_.AddElement<uint8_t>(RadioButtonGroupOptions::VT_ALLOWEDNOSELECTION,
                                 static_cast<uint8_t>(allowedNoSelection), 0);
    }
    explicit RadioButtonGroupOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    RadioButtonGroupOptionsBuilder& operator=(const RadioButtonGroupOptionsBuilder&);
    flatbuffers::Offset<RadioButtonGroupOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<RadioButtonGroupOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<RadioButtonGroupOptions> CreateRadioButtonGroupOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    bool allowedNoSelection                          = false)
{
    RadioButtonGroupOptionsBuilder builder_(_fbb);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_allowedNoSelection(allowedNoSelection);
    return builder_.Finish();
}

struct ImageViewOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS = 4,
        VT_FILENAMEDATA  = 6,
        VT_CAPINSETS     = 8,
        VT_SCALE9SIZE    = 10,
        VT_SCALE9ENABLED = 12
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* fileNameData() const { return GetPointer<const ResourceData*>(VT_FILENAMEDATA); }
    const CapInsets* capInsets() const { return GetStruct<const CapInsets*>(VT_CAPINSETS); }
    const FlatSize* scale9Size() const { return GetStruct<const FlatSize*>(VT_SCALE9SIZE); }
    bool scale9Enabled() const { return GetField<uint8_t>(VT_SCALE9ENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_FILENAMEDATA) &&
               verifier.VerifyTable(fileNameData()) && VerifyField<CapInsets>(verifier, VT_CAPINSETS) &&
               VerifyField<FlatSize>(verifier, VT_SCALE9SIZE) && VerifyField<uint8_t>(verifier, VT_SCALE9ENABLED) &&
               verifier.EndTable();
    }
};

struct ImageViewOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(ImageViewOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData)
    {
        fbb_.AddOffset(ImageViewOptions::VT_FILENAMEDATA, fileNameData);
    }
    void add_capInsets(const CapInsets* capInsets) { fbb_.AddStruct(ImageViewOptions::VT_CAPINSETS, capInsets); }
    void add_scale9Size(const FlatSize* scale9Size) { fbb_.AddStruct(ImageViewOptions::VT_SCALE9SIZE, scale9Size); }
    void add_scale9Enabled(bool scale9Enabled)
    {
        fbb_.AddElement<uint8_t>(ImageViewOptions::VT_SCALE9ENABLED, static_cast<uint8_t>(scale9Enabled), 0);
    }
    explicit ImageViewOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ImageViewOptionsBuilder& operator=(const ImageViewOptionsBuilder&);
    flatbuffers::Offset<ImageViewOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ImageViewOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ImageViewOptions> CreateImageViewOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    flatbuffers::Offset<ResourceData> fileNameData   = 0,
    const CapInsets* capInsets                       = 0,
    const FlatSize* scale9Size                       = 0,
    bool scale9Enabled                               = false)
{
    ImageViewOptionsBuilder builder_(_fbb);
    builder_.add_scale9Size(scale9Size);
    builder_.add_capInsets(capInsets);
    builder_.add_fileNameData(fileNameData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_scale9Enabled(scale9Enabled);
    return builder_.Finish();
}

struct TextAtlasOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS   = 4,
        VT_CHARMAPFILEDATA = 6,
        VT_STRINGVALUE     = 8,
        VT_STARTCHARMAP    = 10,
        VT_ITEMWIDTH       = 12,
        VT_ITEMHEIGHT      = 14
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* charMapFileData() const { return GetPointer<const ResourceData*>(VT_CHARMAPFILEDATA); }
    const flatbuffers::String* stringValue() const { return GetPointer<const flatbuffers::String*>(VT_STRINGVALUE); }
    const flatbuffers::String* startCharMap() const { return GetPointer<const flatbuffers::String*>(VT_STARTCHARMAP); }
    int32_t itemWidth() const { return GetField<int32_t>(VT_ITEMWIDTH, 0); }
    int32_t itemHeight() const { return GetField<int32_t>(VT_ITEMHEIGHT, 0); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_CHARMAPFILEDATA) &&
               verifier.VerifyTable(charMapFileData()) && VerifyOffset(verifier, VT_STRINGVALUE) &&
               verifier.VerifyString(stringValue()) && VerifyOffset(verifier, VT_STARTCHARMAP) &&
               verifier.VerifyString(startCharMap()) && VerifyField<int32_t>(verifier, VT_ITEMWIDTH) &&
               VerifyField<int32_t>(verifier, VT_ITEMHEIGHT) && verifier.EndTable();
    }
};

struct TextAtlasOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(TextAtlasOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_charMapFileData(flatbuffers::Offset<ResourceData> charMapFileData)
    {
        fbb_.AddOffset(TextAtlasOptions::VT_CHARMAPFILEDATA, charMapFileData);
    }
    void add_stringValue(flatbuffers::Offset<flatbuffers::String> stringValue)
    {
        fbb_.AddOffset(TextAtlasOptions::VT_STRINGVALUE, stringValue);
    }
    void add_startCharMap(flatbuffers::Offset<flatbuffers::String> startCharMap)
    {
        fbb_.AddOffset(TextAtlasOptions::VT_STARTCHARMAP, startCharMap);
    }
    void add_itemWidth(int32_t itemWidth) { fbb_.AddElement<int32_t>(TextAtlasOptions::VT_ITEMWIDTH, itemWidth, 0); }
    void add_itemHeight(int32_t itemHeight)
    {
        fbb_.AddElement<int32_t>(TextAtlasOptions::VT_ITEMHEIGHT, itemHeight, 0);
    }
    explicit TextAtlasOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TextAtlasOptionsBuilder& operator=(const TextAtlasOptionsBuilder&);
    flatbuffers::Offset<TextAtlasOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TextAtlasOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<TextAtlasOptions> CreateTextAtlasOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions      = 0,
    flatbuffers::Offset<ResourceData> charMapFileData     = 0,
    flatbuffers::Offset<flatbuffers::String> stringValue  = 0,
    flatbuffers::Offset<flatbuffers::String> startCharMap = 0,
    int32_t itemWidth                                     = 0,
    int32_t itemHeight                                    = 0)
{
    TextAtlasOptionsBuilder builder_(_fbb);
    builder_.add_itemHeight(itemHeight);
    builder_.add_itemWidth(itemWidth);
    builder_.add_startCharMap(startCharMap);
    builder_.add_stringValue(stringValue);
    builder_.add_charMapFileData(charMapFileData);
    builder_.add_widgetOptions(widgetOptions);
    return builder_.Finish();
}

inline flatbuffers::Offset<TextAtlasOptions> CreateTextAtlasOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions  = 0,
    flatbuffers::Offset<ResourceData> charMapFileData = 0,
    const char* stringValue                           = nullptr,
    const char* startCharMap                          = nullptr,
    int32_t itemWidth                                 = 0,
    int32_t itemHeight                                = 0)
{
    auto stringValue__  = stringValue ? _fbb.CreateString(stringValue) : 0;
    auto startCharMap__ = startCharMap ? _fbb.CreateString(startCharMap) : 0;
    return flatbuffers::CreateTextAtlasOptions(_fbb, widgetOptions, charMapFileData, stringValue__, startCharMap__,
                                               itemWidth, itemHeight);
}

struct TextBMFontOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS = 4,
        VT_FILENAMEDATA  = 6,
        VT_TEXT          = 8,
        VT_ISLOCALIZED   = 10
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* fileNameData() const { return GetPointer<const ResourceData*>(VT_FILENAMEDATA); }
    const flatbuffers::String* text() const { return GetPointer<const flatbuffers::String*>(VT_TEXT); }
    bool isLocalized() const { return GetField<uint8_t>(VT_ISLOCALIZED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_FILENAMEDATA) &&
               verifier.VerifyTable(fileNameData()) && VerifyOffset(verifier, VT_TEXT) &&
               verifier.VerifyString(text()) && VerifyField<uint8_t>(verifier, VT_ISLOCALIZED) && verifier.EndTable();
    }
};

struct TextBMFontOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(TextBMFontOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData)
    {
        fbb_.AddOffset(TextBMFontOptions::VT_FILENAMEDATA, fileNameData);
    }
    void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(TextBMFontOptions::VT_TEXT, text); }
    void add_isLocalized(bool isLocalized)
    {
        fbb_.AddElement<uint8_t>(TextBMFontOptions::VT_ISLOCALIZED, static_cast<uint8_t>(isLocalized), 0);
    }
    explicit TextBMFontOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TextBMFontOptionsBuilder& operator=(const TextBMFontOptionsBuilder&);
    flatbuffers::Offset<TextBMFontOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TextBMFontOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<TextBMFontOptions> CreateTextBMFontOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    flatbuffers::Offset<ResourceData> fileNameData   = 0,
    flatbuffers::Offset<flatbuffers::String> text    = 0,
    bool isLocalized                                 = false)
{
    TextBMFontOptionsBuilder builder_(_fbb);
    builder_.add_text(text);
    builder_.add_fileNameData(fileNameData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_isLocalized(isLocalized);
    return builder_.Finish();
}

inline flatbuffers::Offset<TextBMFontOptions> CreateTextBMFontOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    flatbuffers::Offset<ResourceData> fileNameData   = 0,
    const char* text                                 = nullptr,
    bool isLocalized                                 = false)
{
    auto text__ = text ? _fbb.CreateString(text) : 0;
    return flatbuffers::CreateTextBMFontOptions(_fbb, widgetOptions, fileNameData, text__, isLocalized);
}

struct TextOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS        = 4,
        VT_FONTRESOURCE         = 6,
        VT_FONTNAME             = 8,
        VT_FONTSIZE             = 10,
        VT_TEXT                 = 12,
        VT_AREAWIDTH            = 14,
        VT_AREAHEIGHT           = 16,
        VT_HALIGNMENT           = 18,
        VT_VALIGNMENT           = 20,
        VT_TOUCHSCALEENABLE     = 22,
        VT_ISCUSTOMSIZE         = 24,
        VT_OUTLINEENABLED       = 26,
        VT_OUTLINECOLOR         = 28,
        VT_OUTLINESIZE          = 30,
        VT_SHADOWENABLED        = 32,
        VT_SHADOWCOLOR          = 34,
        VT_SHADOWOFFSETX        = 36,
        VT_SHADOWOFFSETY        = 38,
        VT_SHADOWBLURRADIUS     = 40,
        VT_ISLOCALIZED          = 42,
        VT_GLOWENABLED          = 44,
        VT_GLOWCOLOR            = 46,
        VT_BOLDENABLED          = 48,
        VT_UNDERLINEENABLED     = 50,
        VT_ITALICSENABLED       = 52,
        VT_STRIKETHROUGHENABLED = 54
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* fontResource() const { return GetPointer<const ResourceData*>(VT_FONTRESOURCE); }
    const flatbuffers::String* fontName() const { return GetPointer<const flatbuffers::String*>(VT_FONTNAME); }
    int32_t fontSize() const { return GetField<int32_t>(VT_FONTSIZE, 0); }
    const flatbuffers::String* text() const { return GetPointer<const flatbuffers::String*>(VT_TEXT); }
    int32_t areaWidth() const { return GetField<int32_t>(VT_AREAWIDTH, 0); }
    int32_t areaHeight() const { return GetField<int32_t>(VT_AREAHEIGHT, 0); }
    int32_t hAlignment() const { return GetField<int32_t>(VT_HALIGNMENT, 0); }
    int32_t vAlignment() const { return GetField<int32_t>(VT_VALIGNMENT, 0); }
    bool touchScaleEnable() const { return GetField<uint8_t>(VT_TOUCHSCALEENABLE, 0) != 0; }
    bool isCustomSize() const { return GetField<uint8_t>(VT_ISCUSTOMSIZE, 0) != 0; }
    bool outlineEnabled() const { return GetField<uint8_t>(VT_OUTLINEENABLED, 0) != 0; }
    const Color* outlineColor() const { return GetStruct<const Color*>(VT_OUTLINECOLOR); }
    int32_t outlineSize() const { return GetField<int32_t>(VT_OUTLINESIZE, 1); }
    bool shadowEnabled() const { return GetField<uint8_t>(VT_SHADOWENABLED, 0) != 0; }
    const Color* shadowColor() const { return GetStruct<const Color*>(VT_SHADOWCOLOR); }
    float shadowOffsetX() const { return GetField<float>(VT_SHADOWOFFSETX, 2.0f); }
    float shadowOffsetY() const { return GetField<float>(VT_SHADOWOFFSETY, -2.0f); }
    int32_t shadowBlurRadius() const { return GetField<int32_t>(VT_SHADOWBLURRADIUS, 0); }
    bool isLocalized() const { return GetField<uint8_t>(VT_ISLOCALIZED, 0) != 0; }
    bool glowEnabled() const { return GetField<uint8_t>(VT_GLOWENABLED, 0) != 0; }
    const Color* glowColor() const { return GetStruct<const Color*>(VT_GLOWCOLOR); }
    bool boldEnabled() const { return GetField<uint8_t>(VT_BOLDENABLED, 0) != 0; }
    bool underlineEnabled() const { return GetField<uint8_t>(VT_UNDERLINEENABLED, 0) != 0; }
    bool italicsEnabled() const { return GetField<uint8_t>(VT_ITALICSENABLED, 0) != 0; }
    bool strikethroughEnabled() const { return GetField<uint8_t>(VT_STRIKETHROUGHENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_FONTRESOURCE) &&
               verifier.VerifyTable(fontResource()) && VerifyOffset(verifier, VT_FONTNAME) &&
               verifier.VerifyString(fontName()) && VerifyField<int32_t>(verifier, VT_FONTSIZE) &&
               VerifyOffset(verifier, VT_TEXT) && verifier.VerifyString(text()) &&
               VerifyField<int32_t>(verifier, VT_AREAWIDTH) && VerifyField<int32_t>(verifier, VT_AREAHEIGHT) &&
               VerifyField<int32_t>(verifier, VT_HALIGNMENT) && VerifyField<int32_t>(verifier, VT_VALIGNMENT) &&
               VerifyField<uint8_t>(verifier, VT_TOUCHSCALEENABLE) && VerifyField<uint8_t>(verifier, VT_ISCUSTOMSIZE) &&
               VerifyField<uint8_t>(verifier, VT_OUTLINEENABLED) && VerifyField<Color>(verifier, VT_OUTLINECOLOR) &&
               VerifyField<int32_t>(verifier, VT_OUTLINESIZE) && VerifyField<uint8_t>(verifier, VT_SHADOWENABLED) &&
               VerifyField<Color>(verifier, VT_SHADOWCOLOR) && VerifyField<float>(verifier, VT_SHADOWOFFSETX) &&
               VerifyField<float>(verifier, VT_SHADOWOFFSETY) && VerifyField<int32_t>(verifier, VT_SHADOWBLURRADIUS) &&
               VerifyField<uint8_t>(verifier, VT_ISLOCALIZED) && VerifyField<uint8_t>(verifier, VT_GLOWENABLED) &&
               VerifyField<Color>(verifier, VT_GLOWCOLOR) && VerifyField<uint8_t>(verifier, VT_BOLDENABLED) &&
               VerifyField<uint8_t>(verifier, VT_UNDERLINEENABLED) &&
               VerifyField<uint8_t>(verifier, VT_ITALICSENABLED) &&
               VerifyField<uint8_t>(verifier, VT_STRIKETHROUGHENABLED) && verifier.EndTable();
    }
};

struct TextOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(TextOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_fontResource(flatbuffers::Offset<ResourceData> fontResource)
    {
        fbb_.AddOffset(TextOptions::VT_FONTRESOURCE, fontResource);
    }
    void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName)
    {
        fbb_.AddOffset(TextOptions::VT_FONTNAME, fontName);
    }
    void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(TextOptions::VT_FONTSIZE, fontSize, 0); }
    void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(TextOptions::VT_TEXT, text); }
    void add_areaWidth(int32_t areaWidth) { fbb_.AddElement<int32_t>(TextOptions::VT_AREAWIDTH, areaWidth, 0); }
    void add_areaHeight(int32_t areaHeight) { fbb_.AddElement<int32_t>(TextOptions::VT_AREAHEIGHT, areaHeight, 0); }
    void add_hAlignment(int32_t hAlignment) { fbb_.AddElement<int32_t>(TextOptions::VT_HALIGNMENT, hAlignment, 0); }
    void add_vAlignment(int32_t vAlignment) { fbb_.AddElement<int32_t>(TextOptions::VT_VALIGNMENT, vAlignment, 0); }
    void add_touchScaleEnable(bool touchScaleEnable)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_TOUCHSCALEENABLE, static_cast<uint8_t>(touchScaleEnable), 0);
    }
    void add_isCustomSize(bool isCustomSize)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_ISCUSTOMSIZE, static_cast<uint8_t>(isCustomSize), 0);
    }
    void add_outlineEnabled(bool outlineEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_OUTLINEENABLED, static_cast<uint8_t>(outlineEnabled), 0);
    }
    void add_outlineColor(const Color* outlineColor) { fbb_.AddStruct(TextOptions::VT_OUTLINECOLOR, outlineColor); }
    void add_outlineSize(int32_t outlineSize) { fbb_.AddElement<int32_t>(TextOptions::VT_OUTLINESIZE, outlineSize, 1); }
    void add_shadowEnabled(bool shadowEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_SHADOWENABLED, static_cast<uint8_t>(shadowEnabled), 0);
    }
    void add_shadowColor(const Color* shadowColor) { fbb_.AddStruct(TextOptions::VT_SHADOWCOLOR, shadowColor); }
    void add_shadowOffsetX(float shadowOffsetX)
    {
        fbb_.AddElement<float>(TextOptions::VT_SHADOWOFFSETX, shadowOffsetX, 2.0f);
    }
    void add_shadowOffsetY(float shadowOffsetY)
    {
        fbb_.AddElement<float>(TextOptions::VT_SHADOWOFFSETY, shadowOffsetY, -2.0f);
    }
    void add_shadowBlurRadius(int32_t shadowBlurRadius)
    {
        fbb_.AddElement<int32_t>(TextOptions::VT_SHADOWBLURRADIUS, shadowBlurRadius, 0);
    }
    void add_isLocalized(bool isLocalized)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_ISLOCALIZED, static_cast<uint8_t>(isLocalized), 0);
    }
    void add_glowEnabled(bool glowEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_GLOWENABLED, static_cast<uint8_t>(glowEnabled), 0);
    }
    void add_glowColor(const Color* glowColor) { fbb_.AddStruct(TextOptions::VT_GLOWCOLOR, glowColor); }
    void add_boldEnabled(bool boldEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_BOLDENABLED, static_cast<uint8_t>(boldEnabled), 0);
    }
    void add_underlineEnabled(bool underlineEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_UNDERLINEENABLED, static_cast<uint8_t>(underlineEnabled), 0);
    }
    void add_italicsEnabled(bool italicsEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_ITALICSENABLED, static_cast<uint8_t>(italicsEnabled), 0);
    }
    void add_strikethroughEnabled(bool strikethroughEnabled)
    {
        fbb_.AddElement<uint8_t>(TextOptions::VT_STRIKETHROUGHENABLED, static_cast<uint8_t>(strikethroughEnabled), 0);
    }
    explicit TextOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TextOptionsBuilder& operator=(const TextOptionsBuilder&);
    flatbuffers::Offset<TextOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TextOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<TextOptions> CreateTextOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                          flatbuffers::Offset<WidgetOptions> widgetOptions  = 0,
                                                          flatbuffers::Offset<ResourceData> fontResource    = 0,
                                                          flatbuffers::Offset<flatbuffers::String> fontName = 0,
                                                          int32_t fontSize                                  = 0,
                                                          flatbuffers::Offset<flatbuffers::String> text     = 0,
                                                          int32_t areaWidth                                 = 0,
                                                          int32_t areaHeight                                = 0,
                                                          int32_t hAlignment                                = 0,
                                                          int32_t vAlignment                                = 0,
                                                          bool touchScaleEnable                             = false,
                                                          bool isCustomSize                                 = false,
                                                          bool outlineEnabled                               = false,
                                                          const Color* outlineColor                         = 0,
                                                          int32_t outlineSize                               = 1,
                                                          bool shadowEnabled                                = false,
                                                          const Color* shadowColor                          = 0,
                                                          float shadowOffsetX                               = 2.0f,
                                                          float shadowOffsetY                               = -2.0f,
                                                          int32_t shadowBlurRadius                          = 0,
                                                          bool isLocalized                                  = false,
                                                          bool glowEnabled                                  = false,
                                                          const Color* glowColor                            = 0,
                                                          bool boldEnabled                                  = false,
                                                          bool underlineEnabled                             = false,
                                                          bool italicsEnabled                               = false,
                                                          bool strikethroughEnabled                         = false)
{
    TextOptionsBuilder builder_(_fbb);
    builder_.add_glowColor(glowColor);
    builder_.add_shadowBlurRadius(shadowBlurRadius);
    builder_.add_shadowOffsetY(shadowOffsetY);
    builder_.add_shadowOffsetX(shadowOffsetX);
    builder_.add_shadowColor(shadowColor);
    builder_.add_outlineSize(outlineSize);
    builder_.add_outlineColor(outlineColor);
    builder_.add_vAlignment(vAlignment);
    builder_.add_hAlignment(hAlignment);
    builder_.add_areaHeight(areaHeight);
    builder_.add_areaWidth(areaWidth);
    builder_.add_text(text);
    builder_.add_fontSize(fontSize);
    builder_.add_fontName(fontName);
    builder_.add_fontResource(fontResource);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_strikethroughEnabled(strikethroughEnabled);
    builder_.add_italicsEnabled(italicsEnabled);
    builder_.add_underlineEnabled(underlineEnabled);
    builder_.add_boldEnabled(boldEnabled);
    builder_.add_glowEnabled(glowEnabled);
    builder_.add_isLocalized(isLocalized);
    builder_.add_shadowEnabled(shadowEnabled);
    builder_.add_outlineEnabled(outlineEnabled);
    builder_.add_isCustomSize(isCustomSize);
    builder_.add_touchScaleEnable(touchScaleEnable);
    return builder_.Finish();
}

inline flatbuffers::Offset<TextOptions> CreateTextOptionsDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                                flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
                                                                flatbuffers::Offset<ResourceData> fontResource   = 0,
                                                                const char* fontName      = nullptr,
                                                                int32_t fontSize          = 0,
                                                                const char* text          = nullptr,
                                                                int32_t areaWidth         = 0,
                                                                int32_t areaHeight        = 0,
                                                                int32_t hAlignment        = 0,
                                                                int32_t vAlignment        = 0,
                                                                bool touchScaleEnable     = false,
                                                                bool isCustomSize         = false,
                                                                bool outlineEnabled       = false,
                                                                const Color* outlineColor = 0,
                                                                int32_t outlineSize       = 1,
                                                                bool shadowEnabled        = false,
                                                                const Color* shadowColor  = 0,
                                                                float shadowOffsetX       = 2.0f,
                                                                float shadowOffsetY       = -2.0f,
                                                                int32_t shadowBlurRadius  = 0,
                                                                bool isLocalized          = false,
                                                                bool glowEnabled          = false,
                                                                const Color* glowColor    = 0,
                                                                bool boldEnabled          = false,
                                                                bool underlineEnabled     = false,
                                                                bool italicsEnabled       = false,
                                                                bool strikethroughEnabled = false)
{
    auto fontName__ = fontName ? _fbb.CreateString(fontName) : 0;
    auto text__     = text ? _fbb.CreateString(text) : 0;
    return flatbuffers::CreateTextOptions(
        _fbb, widgetOptions, fontResource, fontName__, fontSize, text__, areaWidth, areaHeight, hAlignment, vAlignment,
        touchScaleEnable, isCustomSize, outlineEnabled, outlineColor, outlineSize, shadowEnabled, shadowColor,
        shadowOffsetX, shadowOffsetY, shadowBlurRadius, isLocalized, glowEnabled, glowColor, boldEnabled,
        underlineEnabled, italicsEnabled, strikethroughEnabled);
}

struct RichTextOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS = 4,
        VT_XMLDEFINITION = 6
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const flatbuffers::String* xmlDefinition() const
    {
        return GetPointer<const flatbuffers::String*>(VT_XMLDEFINITION);
    }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_XMLDEFINITION) &&
               verifier.VerifyString(xmlDefinition()) && verifier.EndTable();
    }
};

struct RichTextOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(RichTextOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_xmlDefinition(flatbuffers::Offset<flatbuffers::String> xmlDefinition)
    {
        fbb_.AddOffset(RichTextOptions::VT_XMLDEFINITION, xmlDefinition);
    }
    explicit RichTextOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    RichTextOptionsBuilder& operator=(const RichTextOptionsBuilder&);
    flatbuffers::Offset<RichTextOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<RichTextOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<RichTextOptions> CreateRichTextOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions       = 0,
    flatbuffers::Offset<flatbuffers::String> xmlDefinition = 0)
{
    RichTextOptionsBuilder builder_(_fbb);
    builder_.add_xmlDefinition(xmlDefinition);
    builder_.add_widgetOptions(widgetOptions);
    return builder_.Finish();
}

inline flatbuffers::Offset<RichTextOptions> CreateRichTextOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    const char* xmlDefinition                        = nullptr)
{
    auto xmlDefinition__ = xmlDefinition ? _fbb.CreateString(xmlDefinition) : 0;
    return flatbuffers::CreateRichTextOptions(_fbb, widgetOptions, xmlDefinition__);
}

struct TextFieldOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS     = 4,
        VT_FONTRESOURCE      = 6,
        VT_FONTNAME          = 8,
        VT_FONTSIZE          = 10,
        VT_TEXT              = 12,
        VT_PLACEHOLDER       = 14,
        VT_PASSWORDENABLED   = 16,
        VT_PASSWORDSTYLETEXT = 18,
        VT_MAXLENGTHENABLED  = 20,
        VT_MAXLENGTH         = 22,
        VT_AREAWIDTH         = 24,
        VT_AREAHEIGHT        = 26,
        VT_ISCUSTOMSIZE      = 28,
        VT_ISLOCALIZED       = 30
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* fontResource() const { return GetPointer<const ResourceData*>(VT_FONTRESOURCE); }
    const flatbuffers::String* fontName() const { return GetPointer<const flatbuffers::String*>(VT_FONTNAME); }
    int32_t fontSize() const { return GetField<int32_t>(VT_FONTSIZE, 0); }
    const flatbuffers::String* text() const { return GetPointer<const flatbuffers::String*>(VT_TEXT); }
    const flatbuffers::String* placeHolder() const { return GetPointer<const flatbuffers::String*>(VT_PLACEHOLDER); }
    bool passwordEnabled() const { return GetField<uint8_t>(VT_PASSWORDENABLED, 0) != 0; }
    const flatbuffers::String* passwordStyleText() const
    {
        return GetPointer<const flatbuffers::String*>(VT_PASSWORDSTYLETEXT);
    }
    bool maxLengthEnabled() const { return GetField<uint8_t>(VT_MAXLENGTHENABLED, 0) != 0; }
    int32_t maxLength() const { return GetField<int32_t>(VT_MAXLENGTH, 0); }
    int32_t areaWidth() const { return GetField<int32_t>(VT_AREAWIDTH, 0); }
    int32_t areaHeight() const { return GetField<int32_t>(VT_AREAHEIGHT, 0); }
    bool isCustomSize() const { return GetField<uint8_t>(VT_ISCUSTOMSIZE, 0) != 0; }
    bool isLocalized() const { return GetField<uint8_t>(VT_ISLOCALIZED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_FONTRESOURCE) &&
               verifier.VerifyTable(fontResource()) && VerifyOffset(verifier, VT_FONTNAME) &&
               verifier.VerifyString(fontName()) && VerifyField<int32_t>(verifier, VT_FONTSIZE) &&
               VerifyOffset(verifier, VT_TEXT) && verifier.VerifyString(text()) &&
               VerifyOffset(verifier, VT_PLACEHOLDER) && verifier.VerifyString(placeHolder()) &&
               VerifyField<uint8_t>(verifier, VT_PASSWORDENABLED) && VerifyOffset(verifier, VT_PASSWORDSTYLETEXT) &&
               verifier.VerifyString(passwordStyleText()) && VerifyField<uint8_t>(verifier, VT_MAXLENGTHENABLED) &&
               VerifyField<int32_t>(verifier, VT_MAXLENGTH) && VerifyField<int32_t>(verifier, VT_AREAWIDTH) &&
               VerifyField<int32_t>(verifier, VT_AREAHEIGHT) && VerifyField<uint8_t>(verifier, VT_ISCUSTOMSIZE) &&
               VerifyField<uint8_t>(verifier, VT_ISLOCALIZED) && verifier.EndTable();
    }
};

struct TextFieldOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(TextFieldOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_fontResource(flatbuffers::Offset<ResourceData> fontResource)
    {
        fbb_.AddOffset(TextFieldOptions::VT_FONTRESOURCE, fontResource);
    }
    void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName)
    {
        fbb_.AddOffset(TextFieldOptions::VT_FONTNAME, fontName);
    }
    void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(TextFieldOptions::VT_FONTSIZE, fontSize, 0); }
    void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(TextFieldOptions::VT_TEXT, text); }
    void add_placeHolder(flatbuffers::Offset<flatbuffers::String> placeHolder)
    {
        fbb_.AddOffset(TextFieldOptions::VT_PLACEHOLDER, placeHolder);
    }
    void add_passwordEnabled(bool passwordEnabled)
    {
        fbb_.AddElement<uint8_t>(TextFieldOptions::VT_PASSWORDENABLED, static_cast<uint8_t>(passwordEnabled), 0);
    }
    void add_passwordStyleText(flatbuffers::Offset<flatbuffers::String> passwordStyleText)
    {
        fbb_.AddOffset(TextFieldOptions::VT_PASSWORDSTYLETEXT, passwordStyleText);
    }
    void add_maxLengthEnabled(bool maxLengthEnabled)
    {
        fbb_.AddElement<uint8_t>(TextFieldOptions::VT_MAXLENGTHENABLED, static_cast<uint8_t>(maxLengthEnabled), 0);
    }
    void add_maxLength(int32_t maxLength) { fbb_.AddElement<int32_t>(TextFieldOptions::VT_MAXLENGTH, maxLength, 0); }
    void add_areaWidth(int32_t areaWidth) { fbb_.AddElement<int32_t>(TextFieldOptions::VT_AREAWIDTH, areaWidth, 0); }
    void add_areaHeight(int32_t areaHeight)
    {
        fbb_.AddElement<int32_t>(TextFieldOptions::VT_AREAHEIGHT, areaHeight, 0);
    }
    void add_isCustomSize(bool isCustomSize)
    {
        fbb_.AddElement<uint8_t>(TextFieldOptions::VT_ISCUSTOMSIZE, static_cast<uint8_t>(isCustomSize), 0);
    }
    void add_isLocalized(bool isLocalized)
    {
        fbb_.AddElement<uint8_t>(TextFieldOptions::VT_ISLOCALIZED, static_cast<uint8_t>(isLocalized), 0);
    }
    explicit TextFieldOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TextFieldOptionsBuilder& operator=(const TextFieldOptionsBuilder&);
    flatbuffers::Offset<TextFieldOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TextFieldOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<TextFieldOptions> CreateTextFieldOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions           = 0,
    flatbuffers::Offset<ResourceData> fontResource             = 0,
    flatbuffers::Offset<flatbuffers::String> fontName          = 0,
    int32_t fontSize                                           = 0,
    flatbuffers::Offset<flatbuffers::String> text              = 0,
    flatbuffers::Offset<flatbuffers::String> placeHolder       = 0,
    bool passwordEnabled                                       = false,
    flatbuffers::Offset<flatbuffers::String> passwordStyleText = 0,
    bool maxLengthEnabled                                      = false,
    int32_t maxLength                                          = 0,
    int32_t areaWidth                                          = 0,
    int32_t areaHeight                                         = 0,
    bool isCustomSize                                          = false,
    bool isLocalized                                           = false)
{
    TextFieldOptionsBuilder builder_(_fbb);
    builder_.add_areaHeight(areaHeight);
    builder_.add_areaWidth(areaWidth);
    builder_.add_maxLength(maxLength);
    builder_.add_passwordStyleText(passwordStyleText);
    builder_.add_placeHolder(placeHolder);
    builder_.add_text(text);
    builder_.add_fontSize(fontSize);
    builder_.add_fontName(fontName);
    builder_.add_fontResource(fontResource);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_isLocalized(isLocalized);
    builder_.add_isCustomSize(isCustomSize);
    builder_.add_maxLengthEnabled(maxLengthEnabled);
    builder_.add_passwordEnabled(passwordEnabled);
    return builder_.Finish();
}

inline flatbuffers::Offset<TextFieldOptions> CreateTextFieldOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    flatbuffers::Offset<ResourceData> fontResource   = 0,
    const char* fontName                             = nullptr,
    int32_t fontSize                                 = 0,
    const char* text                                 = nullptr,
    const char* placeHolder                          = nullptr,
    bool passwordEnabled                             = false,
    const char* passwordStyleText                    = nullptr,
    bool maxLengthEnabled                            = false,
    int32_t maxLength                                = 0,
    int32_t areaWidth                                = 0,
    int32_t areaHeight                               = 0,
    bool isCustomSize                                = false,
    bool isLocalized                                 = false)
{
    auto fontName__          = fontName ? _fbb.CreateString(fontName) : 0;
    auto text__              = text ? _fbb.CreateString(text) : 0;
    auto placeHolder__       = placeHolder ? _fbb.CreateString(placeHolder) : 0;
    auto passwordStyleText__ = passwordStyleText ? _fbb.CreateString(passwordStyleText) : 0;
    return flatbuffers::CreateTextFieldOptions(_fbb, widgetOptions, fontResource, fontName__, fontSize, text__,
                                               placeHolder__, passwordEnabled, passwordStyleText__, maxLengthEnabled,
                                               maxLength, areaWidth, areaHeight, isCustomSize, isLocalized);
}

struct LoadingBarOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS = 4,
        VT_TEXTUREDATA   = 6,
        VT_PERCENT       = 8,
        VT_DIRECTION     = 10
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* textureData() const { return GetPointer<const ResourceData*>(VT_TEXTUREDATA); }
    int32_t percent() const { return GetField<int32_t>(VT_PERCENT, 80); }
    int32_t direction() const { return GetField<int32_t>(VT_DIRECTION, 0); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_TEXTUREDATA) &&
               verifier.VerifyTable(textureData()) && VerifyField<int32_t>(verifier, VT_PERCENT) &&
               VerifyField<int32_t>(verifier, VT_DIRECTION) && verifier.EndTable();
    }
};

struct LoadingBarOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(LoadingBarOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_textureData(flatbuffers::Offset<ResourceData> textureData)
    {
        fbb_.AddOffset(LoadingBarOptions::VT_TEXTUREDATA, textureData);
    }
    void add_percent(int32_t percent) { fbb_.AddElement<int32_t>(LoadingBarOptions::VT_PERCENT, percent, 80); }
    void add_direction(int32_t direction) { fbb_.AddElement<int32_t>(LoadingBarOptions::VT_DIRECTION, direction, 0); }
    explicit LoadingBarOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    LoadingBarOptionsBuilder& operator=(const LoadingBarOptionsBuilder&);
    flatbuffers::Offset<LoadingBarOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<LoadingBarOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<LoadingBarOptions> CreateLoadingBarOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions = 0,
    flatbuffers::Offset<ResourceData> textureData    = 0,
    int32_t percent                                  = 80,
    int32_t direction                                = 0)
{
    LoadingBarOptionsBuilder builder_(_fbb);
    builder_.add_direction(direction);
    builder_.add_percent(percent);
    builder_.add_textureData(textureData);
    builder_.add_widgetOptions(widgetOptions);
    return builder_.Finish();
}

struct SliderOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS    = 4,
        VT_BARFILENAMEDATA  = 6,
        VT_BALLNORMALDATA   = 8,
        VT_BALLPRESSEDDATA  = 10,
        VT_BALLDISABLEDDATA = 12,
        VT_PROGRESSBARDATA  = 14,
        VT_PERCENT          = 16,
        VT_DISPLAYSTATE     = 18
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* barFileNameData() const { return GetPointer<const ResourceData*>(VT_BARFILENAMEDATA); }
    const ResourceData* ballNormalData() const { return GetPointer<const ResourceData*>(VT_BALLNORMALDATA); }
    const ResourceData* ballPressedData() const { return GetPointer<const ResourceData*>(VT_BALLPRESSEDDATA); }
    const ResourceData* ballDisabledData() const { return GetPointer<const ResourceData*>(VT_BALLDISABLEDDATA); }
    const ResourceData* progressBarData() const { return GetPointer<const ResourceData*>(VT_PROGRESSBARDATA); }
    int32_t percent() const { return GetField<int32_t>(VT_PERCENT, 50); }
    bool displaystate() const { return GetField<uint8_t>(VT_DISPLAYSTATE, 1) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BARFILENAMEDATA) &&
               verifier.VerifyTable(barFileNameData()) && VerifyOffset(verifier, VT_BALLNORMALDATA) &&
               verifier.VerifyTable(ballNormalData()) && VerifyOffset(verifier, VT_BALLPRESSEDDATA) &&
               verifier.VerifyTable(ballPressedData()) && VerifyOffset(verifier, VT_BALLDISABLEDDATA) &&
               verifier.VerifyTable(ballDisabledData()) && VerifyOffset(verifier, VT_PROGRESSBARDATA) &&
               verifier.VerifyTable(progressBarData()) && VerifyField<int32_t>(verifier, VT_PERCENT) &&
               VerifyField<uint8_t>(verifier, VT_DISPLAYSTATE) && verifier.EndTable();
    }
};

struct SliderOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(SliderOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_barFileNameData(flatbuffers::Offset<ResourceData> barFileNameData)
    {
        fbb_.AddOffset(SliderOptions::VT_BARFILENAMEDATA, barFileNameData);
    }
    void add_ballNormalData(flatbuffers::Offset<ResourceData> ballNormalData)
    {
        fbb_.AddOffset(SliderOptions::VT_BALLNORMALDATA, ballNormalData);
    }
    void add_ballPressedData(flatbuffers::Offset<ResourceData> ballPressedData)
    {
        fbb_.AddOffset(SliderOptions::VT_BALLPRESSEDDATA, ballPressedData);
    }
    void add_ballDisabledData(flatbuffers::Offset<ResourceData> ballDisabledData)
    {
        fbb_.AddOffset(SliderOptions::VT_BALLDISABLEDDATA, ballDisabledData);
    }
    void add_progressBarData(flatbuffers::Offset<ResourceData> progressBarData)
    {
        fbb_.AddOffset(SliderOptions::VT_PROGRESSBARDATA, progressBarData);
    }
    void add_percent(int32_t percent) { fbb_.AddElement<int32_t>(SliderOptions::VT_PERCENT, percent, 50); }
    void add_displaystate(bool displaystate)
    {
        fbb_.AddElement<uint8_t>(SliderOptions::VT_DISPLAYSTATE, static_cast<uint8_t>(displaystate), 1);
    }
    explicit SliderOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    SliderOptionsBuilder& operator=(const SliderOptionsBuilder&);
    flatbuffers::Offset<SliderOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<SliderOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<SliderOptions> CreateSliderOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                              flatbuffers::Offset<WidgetOptions> widgetOptions   = 0,
                                                              flatbuffers::Offset<ResourceData> barFileNameData  = 0,
                                                              flatbuffers::Offset<ResourceData> ballNormalData   = 0,
                                                              flatbuffers::Offset<ResourceData> ballPressedData  = 0,
                                                              flatbuffers::Offset<ResourceData> ballDisabledData = 0,
                                                              flatbuffers::Offset<ResourceData> progressBarData  = 0,
                                                              int32_t percent                                    = 50,
                                                              bool displaystate                                  = true)
{
    SliderOptionsBuilder builder_(_fbb);
    builder_.add_percent(percent);
    builder_.add_progressBarData(progressBarData);
    builder_.add_ballDisabledData(ballDisabledData);
    builder_.add_ballPressedData(ballPressedData);
    builder_.add_ballNormalData(ballNormalData);
    builder_.add_barFileNameData(barFileNameData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_displaystate(displaystate);
    return builder_.Finish();
}

struct PanelOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS           = 4,
        VT_BACKGROUNDIMAGEDATA     = 6,
        VT_CLIPENABLED             = 8,
        VT_BGCOLOR                 = 10,
        VT_BGSTARTCOLOR            = 12,
        VT_BGENDCOLOR              = 14,
        VT_COLORTYPE               = 16,
        VT_BGCOLOROPACITY          = 18,
        VT_COLORVECTOR             = 20,
        VT_CAPINSETS               = 22,
        VT_SCALE9SIZE              = 24,
        VT_BACKGROUNDSCALE9ENABLED = 26
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* backGroundImageData() const { return GetPointer<const ResourceData*>(VT_BACKGROUNDIMAGEDATA); }
    bool clipEnabled() const { return GetField<uint8_t>(VT_CLIPENABLED, 0) != 0; }
    const Color* bgColor() const { return GetStruct<const Color*>(VT_BGCOLOR); }
    const Color* bgStartColor() const { return GetStruct<const Color*>(VT_BGSTARTCOLOR); }
    const Color* bgEndColor() const { return GetStruct<const Color*>(VT_BGENDCOLOR); }
    int32_t colorType() const { return GetField<int32_t>(VT_COLORTYPE, 0); }
    uint8_t bgColorOpacity() const { return GetField<uint8_t>(VT_BGCOLOROPACITY, 255); }
    const ColorVector* colorVector() const { return GetStruct<const ColorVector*>(VT_COLORVECTOR); }
    const CapInsets* capInsets() const { return GetStruct<const CapInsets*>(VT_CAPINSETS); }
    const FlatSize* scale9Size() const { return GetStruct<const FlatSize*>(VT_SCALE9SIZE); }
    bool backGroundScale9Enabled() const { return GetField<uint8_t>(VT_BACKGROUNDSCALE9ENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BACKGROUNDIMAGEDATA) &&
               verifier.VerifyTable(backGroundImageData()) && VerifyField<uint8_t>(verifier, VT_CLIPENABLED) &&
               VerifyField<Color>(verifier, VT_BGCOLOR) && VerifyField<Color>(verifier, VT_BGSTARTCOLOR) &&
               VerifyField<Color>(verifier, VT_BGENDCOLOR) && VerifyField<int32_t>(verifier, VT_COLORTYPE) &&
               VerifyField<uint8_t>(verifier, VT_BGCOLOROPACITY) &&
               VerifyField<ColorVector>(verifier, VT_COLORVECTOR) && VerifyField<CapInsets>(verifier, VT_CAPINSETS) &&
               VerifyField<FlatSize>(verifier, VT_SCALE9SIZE) &&
               VerifyField<uint8_t>(verifier, VT_BACKGROUNDSCALE9ENABLED) && verifier.EndTable();
    }
};

struct PanelOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(PanelOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData)
    {
        fbb_.AddOffset(PanelOptions::VT_BACKGROUNDIMAGEDATA, backGroundImageData);
    }
    void add_clipEnabled(bool clipEnabled)
    {
        fbb_.AddElement<uint8_t>(PanelOptions::VT_CLIPENABLED, static_cast<uint8_t>(clipEnabled), 0);
    }
    void add_bgColor(const Color* bgColor) { fbb_.AddStruct(PanelOptions::VT_BGCOLOR, bgColor); }
    void add_bgStartColor(const Color* bgStartColor) { fbb_.AddStruct(PanelOptions::VT_BGSTARTCOLOR, bgStartColor); }
    void add_bgEndColor(const Color* bgEndColor) { fbb_.AddStruct(PanelOptions::VT_BGENDCOLOR, bgEndColor); }
    void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(PanelOptions::VT_COLORTYPE, colorType, 0); }
    void add_bgColorOpacity(uint8_t bgColorOpacity)
    {
        fbb_.AddElement<uint8_t>(PanelOptions::VT_BGCOLOROPACITY, bgColorOpacity, 255);
    }
    void add_colorVector(const ColorVector* colorVector) { fbb_.AddStruct(PanelOptions::VT_COLORVECTOR, colorVector); }
    void add_capInsets(const CapInsets* capInsets) { fbb_.AddStruct(PanelOptions::VT_CAPINSETS, capInsets); }
    void add_scale9Size(const FlatSize* scale9Size) { fbb_.AddStruct(PanelOptions::VT_SCALE9SIZE, scale9Size); }
    void add_backGroundScale9Enabled(bool backGroundScale9Enabled)
    {
        fbb_.AddElement<uint8_t>(PanelOptions::VT_BACKGROUNDSCALE9ENABLED,
                                 static_cast<uint8_t>(backGroundScale9Enabled), 0);
    }
    explicit PanelOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    PanelOptionsBuilder& operator=(const PanelOptionsBuilder&);
    flatbuffers::Offset<PanelOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<PanelOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<PanelOptions> CreatePanelOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                            flatbuffers::Offset<WidgetOptions> widgetOptions      = 0,
                                                            flatbuffers::Offset<ResourceData> backGroundImageData = 0,
                                                            bool clipEnabled               = false,
                                                            const Color* bgColor           = 0,
                                                            const Color* bgStartColor      = 0,
                                                            const Color* bgEndColor        = 0,
                                                            int32_t colorType              = 0,
                                                            uint8_t bgColorOpacity         = 255,
                                                            const ColorVector* colorVector = 0,
                                                            const CapInsets* capInsets     = 0,
                                                            const FlatSize* scale9Size     = 0,
                                                            bool backGroundScale9Enabled   = false)
{
    PanelOptionsBuilder builder_(_fbb);
    builder_.add_scale9Size(scale9Size);
    builder_.add_capInsets(capInsets);
    builder_.add_colorVector(colorVector);
    builder_.add_colorType(colorType);
    builder_.add_bgEndColor(bgEndColor);
    builder_.add_bgStartColor(bgStartColor);
    builder_.add_bgColor(bgColor);
    builder_.add_backGroundImageData(backGroundImageData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
    builder_.add_bgColorOpacity(bgColorOpacity);
    builder_.add_clipEnabled(clipEnabled);
    return builder_.Finish();
}

struct ScrollViewOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS           = 4,
        VT_BACKGROUNDIMAGEDATA     = 6,
        VT_CLIPENABLED             = 8,
        VT_BGCOLOR                 = 10,
        VT_BGSTARTCOLOR            = 12,
        VT_BGENDCOLOR              = 14,
        VT_COLORTYPE               = 16,
        VT_BGCOLOROPACITY          = 18,
        VT_COLORVECTOR             = 20,
        VT_CAPINSETS               = 22,
        VT_SCALE9SIZE              = 24,
        VT_BACKGROUNDSCALE9ENABLED = 26,
        VT_INNERSIZE               = 28,
        VT_DIRECTION               = 30,
        VT_BOUNCEENABLED           = 32,
        VT_SCROLLBARENABELD        = 34,
        VT_SCROLLBARAUTOHIDE       = 36,
        VT_SCROLLBARAUTOHIDETIME   = 38
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* backGroundImageData() const { return GetPointer<const ResourceData*>(VT_BACKGROUNDIMAGEDATA); }
    bool clipEnabled() const { return GetField<uint8_t>(VT_CLIPENABLED, 0) != 0; }
    const Color* bgColor() const { return GetStruct<const Color*>(VT_BGCOLOR); }
    const Color* bgStartColor() const { return GetStruct<const Color*>(VT_BGSTARTCOLOR); }
    const Color* bgEndColor() const { return GetStruct<const Color*>(VT_BGENDCOLOR); }
    int32_t colorType() const { return GetField<int32_t>(VT_COLORTYPE, 0); }
    uint8_t bgColorOpacity() const { return GetField<uint8_t>(VT_BGCOLOROPACITY, 255); }
    const ColorVector* colorVector() const { return GetStruct<const ColorVector*>(VT_COLORVECTOR); }
    const CapInsets* capInsets() const { return GetStruct<const CapInsets*>(VT_CAPINSETS); }
    const FlatSize* scale9Size() const { return GetStruct<const FlatSize*>(VT_SCALE9SIZE); }
    bool backGroundScale9Enabled() const { return GetField<uint8_t>(VT_BACKGROUNDSCALE9ENABLED, 0) != 0; }
    const FlatSize* innerSize() const { return GetStruct<const FlatSize*>(VT_INNERSIZE); }
    int32_t direction() const { return GetField<int32_t>(VT_DIRECTION, 0); }
    bool bounceEnabled() const { return GetField<uint8_t>(VT_BOUNCEENABLED, 0) != 0; }
    bool scrollbarEnabeld() const { return GetField<uint8_t>(VT_SCROLLBARENABELD, 1) != 0; }
    bool scrollbarAutoHide() const { return GetField<uint8_t>(VT_SCROLLBARAUTOHIDE, 1) != 0; }
    float scrollbarAutoHideTime() const { return GetField<float>(VT_SCROLLBARAUTOHIDETIME, 0.2f); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BACKGROUNDIMAGEDATA) &&
               verifier.VerifyTable(backGroundImageData()) && VerifyField<uint8_t>(verifier, VT_CLIPENABLED) &&
               VerifyField<Color>(verifier, VT_BGCOLOR) && VerifyField<Color>(verifier, VT_BGSTARTCOLOR) &&
               VerifyField<Color>(verifier, VT_BGENDCOLOR) && VerifyField<int32_t>(verifier, VT_COLORTYPE) &&
               VerifyField<uint8_t>(verifier, VT_BGCOLOROPACITY) &&
               VerifyField<ColorVector>(verifier, VT_COLORVECTOR) && VerifyField<CapInsets>(verifier, VT_CAPINSETS) &&
               VerifyField<FlatSize>(verifier, VT_SCALE9SIZE) &&
               VerifyField<uint8_t>(verifier, VT_BACKGROUNDSCALE9ENABLED) &&
               VerifyField<FlatSize>(verifier, VT_INNERSIZE) && VerifyField<int32_t>(verifier, VT_DIRECTION) &&
               VerifyField<uint8_t>(verifier, VT_BOUNCEENABLED) &&
               VerifyField<uint8_t>(verifier, VT_SCROLLBARENABELD) &&
               VerifyField<uint8_t>(verifier, VT_SCROLLBARAUTOHIDE) &&
               VerifyField<float>(verifier, VT_SCROLLBARAUTOHIDETIME) && verifier.EndTable();
    }
};

struct ScrollViewOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(ScrollViewOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData)
    {
        fbb_.AddOffset(ScrollViewOptions::VT_BACKGROUNDIMAGEDATA, backGroundImageData);
    }
    void add_clipEnabled(bool clipEnabled)
    {
        fbb_.AddElement<uint8_t>(ScrollViewOptions::VT_CLIPENABLED, static_cast<uint8_t>(clipEnabled), 0);
    }
    void add_bgColor(const Color* bgColor) { fbb_.AddStruct(ScrollViewOptions::VT_BGCOLOR, bgColor); }
    void add_bgStartColor(const Color* bgStartColor)
    {
        fbb_.AddStruct(ScrollViewOptions::VT_BGSTARTCOLOR, bgStartColor);
    }
    void add_bgEndColor(const Color* bgEndColor) { fbb_.AddStruct(ScrollViewOptions::VT_BGENDCOLOR, bgEndColor); }
    void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(ScrollViewOptions::VT_COLORTYPE, colorType, 0); }
    void add_bgColorOpacity(uint8_t bgColorOpacity)
    {
        fbb_.AddElement<uint8_t>(ScrollViewOptions::VT_BGCOLOROPACITY, bgColorOpacity, 255);
    }
    void add_colorVector(const ColorVector* colorVector)
    {
        fbb_.AddStruct(ScrollViewOptions::VT_COLORVECTOR, colorVector);
    }
    void add_capInsets(const CapInsets* capInsets) { fbb_.AddStruct(ScrollViewOptions::VT_CAPINSETS, capInsets); }
    void add_scale9Size(const FlatSize* scale9Size) { fbb_.AddStruct(ScrollViewOptions::VT_SCALE9SIZE, scale9Size); }
    void add_backGroundScale9Enabled(bool backGroundScale9Enabled)
    {
        fbb_.AddElement<uint8_t>(ScrollViewOptions::VT_BACKGROUNDSCALE9ENABLED,
                                 static_cast<uint8_t>(backGroundScale9Enabled), 0);
    }
    void add_innerSize(const FlatSize* innerSize) { fbb_.AddStruct(ScrollViewOptions::VT_INNERSIZE, innerSize); }
    void add_direction(int32_t direction) { fbb_.AddElement<int32_t>(ScrollViewOptions::VT_DIRECTION, direction, 0); }
    void add_bounceEnabled(bool bounceEnabled)
    {
        fbb_.AddElement<uint8_t>(ScrollViewOptions::VT_BOUNCEENABLED, static_cast<uint8_t>(bounceEnabled), 0);
    }
    void add_scrollbarEnabeld(bool scrollbarEnabeld)
    {
        fbb_.AddElement<uint8_t>(ScrollViewOptions::VT_SCROLLBARENABELD, static_cast<uint8_t>(scrollbarEnabeld), 1);
    }
    void add_scrollbarAutoHide(bool scrollbarAutoHide)
    {
        fbb_.AddElement<uint8_t>(ScrollViewOptions::VT_SCROLLBARAUTOHIDE, static_cast<uint8_t>(scrollbarAutoHide), 1);
    }
    void add_scrollbarAutoHideTime(float scrollbarAutoHideTime)
    {
        fbb_.AddElement<float>(ScrollViewOptions::VT_SCROLLBARAUTOHIDETIME, scrollbarAutoHideTime, 0.2f);
    }
    explicit ScrollViewOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ScrollViewOptionsBuilder& operator=(const ScrollViewOptionsBuilder&);
    flatbuffers::Offset<ScrollViewOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ScrollViewOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ScrollViewOptions> CreateScrollViewOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions      = 0,
    flatbuffers::Offset<ResourceData> backGroundImageData = 0,
    bool clipEnabled                                      = false,
    const Color* bgColor                                  = 0,
    const Color* bgStartColor                             = 0,
    const Color* bgEndColor                               = 0,
    int32_t colorType                                     = 0,
    uint8_t bgColorOpacity                                = 255,
    const ColorVector* colorVector                        = 0,
    const CapInsets* capInsets                            = 0,
    const FlatSize* scale9Size                            = 0,
    bool backGroundScale9Enabled                          = false,
    const FlatSize* innerSize                             = 0,
    int32_t direction                                     = 0,
    bool bounceEnabled                                    = false,
    bool scrollbarEnabeld                                 = true,
    bool scrollbarAutoHide                                = true,
    float scrollbarAutoHideTime                           = 0.2f)
{
    ScrollViewOptionsBuilder builder_(_fbb);
    builder_.add_scrollbarAutoHideTime(scrollbarAutoHideTime);
    builder_.add_direction(direction);
    builder_.add_innerSize(innerSize);
    builder_.add_scale9Size(scale9Size);
    builder_.add_capInsets(capInsets);
    builder_.add_colorVector(colorVector);
    builder_.add_colorType(colorType);
    builder_.add_bgEndColor(bgEndColor);
    builder_.add_bgStartColor(bgStartColor);
    builder_.add_bgColor(bgColor);
    builder_.add_backGroundImageData(backGroundImageData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_scrollbarAutoHide(scrollbarAutoHide);
    builder_.add_scrollbarEnabeld(scrollbarEnabeld);
    builder_.add_bounceEnabled(bounceEnabled);
    builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
    builder_.add_bgColorOpacity(bgColorOpacity);
    builder_.add_clipEnabled(clipEnabled);
    return builder_.Finish();
}

struct PageViewOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS           = 4,
        VT_BACKGROUNDIMAGEDATA     = 6,
        VT_CLIPENABLED             = 8,
        VT_BGCOLOR                 = 10,
        VT_BGSTARTCOLOR            = 12,
        VT_BGENDCOLOR              = 14,
        VT_COLORTYPE               = 16,
        VT_BGCOLOROPACITY          = 18,
        VT_COLORVECTOR             = 20,
        VT_CAPINSETS               = 22,
        VT_SCALE9SIZE              = 24,
        VT_BACKGROUNDSCALE9ENABLED = 26
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* backGroundImageData() const { return GetPointer<const ResourceData*>(VT_BACKGROUNDIMAGEDATA); }
    bool clipEnabled() const { return GetField<uint8_t>(VT_CLIPENABLED, 0) != 0; }
    const Color* bgColor() const { return GetStruct<const Color*>(VT_BGCOLOR); }
    const Color* bgStartColor() const { return GetStruct<const Color*>(VT_BGSTARTCOLOR); }
    const Color* bgEndColor() const { return GetStruct<const Color*>(VT_BGENDCOLOR); }
    int32_t colorType() const { return GetField<int32_t>(VT_COLORTYPE, 0); }
    uint8_t bgColorOpacity() const { return GetField<uint8_t>(VT_BGCOLOROPACITY, 255); }
    const ColorVector* colorVector() const { return GetStruct<const ColorVector*>(VT_COLORVECTOR); }
    const CapInsets* capInsets() const { return GetStruct<const CapInsets*>(VT_CAPINSETS); }
    const FlatSize* scale9Size() const { return GetStruct<const FlatSize*>(VT_SCALE9SIZE); }
    bool backGroundScale9Enabled() const { return GetField<uint8_t>(VT_BACKGROUNDSCALE9ENABLED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BACKGROUNDIMAGEDATA) &&
               verifier.VerifyTable(backGroundImageData()) && VerifyField<uint8_t>(verifier, VT_CLIPENABLED) &&
               VerifyField<Color>(verifier, VT_BGCOLOR) && VerifyField<Color>(verifier, VT_BGSTARTCOLOR) &&
               VerifyField<Color>(verifier, VT_BGENDCOLOR) && VerifyField<int32_t>(verifier, VT_COLORTYPE) &&
               VerifyField<uint8_t>(verifier, VT_BGCOLOROPACITY) &&
               VerifyField<ColorVector>(verifier, VT_COLORVECTOR) && VerifyField<CapInsets>(verifier, VT_CAPINSETS) &&
               VerifyField<FlatSize>(verifier, VT_SCALE9SIZE) &&
               VerifyField<uint8_t>(verifier, VT_BACKGROUNDSCALE9ENABLED) && verifier.EndTable();
    }
};

struct PageViewOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(PageViewOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData)
    {
        fbb_.AddOffset(PageViewOptions::VT_BACKGROUNDIMAGEDATA, backGroundImageData);
    }
    void add_clipEnabled(bool clipEnabled)
    {
        fbb_.AddElement<uint8_t>(PageViewOptions::VT_CLIPENABLED, static_cast<uint8_t>(clipEnabled), 0);
    }
    void add_bgColor(const Color* bgColor) { fbb_.AddStruct(PageViewOptions::VT_BGCOLOR, bgColor); }
    void add_bgStartColor(const Color* bgStartColor) { fbb_.AddStruct(PageViewOptions::VT_BGSTARTCOLOR, bgStartColor); }
    void add_bgEndColor(const Color* bgEndColor) { fbb_.AddStruct(PageViewOptions::VT_BGENDCOLOR, bgEndColor); }
    void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(PageViewOptions::VT_COLORTYPE, colorType, 0); }
    void add_bgColorOpacity(uint8_t bgColorOpacity)
    {
        fbb_.AddElement<uint8_t>(PageViewOptions::VT_BGCOLOROPACITY, bgColorOpacity, 255);
    }
    void add_colorVector(const ColorVector* colorVector)
    {
        fbb_.AddStruct(PageViewOptions::VT_COLORVECTOR, colorVector);
    }
    void add_capInsets(const CapInsets* capInsets) { fbb_.AddStruct(PageViewOptions::VT_CAPINSETS, capInsets); }
    void add_scale9Size(const FlatSize* scale9Size) { fbb_.AddStruct(PageViewOptions::VT_SCALE9SIZE, scale9Size); }
    void add_backGroundScale9Enabled(bool backGroundScale9Enabled)
    {
        fbb_.AddElement<uint8_t>(PageViewOptions::VT_BACKGROUNDSCALE9ENABLED,
                                 static_cast<uint8_t>(backGroundScale9Enabled), 0);
    }
    explicit PageViewOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    PageViewOptionsBuilder& operator=(const PageViewOptionsBuilder&);
    flatbuffers::Offset<PageViewOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<PageViewOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<PageViewOptions> CreatePageViewOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions      = 0,
    flatbuffers::Offset<ResourceData> backGroundImageData = 0,
    bool clipEnabled                                      = false,
    const Color* bgColor                                  = 0,
    const Color* bgStartColor                             = 0,
    const Color* bgEndColor                               = 0,
    int32_t colorType                                     = 0,
    uint8_t bgColorOpacity                                = 255,
    const ColorVector* colorVector                        = 0,
    const CapInsets* capInsets                            = 0,
    const FlatSize* scale9Size                            = 0,
    bool backGroundScale9Enabled                          = false)
{
    PageViewOptionsBuilder builder_(_fbb);
    builder_.add_scale9Size(scale9Size);
    builder_.add_capInsets(capInsets);
    builder_.add_colorVector(colorVector);
    builder_.add_colorType(colorType);
    builder_.add_bgEndColor(bgEndColor);
    builder_.add_bgStartColor(bgStartColor);
    builder_.add_bgColor(bgColor);
    builder_.add_backGroundImageData(backGroundImageData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
    builder_.add_bgColorOpacity(bgColorOpacity);
    builder_.add_clipEnabled(clipEnabled);
    return builder_.Finish();
}

struct ListViewOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_WIDGETOPTIONS           = 4,
        VT_BACKGROUNDIMAGEDATA     = 6,
        VT_CLIPENABLED             = 8,
        VT_BGCOLOR                 = 10,
        VT_BGSTARTCOLOR            = 12,
        VT_BGENDCOLOR              = 14,
        VT_COLORTYPE               = 16,
        VT_BGCOLOROPACITY          = 18,
        VT_COLORVECTOR             = 20,
        VT_CAPINSETS               = 22,
        VT_SCALE9SIZE              = 24,
        VT_BACKGROUNDSCALE9ENABLED = 26,
        VT_INNERSIZE               = 28,
        VT_DIRECTION               = 30,
        VT_BOUNCEENABLED           = 32,
        VT_ITEMMARGIN              = 34,
        VT_DIRECTIONTYPE           = 36,
        VT_HORIZONTALTYPE          = 38,
        VT_VERTICALTYPE            = 40
    };
    const WidgetOptions* widgetOptions() const { return GetPointer<const WidgetOptions*>(VT_WIDGETOPTIONS); }
    const ResourceData* backGroundImageData() const { return GetPointer<const ResourceData*>(VT_BACKGROUNDIMAGEDATA); }
    bool clipEnabled() const { return GetField<uint8_t>(VT_CLIPENABLED, 0) != 0; }
    const Color* bgColor() const { return GetStruct<const Color*>(VT_BGCOLOR); }
    const Color* bgStartColor() const { return GetStruct<const Color*>(VT_BGSTARTCOLOR); }
    const Color* bgEndColor() const { return GetStruct<const Color*>(VT_BGENDCOLOR); }
    int32_t colorType() const { return GetField<int32_t>(VT_COLORTYPE, 0); }
    uint8_t bgColorOpacity() const { return GetField<uint8_t>(VT_BGCOLOROPACITY, 255); }
    const ColorVector* colorVector() const { return GetStruct<const ColorVector*>(VT_COLORVECTOR); }
    const CapInsets* capInsets() const { return GetStruct<const CapInsets*>(VT_CAPINSETS); }
    const FlatSize* scale9Size() const { return GetStruct<const FlatSize*>(VT_SCALE9SIZE); }
    bool backGroundScale9Enabled() const { return GetField<uint8_t>(VT_BACKGROUNDSCALE9ENABLED, 0) != 0; }
    const FlatSize* innerSize() const { return GetStruct<const FlatSize*>(VT_INNERSIZE); }
    int32_t direction() const { return GetField<int32_t>(VT_DIRECTION, 0); }
    bool bounceEnabled() const { return GetField<uint8_t>(VT_BOUNCEENABLED, 0) != 0; }
    int32_t itemMargin() const { return GetField<int32_t>(VT_ITEMMARGIN, 0); }
    const flatbuffers::String* directionType() const
    {
        return GetPointer<const flatbuffers::String*>(VT_DIRECTIONTYPE);
    }
    const flatbuffers::String* horizontalType() const
    {
        return GetPointer<const flatbuffers::String*>(VT_HORIZONTALTYPE);
    }
    const flatbuffers::String* verticalType() const { return GetPointer<const flatbuffers::String*>(VT_VERTICALTYPE); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_WIDGETOPTIONS) &&
               verifier.VerifyTable(widgetOptions()) && VerifyOffset(verifier, VT_BACKGROUNDIMAGEDATA) &&
               verifier.VerifyTable(backGroundImageData()) && VerifyField<uint8_t>(verifier, VT_CLIPENABLED) &&
               VerifyField<Color>(verifier, VT_BGCOLOR) && VerifyField<Color>(verifier, VT_BGSTARTCOLOR) &&
               VerifyField<Color>(verifier, VT_BGENDCOLOR) && VerifyField<int32_t>(verifier, VT_COLORTYPE) &&
               VerifyField<uint8_t>(verifier, VT_BGCOLOROPACITY) &&
               VerifyField<ColorVector>(verifier, VT_COLORVECTOR) && VerifyField<CapInsets>(verifier, VT_CAPINSETS) &&
               VerifyField<FlatSize>(verifier, VT_SCALE9SIZE) &&
               VerifyField<uint8_t>(verifier, VT_BACKGROUNDSCALE9ENABLED) &&
               VerifyField<FlatSize>(verifier, VT_INNERSIZE) && VerifyField<int32_t>(verifier, VT_DIRECTION) &&
               VerifyField<uint8_t>(verifier, VT_BOUNCEENABLED) && VerifyField<int32_t>(verifier, VT_ITEMMARGIN) &&
               VerifyOffset(verifier, VT_DIRECTIONTYPE) && verifier.VerifyString(directionType()) &&
               VerifyOffset(verifier, VT_HORIZONTALTYPE) && verifier.VerifyString(horizontalType()) &&
               VerifyOffset(verifier, VT_VERTICALTYPE) && verifier.VerifyString(verticalType()) && verifier.EndTable();
    }
};

struct ListViewOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_widgetOptions(flatbuffers::Offset<WidgetOptions> widgetOptions)
    {
        fbb_.AddOffset(ListViewOptions::VT_WIDGETOPTIONS, widgetOptions);
    }
    void add_backGroundImageData(flatbuffers::Offset<ResourceData> backGroundImageData)
    {
        fbb_.AddOffset(ListViewOptions::VT_BACKGROUNDIMAGEDATA, backGroundImageData);
    }
    void add_clipEnabled(bool clipEnabled)
    {
        fbb_.AddElement<uint8_t>(ListViewOptions::VT_CLIPENABLED, static_cast<uint8_t>(clipEnabled), 0);
    }
    void add_bgColor(const Color* bgColor) { fbb_.AddStruct(ListViewOptions::VT_BGCOLOR, bgColor); }
    void add_bgStartColor(const Color* bgStartColor) { fbb_.AddStruct(ListViewOptions::VT_BGSTARTCOLOR, bgStartColor); }
    void add_bgEndColor(const Color* bgEndColor) { fbb_.AddStruct(ListViewOptions::VT_BGENDCOLOR, bgEndColor); }
    void add_colorType(int32_t colorType) { fbb_.AddElement<int32_t>(ListViewOptions::VT_COLORTYPE, colorType, 0); }
    void add_bgColorOpacity(uint8_t bgColorOpacity)
    {
        fbb_.AddElement<uint8_t>(ListViewOptions::VT_BGCOLOROPACITY, bgColorOpacity, 255);
    }
    void add_colorVector(const ColorVector* colorVector)
    {
        fbb_.AddStruct(ListViewOptions::VT_COLORVECTOR, colorVector);
    }
    void add_capInsets(const CapInsets* capInsets) { fbb_.AddStruct(ListViewOptions::VT_CAPINSETS, capInsets); }
    void add_scale9Size(const FlatSize* scale9Size) { fbb_.AddStruct(ListViewOptions::VT_SCALE9SIZE, scale9Size); }
    void add_backGroundScale9Enabled(bool backGroundScale9Enabled)
    {
        fbb_.AddElement<uint8_t>(ListViewOptions::VT_BACKGROUNDSCALE9ENABLED,
                                 static_cast<uint8_t>(backGroundScale9Enabled), 0);
    }
    void add_innerSize(const FlatSize* innerSize) { fbb_.AddStruct(ListViewOptions::VT_INNERSIZE, innerSize); }
    void add_direction(int32_t direction) { fbb_.AddElement<int32_t>(ListViewOptions::VT_DIRECTION, direction, 0); }
    void add_bounceEnabled(bool bounceEnabled)
    {
        fbb_.AddElement<uint8_t>(ListViewOptions::VT_BOUNCEENABLED, static_cast<uint8_t>(bounceEnabled), 0);
    }
    void add_itemMargin(int32_t itemMargin) { fbb_.AddElement<int32_t>(ListViewOptions::VT_ITEMMARGIN, itemMargin, 0); }
    void add_directionType(flatbuffers::Offset<flatbuffers::String> directionType)
    {
        fbb_.AddOffset(ListViewOptions::VT_DIRECTIONTYPE, directionType);
    }
    void add_horizontalType(flatbuffers::Offset<flatbuffers::String> horizontalType)
    {
        fbb_.AddOffset(ListViewOptions::VT_HORIZONTALTYPE, horizontalType);
    }
    void add_verticalType(flatbuffers::Offset<flatbuffers::String> verticalType)
    {
        fbb_.AddOffset(ListViewOptions::VT_VERTICALTYPE, verticalType);
    }
    explicit ListViewOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ListViewOptionsBuilder& operator=(const ListViewOptionsBuilder&);
    flatbuffers::Offset<ListViewOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ListViewOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ListViewOptions> CreateListViewOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions        = 0,
    flatbuffers::Offset<ResourceData> backGroundImageData   = 0,
    bool clipEnabled                                        = false,
    const Color* bgColor                                    = 0,
    const Color* bgStartColor                               = 0,
    const Color* bgEndColor                                 = 0,
    int32_t colorType                                       = 0,
    uint8_t bgColorOpacity                                  = 255,
    const ColorVector* colorVector                          = 0,
    const CapInsets* capInsets                              = 0,
    const FlatSize* scale9Size                              = 0,
    bool backGroundScale9Enabled                            = false,
    const FlatSize* innerSize                               = 0,
    int32_t direction                                       = 0,
    bool bounceEnabled                                      = false,
    int32_t itemMargin                                      = 0,
    flatbuffers::Offset<flatbuffers::String> directionType  = 0,
    flatbuffers::Offset<flatbuffers::String> horizontalType = 0,
    flatbuffers::Offset<flatbuffers::String> verticalType   = 0)
{
    ListViewOptionsBuilder builder_(_fbb);
    builder_.add_verticalType(verticalType);
    builder_.add_horizontalType(horizontalType);
    builder_.add_directionType(directionType);
    builder_.add_itemMargin(itemMargin);
    builder_.add_direction(direction);
    builder_.add_innerSize(innerSize);
    builder_.add_scale9Size(scale9Size);
    builder_.add_capInsets(capInsets);
    builder_.add_colorVector(colorVector);
    builder_.add_colorType(colorType);
    builder_.add_bgEndColor(bgEndColor);
    builder_.add_bgStartColor(bgStartColor);
    builder_.add_bgColor(bgColor);
    builder_.add_backGroundImageData(backGroundImageData);
    builder_.add_widgetOptions(widgetOptions);
    builder_.add_bounceEnabled(bounceEnabled);
    builder_.add_backGroundScale9Enabled(backGroundScale9Enabled);
    builder_.add_bgColorOpacity(bgColorOpacity);
    builder_.add_clipEnabled(clipEnabled);
    return builder_.Finish();
}

inline flatbuffers::Offset<ListViewOptions> CreateListViewOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> widgetOptions      = 0,
    flatbuffers::Offset<ResourceData> backGroundImageData = 0,
    bool clipEnabled                                      = false,
    const Color* bgColor                                  = 0,
    const Color* bgStartColor                             = 0,
    const Color* bgEndColor                               = 0,
    int32_t colorType                                     = 0,
    uint8_t bgColorOpacity                                = 255,
    const ColorVector* colorVector                        = 0,
    const CapInsets* capInsets                            = 0,
    const FlatSize* scale9Size                            = 0,
    bool backGroundScale9Enabled                          = false,
    const FlatSize* innerSize                             = 0,
    int32_t direction                                     = 0,
    bool bounceEnabled                                    = false,
    int32_t itemMargin                                    = 0,
    const char* directionType                             = nullptr,
    const char* horizontalType                            = nullptr,
    const char* verticalType                              = nullptr)
{
    auto directionType__  = directionType ? _fbb.CreateString(directionType) : 0;
    auto horizontalType__ = horizontalType ? _fbb.CreateString(horizontalType) : 0;
    auto verticalType__   = verticalType ? _fbb.CreateString(verticalType) : 0;
    return flatbuffers::CreateListViewOptions(
        _fbb, widgetOptions, backGroundImageData, clipEnabled, bgColor, bgStartColor, bgEndColor, colorType,
        bgColorOpacity, colorVector, capInsets, scale9Size, backGroundScale9Enabled, innerSize, direction,
        bounceEnabled, itemMargin, directionType__, horizontalType__, verticalType__);
}

struct TextFieldExOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS       = 4,
        VT_FONTRESOURCE      = 6,
        VT_FONTNAME          = 8,
        VT_FONTSIZE          = 10,
        VT_TEXT              = 12,
        VT_PLACEHOLDERTEXT   = 14,
        VT_PASSWORDENABLED   = 16,
        VT_PASSWORDSTYLETEXT = 18,
        VT_MAXLENGTH         = 20,
        VT_TEXTCOLOR         = 22,
        VT_PLACEHOLDERCOLOR  = 24,
        VT_CURSORCOLOR       = 26,
        VT_ENABLED           = 28,
        VT_EDITABLE          = 30,
        VT_ISLOCALIZED       = 32
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const ResourceData* fontResource() const { return GetPointer<const ResourceData*>(VT_FONTRESOURCE); }
    const flatbuffers::String* fontName() const { return GetPointer<const flatbuffers::String*>(VT_FONTNAME); }
    int32_t fontSize() const { return GetField<int32_t>(VT_FONTSIZE, 0); }
    const flatbuffers::String* text() const { return GetPointer<const flatbuffers::String*>(VT_TEXT); }
    const flatbuffers::String* placeholderText() const
    {
        return GetPointer<const flatbuffers::String*>(VT_PLACEHOLDERTEXT);
    }
    bool passwordEnabled() const { return GetField<uint8_t>(VT_PASSWORDENABLED, 0) != 0; }
    const flatbuffers::String* passwordStyleText() const
    {
        return GetPointer<const flatbuffers::String*>(VT_PASSWORDSTYLETEXT);
    }
    int32_t maxLength() const { return GetField<int32_t>(VT_MAXLENGTH, 0); }
    const Color* textColor() const { return GetStruct<const Color*>(VT_TEXTCOLOR); }
    const Color* placeholderColor() const { return GetStruct<const Color*>(VT_PLACEHOLDERCOLOR); }
    const Color* cursorColor() const { return GetStruct<const Color*>(VT_CURSORCOLOR); }
    bool enabled() const { return GetField<uint8_t>(VT_ENABLED, 1) != 0; }
    bool editable() const { return GetField<uint8_t>(VT_EDITABLE, 1) != 0; }
    bool isLocalized() const { return GetField<uint8_t>(VT_ISLOCALIZED, 0) != 0; }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_FONTRESOURCE) &&
               verifier.VerifyTable(fontResource()) && VerifyOffset(verifier, VT_FONTNAME) &&
               verifier.VerifyString(fontName()) && VerifyField<int32_t>(verifier, VT_FONTSIZE) &&
               VerifyOffset(verifier, VT_TEXT) && verifier.VerifyString(text()) &&
               VerifyOffset(verifier, VT_PLACEHOLDERTEXT) && verifier.VerifyString(placeholderText()) &&
               VerifyField<uint8_t>(verifier, VT_PASSWORDENABLED) && VerifyOffset(verifier, VT_PASSWORDSTYLETEXT) &&
               verifier.VerifyString(passwordStyleText()) && VerifyField<int32_t>(verifier, VT_MAXLENGTH) &&
               VerifyField<Color>(verifier, VT_TEXTCOLOR) && VerifyField<Color>(verifier, VT_PLACEHOLDERCOLOR) &&
               VerifyField<Color>(verifier, VT_CURSORCOLOR) && VerifyField<uint8_t>(verifier, VT_ENABLED) &&
               VerifyField<uint8_t>(verifier, VT_EDITABLE) && VerifyField<uint8_t>(verifier, VT_ISLOCALIZED) &&
               verifier.EndTable();
    }
};

struct TextFieldExOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(TextFieldExOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_fontResource(flatbuffers::Offset<ResourceData> fontResource)
    {
        fbb_.AddOffset(TextFieldExOptions::VT_FONTRESOURCE, fontResource);
    }
    void add_fontName(flatbuffers::Offset<flatbuffers::String> fontName)
    {
        fbb_.AddOffset(TextFieldExOptions::VT_FONTNAME, fontName);
    }
    void add_fontSize(int32_t fontSize) { fbb_.AddElement<int32_t>(TextFieldExOptions::VT_FONTSIZE, fontSize, 0); }
    void add_text(flatbuffers::Offset<flatbuffers::String> text) { fbb_.AddOffset(TextFieldExOptions::VT_TEXT, text); }
    void add_placeholderText(flatbuffers::Offset<flatbuffers::String> placeholderText)
    {
        fbb_.AddOffset(TextFieldExOptions::VT_PLACEHOLDERTEXT, placeholderText);
    }
    void add_passwordEnabled(bool passwordEnabled)
    {
        fbb_.AddElement<uint8_t>(TextFieldExOptions::VT_PASSWORDENABLED, static_cast<uint8_t>(passwordEnabled), 0);
    }
    void add_passwordStyleText(flatbuffers::Offset<flatbuffers::String> passwordStyleText)
    {
        fbb_.AddOffset(TextFieldExOptions::VT_PASSWORDSTYLETEXT, passwordStyleText);
    }
    void add_maxLength(int32_t maxLength) { fbb_.AddElement<int32_t>(TextFieldExOptions::VT_MAXLENGTH, maxLength, 0); }
    void add_textColor(const Color* textColor) { fbb_.AddStruct(TextFieldExOptions::VT_TEXTCOLOR, textColor); }
    void add_placeholderColor(const Color* placeholderColor)
    {
        fbb_.AddStruct(TextFieldExOptions::VT_PLACEHOLDERCOLOR, placeholderColor);
    }
    void add_cursorColor(const Color* cursorColor) { fbb_.AddStruct(TextFieldExOptions::VT_CURSORCOLOR, cursorColor); }
    void add_enabled(bool enabled)
    {
        fbb_.AddElement<uint8_t>(TextFieldExOptions::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
    }
    void add_editable(bool editable)
    {
        fbb_.AddElement<uint8_t>(TextFieldExOptions::VT_EDITABLE, static_cast<uint8_t>(editable), 1);
    }
    void add_isLocalized(bool isLocalized)
    {
        fbb_.AddElement<uint8_t>(TextFieldExOptions::VT_ISLOCALIZED, static_cast<uint8_t>(isLocalized), 0);
    }
    explicit TextFieldExOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    TextFieldExOptionsBuilder& operator=(const TextFieldExOptionsBuilder&);
    flatbuffers::Offset<TextFieldExOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TextFieldExOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<TextFieldExOptions> CreateTextFieldExOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions             = 0,
    flatbuffers::Offset<ResourceData> fontResource             = 0,
    flatbuffers::Offset<flatbuffers::String> fontName          = 0,
    int32_t fontSize                                           = 0,
    flatbuffers::Offset<flatbuffers::String> text              = 0,
    flatbuffers::Offset<flatbuffers::String> placeholderText   = 0,
    bool passwordEnabled                                       = false,
    flatbuffers::Offset<flatbuffers::String> passwordStyleText = 0,
    int32_t maxLength                                          = 0,
    const Color* textColor                                     = 0,
    const Color* placeholderColor                              = 0,
    const Color* cursorColor                                   = 0,
    bool enabled                                               = true,
    bool editable                                              = true,
    bool isLocalized                                           = false)
{
    TextFieldExOptionsBuilder builder_(_fbb);
    builder_.add_cursorColor(cursorColor);
    builder_.add_placeholderColor(placeholderColor);
    builder_.add_textColor(textColor);
    builder_.add_maxLength(maxLength);
    builder_.add_passwordStyleText(passwordStyleText);
    builder_.add_placeholderText(placeholderText);
    builder_.add_text(text);
    builder_.add_fontSize(fontSize);
    builder_.add_fontName(fontName);
    builder_.add_fontResource(fontResource);
    builder_.add_nodeOptions(nodeOptions);
    builder_.add_isLocalized(isLocalized);
    builder_.add_editable(editable);
    builder_.add_enabled(enabled);
    builder_.add_passwordEnabled(passwordEnabled);
    return builder_.Finish();
}

inline flatbuffers::Offset<TextFieldExOptions> CreateTextFieldExOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    flatbuffers::Offset<ResourceData> fontResource = 0,
    const char* fontName                           = nullptr,
    int32_t fontSize                               = 0,
    const char* text                               = nullptr,
    const char* placeholderText                    = nullptr,
    bool passwordEnabled                           = false,
    const char* passwordStyleText                  = nullptr,
    int32_t maxLength                              = 0,
    const Color* textColor                         = 0,
    const Color* placeholderColor                  = 0,
    const Color* cursorColor                       = 0,
    bool enabled                                   = true,
    bool editable                                  = true,
    bool isLocalized                               = false)
{
    auto fontName__          = fontName ? _fbb.CreateString(fontName) : 0;
    auto text__              = text ? _fbb.CreateString(text) : 0;
    auto placeholderText__   = placeholderText ? _fbb.CreateString(placeholderText) : 0;
    auto passwordStyleText__ = passwordStyleText ? _fbb.CreateString(passwordStyleText) : 0;
    return flatbuffers::CreateTextFieldExOptions(
        _fbb, nodeOptions, fontResource, fontName__, fontSize, text__, placeholderText__, passwordEnabled,
        passwordStyleText__, maxLength, textColor, placeholderColor, cursorColor, enabled, editable, isLocalized);
}

struct ProjectNodeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS      = 4,
        VT_FILENAME         = 6,
        VT_INNERACTIONSPEED = 8
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const flatbuffers::String* fileName() const { return GetPointer<const flatbuffers::String*>(VT_FILENAME); }
    float innerActionSpeed() const { return GetField<float>(VT_INNERACTIONSPEED, 0.0f); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_FILENAME) &&
               verifier.VerifyString(fileName()) && VerifyField<float>(verifier, VT_INNERACTIONSPEED) &&
               verifier.EndTable();
    }
};

struct ProjectNodeOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(ProjectNodeOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_fileName(flatbuffers::Offset<flatbuffers::String> fileName)
    {
        fbb_.AddOffset(ProjectNodeOptions::VT_FILENAME, fileName);
    }
    void add_innerActionSpeed(float innerActionSpeed)
    {
        fbb_.AddElement<float>(ProjectNodeOptions::VT_INNERACTIONSPEED, innerActionSpeed, 0.0f);
    }
    explicit ProjectNodeOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb)
    {
        start_ = fbb_.StartTable();
    }
    ProjectNodeOptionsBuilder& operator=(const ProjectNodeOptionsBuilder&);
    flatbuffers::Offset<ProjectNodeOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ProjectNodeOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ProjectNodeOptions> CreateProjectNodeOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions    = 0,
    flatbuffers::Offset<flatbuffers::String> fileName = 0,
    float innerActionSpeed                            = 0.0f)
{
    ProjectNodeOptionsBuilder builder_(_fbb);
    builder_.add_innerActionSpeed(innerActionSpeed);
    builder_.add_fileName(fileName);
    builder_.add_nodeOptions(nodeOptions);
    return builder_.Finish();
}

inline flatbuffers::Offset<ProjectNodeOptions> CreateProjectNodeOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    const char* fileName                           = nullptr,
    float innerActionSpeed                         = 0.0f)
{
    auto fileName__ = fileName ? _fbb.CreateString(fileName) : 0;
    return flatbuffers::CreateProjectNodeOptions(_fbb, nodeOptions, fileName__, innerActionSpeed);
}

struct ComponentOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS     = 4,
        VT_TYPE            = 6,
        VT_COMAUDIOOPTIONS = 8
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const flatbuffers::String* type() const { return GetPointer<const flatbuffers::String*>(VT_TYPE); }
    const ComAudioOptions* comAudioOptions() const { return GetPointer<const ComAudioOptions*>(VT_COMAUDIOOPTIONS); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_TYPE) &&
               verifier.VerifyString(type()) && VerifyOffset(verifier, VT_COMAUDIOOPTIONS) &&
               verifier.VerifyTable(comAudioOptions()) && verifier.EndTable();
    }
};

struct ComponentOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(ComponentOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_type(flatbuffers::Offset<flatbuffers::String> type) { fbb_.AddOffset(ComponentOptions::VT_TYPE, type); }
    void add_comAudioOptions(flatbuffers::Offset<ComAudioOptions> comAudioOptions)
    {
        fbb_.AddOffset(ComponentOptions::VT_COMAUDIOOPTIONS, comAudioOptions);
    }
    explicit ComponentOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ComponentOptionsBuilder& operator=(const ComponentOptionsBuilder&);
    flatbuffers::Offset<ComponentOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ComponentOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ComponentOptions> CreateComponentOptions(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions       = 0,
    flatbuffers::Offset<flatbuffers::String> type        = 0,
    flatbuffers::Offset<ComAudioOptions> comAudioOptions = 0)
{
    ComponentOptionsBuilder builder_(_fbb);
    builder_.add_comAudioOptions(comAudioOptions);
    builder_.add_type(type);
    builder_.add_nodeOptions(nodeOptions);
    return builder_.Finish();
}

inline flatbuffers::Offset<ComponentOptions> CreateComponentOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions       = 0,
    const char* type                                     = nullptr,
    flatbuffers::Offset<ComAudioOptions> comAudioOptions = 0)
{
    auto type__ = type ? _fbb.CreateString(type) : 0;
    return flatbuffers::CreateComponentOptions(_fbb, nodeOptions, type__, comAudioOptions);
}

struct ComAudioOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NODEOPTIONS  = 4,
        VT_NAME         = 6,
        VT_ENABLED      = 8,
        VT_LOOP         = 10,
        VT_VOLUME       = 12,
        VT_FILENAMEDATA = 14
    };
    const WidgetOptions* nodeOptions() const { return GetPointer<const WidgetOptions*>(VT_NODEOPTIONS); }
    const flatbuffers::String* name() const { return GetPointer<const flatbuffers::String*>(VT_NAME); }
    bool enabled() const { return GetField<uint8_t>(VT_ENABLED, 0) != 0; }
    bool loop() const { return GetField<uint8_t>(VT_LOOP, 0) != 0; }
    int32_t volume() const { return GetField<int32_t>(VT_VOLUME, 0); }
    const ResourceData* fileNameData() const { return GetPointer<const ResourceData*>(VT_FILENAMEDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NODEOPTIONS) &&
               verifier.VerifyTable(nodeOptions()) && VerifyOffset(verifier, VT_NAME) &&
               verifier.VerifyString(name()) && VerifyField<uint8_t>(verifier, VT_ENABLED) &&
               VerifyField<uint8_t>(verifier, VT_LOOP) && VerifyField<int32_t>(verifier, VT_VOLUME) &&
               VerifyOffset(verifier, VT_FILENAMEDATA) && verifier.VerifyTable(fileNameData()) && verifier.EndTable();
    }
};

struct ComAudioOptionsBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_nodeOptions(flatbuffers::Offset<WidgetOptions> nodeOptions)
    {
        fbb_.AddOffset(ComAudioOptions::VT_NODEOPTIONS, nodeOptions);
    }
    void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(ComAudioOptions::VT_NAME, name); }
    void add_enabled(bool enabled)
    {
        fbb_.AddElement<uint8_t>(ComAudioOptions::VT_ENABLED, static_cast<uint8_t>(enabled), 0);
    }
    void add_loop(bool loop) { fbb_.AddElement<uint8_t>(ComAudioOptions::VT_LOOP, static_cast<uint8_t>(loop), 0); }
    void add_volume(int32_t volume) { fbb_.AddElement<int32_t>(ComAudioOptions::VT_VOLUME, volume, 0); }
    void add_fileNameData(flatbuffers::Offset<ResourceData> fileNameData)
    {
        fbb_.AddOffset(ComAudioOptions::VT_FILENAMEDATA, fileNameData);
    }
    explicit ComAudioOptionsBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ComAudioOptionsBuilder& operator=(const ComAudioOptionsBuilder&);
    flatbuffers::Offset<ComAudioOptions> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ComAudioOptions>(end);
        return o;
    }
};

inline flatbuffers::Offset<ComAudioOptions> CreateComAudioOptions(flatbuffers::FlatBufferBuilder& _fbb,
                                                                  flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
                                                                  flatbuffers::Offset<flatbuffers::String> name  = 0,
                                                                  bool enabled   = false,
                                                                  bool loop      = false,
                                                                  int32_t volume = 0,
                                                                  flatbuffers::Offset<ResourceData> fileNameData = 0)
{
    ComAudioOptionsBuilder builder_(_fbb);
    builder_.add_fileNameData(fileNameData);
    builder_.add_volume(volume);
    builder_.add_name(name);
    builder_.add_nodeOptions(nodeOptions);
    builder_.add_loop(loop);
    builder_.add_enabled(enabled);
    return builder_.Finish();
}

inline flatbuffers::Offset<ComAudioOptions> CreateComAudioOptionsDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<WidgetOptions> nodeOptions = 0,
    const char* name                               = nullptr,
    bool enabled                                   = false,
    bool loop                                      = false,
    int32_t volume                                 = 0,
    flatbuffers::Offset<ResourceData> fileNameData = 0)
{
    auto name__ = name ? _fbb.CreateString(name) : 0;
    return flatbuffers::CreateComAudioOptions(_fbb, nodeOptions, name__, enabled, loop, volume, fileNameData);
}

struct AnimationInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_NAME       = 4,
        VT_STARTINDEX = 6,
        VT_ENDINDEX   = 8
    };
    const flatbuffers::String* name() const { return GetPointer<const flatbuffers::String*>(VT_NAME); }
    int32_t startIndex() const { return GetField<int32_t>(VT_STARTINDEX, 0); }
    int32_t endIndex() const { return GetField<int32_t>(VT_ENDINDEX, 0); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) &&
               VerifyField<int32_t>(verifier, VT_STARTINDEX) && VerifyField<int32_t>(verifier, VT_ENDINDEX) &&
               verifier.EndTable();
    }
};

struct AnimationInfoBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(AnimationInfo::VT_NAME, name); }
    void add_startIndex(int32_t startIndex) { fbb_.AddElement<int32_t>(AnimationInfo::VT_STARTINDEX, startIndex, 0); }
    void add_endIndex(int32_t endIndex) { fbb_.AddElement<int32_t>(AnimationInfo::VT_ENDINDEX, endIndex, 0); }
    explicit AnimationInfoBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    AnimationInfoBuilder& operator=(const AnimationInfoBuilder&);
    flatbuffers::Offset<AnimationInfo> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<AnimationInfo>(end);
        return o;
    }
};

inline flatbuffers::Offset<AnimationInfo> CreateAnimationInfo(flatbuffers::FlatBufferBuilder& _fbb,
                                                              flatbuffers::Offset<flatbuffers::String> name = 0,
                                                              int32_t startIndex                            = 0,
                                                              int32_t endIndex                              = 0)
{
    AnimationInfoBuilder builder_(_fbb);
    builder_.add_endIndex(endIndex);
    builder_.add_startIndex(startIndex);
    builder_.add_name(name);
    return builder_.Finish();
}

inline flatbuffers::Offset<AnimationInfo> CreateAnimationInfoDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                                    const char* name   = nullptr,
                                                                    int32_t startIndex = 0,
                                                                    int32_t endIndex   = 0)
{
    auto name__ = name ? _fbb.CreateString(name) : 0;
    return flatbuffers::CreateAnimationInfo(_fbb, name__, startIndex, endIndex);
}

struct NodeAction FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_DURATION             = 4,
        VT_SPEED                = 6,
        VT_TIMELINES            = 8,
        VT_CURRENTANIMATIONNAME = 10
    };
    int32_t duration() const { return GetField<int32_t>(VT_DURATION, 0); }
    float speed() const { return GetField<float>(VT_SPEED, 0.0f); }
    const flatbuffers::Vector<flatbuffers::Offset<TimeLine>>* timeLines() const
    {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TimeLine>>*>(VT_TIMELINES);
    }
    const flatbuffers::String* currentAnimationName() const
    {
        return GetPointer<const flatbuffers::String*>(VT_CURRENTANIMATIONNAME);
    }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_DURATION) &&
               VerifyField<float>(verifier, VT_SPEED) && VerifyOffset(verifier, VT_TIMELINES) &&
               verifier.VerifyVector(timeLines()) && verifier.VerifyVectorOfTables(timeLines()) &&
               VerifyOffset(verifier, VT_CURRENTANIMATIONNAME) && verifier.VerifyString(currentAnimationName()) &&
               verifier.EndTable();
    }
};

struct NodeActionBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_duration(int32_t duration) { fbb_.AddElement<int32_t>(NodeAction::VT_DURATION, duration, 0); }
    void add_speed(float speed) { fbb_.AddElement<float>(NodeAction::VT_SPEED, speed, 0.0f); }
    void add_timeLines(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TimeLine>>> timeLines)
    {
        fbb_.AddOffset(NodeAction::VT_TIMELINES, timeLines);
    }
    void add_currentAnimationName(flatbuffers::Offset<flatbuffers::String> currentAnimationName)
    {
        fbb_.AddOffset(NodeAction::VT_CURRENTANIMATIONNAME, currentAnimationName);
    }
    explicit NodeActionBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    NodeActionBuilder& operator=(const NodeActionBuilder&);
    flatbuffers::Offset<NodeAction> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<NodeAction>(end);
        return o;
    }
};

inline flatbuffers::Offset<NodeAction> CreateNodeAction(
    flatbuffers::FlatBufferBuilder& _fbb,
    int32_t duration                                                                  = 0,
    float speed                                                                       = 0.0f,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TimeLine>>> timeLines = 0,
    flatbuffers::Offset<flatbuffers::String> currentAnimationName                     = 0)
{
    NodeActionBuilder builder_(_fbb);
    builder_.add_currentAnimationName(currentAnimationName);
    builder_.add_timeLines(timeLines);
    builder_.add_speed(speed);
    builder_.add_duration(duration);
    return builder_.Finish();
}

inline flatbuffers::Offset<NodeAction> CreateNodeActionDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    int32_t duration                                            = 0,
    float speed                                                 = 0.0f,
    const std::vector<flatbuffers::Offset<TimeLine>>* timeLines = nullptr,
    const char* currentAnimationName                            = nullptr)
{
    auto timeLines__            = timeLines ? _fbb.CreateVector<flatbuffers::Offset<TimeLine>>(*timeLines) : 0;
    auto currentAnimationName__ = currentAnimationName ? _fbb.CreateString(currentAnimationName) : 0;
    return flatbuffers::CreateNodeAction(_fbb, duration, speed, timeLines__, currentAnimationName__);
}

struct TimeLine FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_PROPERTY  = 4,
        VT_ACTIONTAG = 6,
        VT_FRAMES    = 8
    };
    const flatbuffers::String* property() const { return GetPointer<const flatbuffers::String*>(VT_PROPERTY); }
    int32_t actionTag() const { return GetField<int32_t>(VT_ACTIONTAG, 0); }
    const flatbuffers::Vector<flatbuffers::Offset<Frame>>* frames() const
    {
        return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Frame>>*>(VT_FRAMES);
    }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_PROPERTY) && verifier.VerifyString(property()) &&
               VerifyField<int32_t>(verifier, VT_ACTIONTAG) && VerifyOffset(verifier, VT_FRAMES) &&
               verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable();
    }
};

struct TimeLineBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_property(flatbuffers::Offset<flatbuffers::String> property)
    {
        fbb_.AddOffset(TimeLine::VT_PROPERTY, property);
    }
    void add_actionTag(int32_t actionTag) { fbb_.AddElement<int32_t>(TimeLine::VT_ACTIONTAG, actionTag, 0); }
    void add_frames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Frame>>> frames)
    {
        fbb_.AddOffset(TimeLine::VT_FRAMES, frames);
    }
    explicit TimeLineBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TimeLineBuilder& operator=(const TimeLineBuilder&);
    flatbuffers::Offset<TimeLine> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TimeLine>(end);
        return o;
    }
};

inline flatbuffers::Offset<TimeLine> CreateTimeLine(
    flatbuffers::FlatBufferBuilder& _fbb,
    flatbuffers::Offset<flatbuffers::String> property                           = 0,
    int32_t actionTag                                                           = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Frame>>> frames = 0)
{
    TimeLineBuilder builder_(_fbb);
    builder_.add_frames(frames);
    builder_.add_actionTag(actionTag);
    builder_.add_property(property);
    return builder_.Finish();
}

inline flatbuffers::Offset<TimeLine> CreateTimeLineDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    const char* property                                  = nullptr,
    int32_t actionTag                                     = 0,
    const std::vector<flatbuffers::Offset<Frame>>* frames = nullptr)
{
    auto property__ = property ? _fbb.CreateString(property) : 0;
    auto frames__   = frames ? _fbb.CreateVector<flatbuffers::Offset<Frame>>(*frames) : 0;
    return flatbuffers::CreateTimeLine(_fbb, property__, actionTag, frames__);
}

struct Frame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_POINTFRAME       = 4,
        VT_SCALEFRAME       = 6,
        VT_COLORFRAME       = 8,
        VT_TEXTUREFRAME     = 10,
        VT_EVENTFRAME       = 12,
        VT_INTFRAME         = 14,
        VT_BOOLFRAME        = 16,
        VT_INNERACTIONFRAME = 18,
        VT_BLENDFRAME       = 20
    };
    const PointFrame* pointFrame() const { return GetPointer<const PointFrame*>(VT_POINTFRAME); }
    const ScaleFrame* scaleFrame() const { return GetPointer<const ScaleFrame*>(VT_SCALEFRAME); }
    const ColorFrame* colorFrame() const { return GetPointer<const ColorFrame*>(VT_COLORFRAME); }
    const TextureFrame* textureFrame() const { return GetPointer<const TextureFrame*>(VT_TEXTUREFRAME); }
    const EventFrame* eventFrame() const { return GetPointer<const EventFrame*>(VT_EVENTFRAME); }
    const IntFrame* intFrame() const { return GetPointer<const IntFrame*>(VT_INTFRAME); }
    const BoolFrame* boolFrame() const { return GetPointer<const BoolFrame*>(VT_BOOLFRAME); }
    const InnerActionFrame* innerActionFrame() const
    {
        return GetPointer<const InnerActionFrame*>(VT_INNERACTIONFRAME);
    }
    const BlendFrame* blendFrame() const { return GetPointer<const BlendFrame*>(VT_BLENDFRAME); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_POINTFRAME) &&
               verifier.VerifyTable(pointFrame()) && VerifyOffset(verifier, VT_SCALEFRAME) &&
               verifier.VerifyTable(scaleFrame()) && VerifyOffset(verifier, VT_COLORFRAME) &&
               verifier.VerifyTable(colorFrame()) && VerifyOffset(verifier, VT_TEXTUREFRAME) &&
               verifier.VerifyTable(textureFrame()) && VerifyOffset(verifier, VT_EVENTFRAME) &&
               verifier.VerifyTable(eventFrame()) && VerifyOffset(verifier, VT_INTFRAME) &&
               verifier.VerifyTable(intFrame()) && VerifyOffset(verifier, VT_BOOLFRAME) &&
               verifier.VerifyTable(boolFrame()) && VerifyOffset(verifier, VT_INNERACTIONFRAME) &&
               verifier.VerifyTable(innerActionFrame()) && VerifyOffset(verifier, VT_BLENDFRAME) &&
               verifier.VerifyTable(blendFrame()) && verifier.EndTable();
    }
};

struct FrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_pointFrame(flatbuffers::Offset<PointFrame> pointFrame)
    {
        fbb_.AddOffset(Frame::VT_POINTFRAME, pointFrame);
    }
    void add_scaleFrame(flatbuffers::Offset<ScaleFrame> scaleFrame)
    {
        fbb_.AddOffset(Frame::VT_SCALEFRAME, scaleFrame);
    }
    void add_colorFrame(flatbuffers::Offset<ColorFrame> colorFrame)
    {
        fbb_.AddOffset(Frame::VT_COLORFRAME, colorFrame);
    }
    void add_textureFrame(flatbuffers::Offset<TextureFrame> textureFrame)
    {
        fbb_.AddOffset(Frame::VT_TEXTUREFRAME, textureFrame);
    }
    void add_eventFrame(flatbuffers::Offset<EventFrame> eventFrame)
    {
        fbb_.AddOffset(Frame::VT_EVENTFRAME, eventFrame);
    }
    void add_intFrame(flatbuffers::Offset<IntFrame> intFrame) { fbb_.AddOffset(Frame::VT_INTFRAME, intFrame); }
    void add_boolFrame(flatbuffers::Offset<BoolFrame> boolFrame) { fbb_.AddOffset(Frame::VT_BOOLFRAME, boolFrame); }
    void add_innerActionFrame(flatbuffers::Offset<InnerActionFrame> innerActionFrame)
    {
        fbb_.AddOffset(Frame::VT_INNERACTIONFRAME, innerActionFrame);
    }
    void add_blendFrame(flatbuffers::Offset<BlendFrame> blendFrame)
    {
        fbb_.AddOffset(Frame::VT_BLENDFRAME, blendFrame);
    }
    explicit FrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    FrameBuilder& operator=(const FrameBuilder&);
    flatbuffers::Offset<Frame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<Frame>(end);
        return o;
    }
};

inline flatbuffers::Offset<Frame> CreateFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                              flatbuffers::Offset<PointFrame> pointFrame             = 0,
                                              flatbuffers::Offset<ScaleFrame> scaleFrame             = 0,
                                              flatbuffers::Offset<ColorFrame> colorFrame             = 0,
                                              flatbuffers::Offset<TextureFrame> textureFrame         = 0,
                                              flatbuffers::Offset<EventFrame> eventFrame             = 0,
                                              flatbuffers::Offset<IntFrame> intFrame                 = 0,
                                              flatbuffers::Offset<BoolFrame> boolFrame               = 0,
                                              flatbuffers::Offset<InnerActionFrame> innerActionFrame = 0,
                                              flatbuffers::Offset<BlendFrame> blendFrame             = 0)
{
    FrameBuilder builder_(_fbb);
    builder_.add_blendFrame(blendFrame);
    builder_.add_innerActionFrame(innerActionFrame);
    builder_.add_boolFrame(boolFrame);
    builder_.add_intFrame(intFrame);
    builder_.add_eventFrame(eventFrame);
    builder_.add_textureFrame(textureFrame);
    builder_.add_colorFrame(colorFrame);
    builder_.add_scaleFrame(scaleFrame);
    builder_.add_pointFrame(pointFrame);
    return builder_.Finish();
}

struct PointFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_POSITION   = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    const FVec2* position() const { return GetStruct<const FVec2*>(VT_POSITION); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<FVec2>(verifier, VT_POSITION) &&
               VerifyOffset(verifier, VT_EASINGDATA) && verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct PointFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(PointFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(PointFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_position(const FVec2* position) { fbb_.AddStruct(PointFrame::VT_POSITION, position); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(PointFrame::VT_EASINGDATA, easingData);
    }
    explicit PointFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    PointFrameBuilder& operator=(const PointFrameBuilder&);
    flatbuffers::Offset<PointFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<PointFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<PointFrame> CreatePointFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                        int32_t frameIndex                         = 0,
                                                        bool tween                                 = true,
                                                        const FVec2* position                      = 0,
                                                        flatbuffers::Offset<EasingData> easingData = 0)
{
    PointFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_position(position);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

struct ScaleFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_SCALE      = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    const Scale* scale() const { return GetStruct<const Scale*>(VT_SCALE); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<Scale>(verifier, VT_SCALE) &&
               VerifyOffset(verifier, VT_EASINGDATA) && verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct ScaleFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(ScaleFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(ScaleFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_scale(const Scale* scale) { fbb_.AddStruct(ScaleFrame::VT_SCALE, scale); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(ScaleFrame::VT_EASINGDATA, easingData);
    }
    explicit ScaleFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ScaleFrameBuilder& operator=(const ScaleFrameBuilder&);
    flatbuffers::Offset<ScaleFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ScaleFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<ScaleFrame> CreateScaleFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                        int32_t frameIndex                         = 0,
                                                        bool tween                                 = true,
                                                        const Scale* scale                         = 0,
                                                        flatbuffers::Offset<EasingData> easingData = 0)
{
    ScaleFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_scale(scale);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

struct ColorFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_COLOR      = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    const Color* color() const { return GetStruct<const Color*>(VT_COLOR); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<Color>(verifier, VT_COLOR) &&
               VerifyOffset(verifier, VT_EASINGDATA) && verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct ColorFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(ColorFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(ColorFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_color(const Color* color) { fbb_.AddStruct(ColorFrame::VT_COLOR, color); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(ColorFrame::VT_EASINGDATA, easingData);
    }
    explicit ColorFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ColorFrameBuilder& operator=(const ColorFrameBuilder&);
    flatbuffers::Offset<ColorFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ColorFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<ColorFrame> CreateColorFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                        int32_t frameIndex                         = 0,
                                                        bool tween                                 = true,
                                                        const Color* color                         = 0,
                                                        flatbuffers::Offset<EasingData> easingData = 0)
{
    ColorFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_color(color);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

struct TextureFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX  = 4,
        VT_TWEEN       = 6,
        VT_TEXTUREFILE = 8,
        VT_EASINGDATA  = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    const ResourceData* textureFile() const { return GetPointer<const ResourceData*>(VT_TEXTUREFILE); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyOffset(verifier, VT_TEXTUREFILE) &&
               verifier.VerifyTable(textureFile()) && VerifyOffset(verifier, VT_EASINGDATA) &&
               verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct TextureFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(TextureFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(TextureFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_textureFile(flatbuffers::Offset<ResourceData> textureFile)
    {
        fbb_.AddOffset(TextureFrame::VT_TEXTUREFILE, textureFile);
    }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(TextureFrame::VT_EASINGDATA, easingData);
    }
    explicit TextureFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    TextureFrameBuilder& operator=(const TextureFrameBuilder&);
    flatbuffers::Offset<TextureFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<TextureFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<TextureFrame> CreateTextureFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                            int32_t frameIndex                            = 0,
                                                            bool tween                                    = true,
                                                            flatbuffers::Offset<ResourceData> textureFile = 0,
                                                            flatbuffers::Offset<EasingData> easingData    = 0)
{
    TextureFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_textureFile(textureFile);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

struct EventFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_VALUE      = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    const flatbuffers::String* value() const { return GetPointer<const flatbuffers::String*>(VT_VALUE); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyOffset(verifier, VT_VALUE) &&
               verifier.VerifyString(value()) && VerifyOffset(verifier, VT_EASINGDATA) &&
               verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct EventFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(EventFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(EventFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(EventFrame::VT_VALUE, value); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(EventFrame::VT_EASINGDATA, easingData);
    }
    explicit EventFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    EventFrameBuilder& operator=(const EventFrameBuilder&);
    flatbuffers::Offset<EventFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<EventFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<EventFrame> CreateEventFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                        int32_t frameIndex                             = 0,
                                                        bool tween                                     = true,
                                                        flatbuffers::Offset<flatbuffers::String> value = 0,
                                                        flatbuffers::Offset<EasingData> easingData     = 0)
{
    EventFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_value(value);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

inline flatbuffers::Offset<EventFrame> CreateEventFrameDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                              int32_t frameIndex                         = 0,
                                                              bool tween                                 = true,
                                                              const char* value                          = nullptr,
                                                              flatbuffers::Offset<EasingData> easingData = 0)
{
    auto value__ = value ? _fbb.CreateString(value) : 0;
    return flatbuffers::CreateEventFrame(_fbb, frameIndex, tween, value__, easingData);
}

struct IntFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_VALUE      = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    int32_t value() const { return GetField<int32_t>(VT_VALUE, 0); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<int32_t>(verifier, VT_VALUE) &&
               VerifyOffset(verifier, VT_EASINGDATA) && verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct IntFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(IntFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(IntFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_value(int32_t value) { fbb_.AddElement<int32_t>(IntFrame::VT_VALUE, value, 0); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(IntFrame::VT_EASINGDATA, easingData);
    }
    explicit IntFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    IntFrameBuilder& operator=(const IntFrameBuilder&);
    flatbuffers::Offset<IntFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<IntFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<IntFrame> CreateIntFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                    int32_t frameIndex                         = 0,
                                                    bool tween                                 = true,
                                                    int32_t value                              = 0,
                                                    flatbuffers::Offset<EasingData> easingData = 0)
{
    IntFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_value(value);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

struct BoolFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_VALUE      = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    bool value() const { return GetField<uint8_t>(VT_VALUE, 1) != 0; }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<uint8_t>(verifier, VT_VALUE) &&
               VerifyOffset(verifier, VT_EASINGDATA) && verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct BoolFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(BoolFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(BoolFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_value(bool value) { fbb_.AddElement<uint8_t>(BoolFrame::VT_VALUE, static_cast<uint8_t>(value), 1); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(BoolFrame::VT_EASINGDATA, easingData);
    }
    explicit BoolFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    BoolFrameBuilder& operator=(const BoolFrameBuilder&);
    flatbuffers::Offset<BoolFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<BoolFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<BoolFrame> CreateBoolFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                      int32_t frameIndex                         = 0,
                                                      bool tween                                 = true,
                                                      bool value                                 = true,
                                                      flatbuffers::Offset<EasingData> easingData = 0)
{
    BoolFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_frameIndex(frameIndex);
    builder_.add_value(value);
    builder_.add_tween(tween);
    return builder_.Finish();
}

struct InnerActionFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX           = 4,
        VT_TWEEN                = 6,
        VT_INNERACTIONTYPE      = 8,
        VT_CURRENTANIAMTIONNAME = 10,
        VT_SINGLEFRAMEINDEX     = 12,
        VT_EASINGDATA           = 14
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    int32_t innerActionType() const { return GetField<int32_t>(VT_INNERACTIONTYPE, 0); }
    const flatbuffers::String* currentAniamtionName() const
    {
        return GetPointer<const flatbuffers::String*>(VT_CURRENTANIAMTIONNAME);
    }
    int32_t singleFrameIndex() const { return GetField<int32_t>(VT_SINGLEFRAMEINDEX, 0); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<int32_t>(verifier, VT_INNERACTIONTYPE) &&
               VerifyOffset(verifier, VT_CURRENTANIAMTIONNAME) && verifier.VerifyString(currentAniamtionName()) &&
               VerifyField<int32_t>(verifier, VT_SINGLEFRAMEINDEX) && VerifyOffset(verifier, VT_EASINGDATA) &&
               verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct InnerActionFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex)
    {
        fbb_.AddElement<int32_t>(InnerActionFrame::VT_FRAMEINDEX, frameIndex, 0);
    }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(InnerActionFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_innerActionType(int32_t innerActionType)
    {
        fbb_.AddElement<int32_t>(InnerActionFrame::VT_INNERACTIONTYPE, innerActionType, 0);
    }
    void add_currentAniamtionName(flatbuffers::Offset<flatbuffers::String> currentAniamtionName)
    {
        fbb_.AddOffset(InnerActionFrame::VT_CURRENTANIAMTIONNAME, currentAniamtionName);
    }
    void add_singleFrameIndex(int32_t singleFrameIndex)
    {
        fbb_.AddElement<int32_t>(InnerActionFrame::VT_SINGLEFRAMEINDEX, singleFrameIndex, 0);
    }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(InnerActionFrame::VT_EASINGDATA, easingData);
    }
    explicit InnerActionFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    InnerActionFrameBuilder& operator=(const InnerActionFrameBuilder&);
    flatbuffers::Offset<InnerActionFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<InnerActionFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<InnerActionFrame> CreateInnerActionFrame(
    flatbuffers::FlatBufferBuilder& _fbb,
    int32_t frameIndex                                            = 0,
    bool tween                                                    = true,
    int32_t innerActionType                                       = 0,
    flatbuffers::Offset<flatbuffers::String> currentAniamtionName = 0,
    int32_t singleFrameIndex                                      = 0,
    flatbuffers::Offset<EasingData> easingData                    = 0)
{
    InnerActionFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_singleFrameIndex(singleFrameIndex);
    builder_.add_currentAniamtionName(currentAniamtionName);
    builder_.add_innerActionType(innerActionType);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

inline flatbuffers::Offset<InnerActionFrame> CreateInnerActionFrameDirect(
    flatbuffers::FlatBufferBuilder& _fbb,
    int32_t frameIndex                         = 0,
    bool tween                                 = true,
    int32_t innerActionType                    = 0,
    const char* currentAniamtionName           = nullptr,
    int32_t singleFrameIndex                   = 0,
    flatbuffers::Offset<EasingData> easingData = 0)
{
    auto currentAniamtionName__ = currentAniamtionName ? _fbb.CreateString(currentAniamtionName) : 0;
    return flatbuffers::CreateInnerActionFrame(_fbb, frameIndex, tween, innerActionType, currentAniamtionName__,
                                               singleFrameIndex, easingData);
}

struct EasingData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_TYPE   = 4,
        VT_POINTS = 6
    };
    int32_t type() const { return GetField<int32_t>(VT_TYPE, -1); }
    const flatbuffers::Vector<const FVec2*>* points() const
    {
        return GetPointer<const flatbuffers::Vector<const FVec2*>*>(VT_POINTS);
    }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_TYPE) &&
               VerifyOffset(verifier, VT_POINTS) && verifier.VerifyVector(points()) && verifier.EndTable();
    }
};

struct EasingDataBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_type(int32_t type) { fbb_.AddElement<int32_t>(EasingData::VT_TYPE, type, -1); }
    void add_points(flatbuffers::Offset<flatbuffers::Vector<const FVec2*>> points)
    {
        fbb_.AddOffset(EasingData::VT_POINTS, points);
    }
    explicit EasingDataBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    EasingDataBuilder& operator=(const EasingDataBuilder&);
    flatbuffers::Offset<EasingData> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<EasingData>(end);
        return o;
    }
};

inline flatbuffers::Offset<EasingData> CreateEasingData(
    flatbuffers::FlatBufferBuilder& _fbb,
    int32_t type                                                  = -1,
    flatbuffers::Offset<flatbuffers::Vector<const FVec2*>> points = 0)
{
    EasingDataBuilder builder_(_fbb);
    builder_.add_points(points);
    builder_.add_type(type);
    return builder_.Finish();
}

inline flatbuffers::Offset<EasingData> CreateEasingDataDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                              int32_t type                     = -1,
                                                              const std::vector<FVec2>* points = nullptr)
{
    auto points__ = points ? _fbb.CreateVectorOfStructs<FVec2>(*points) : 0;
    return flatbuffers::CreateEasingData(_fbb, type, points__);
}

struct ResourceData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_PATH         = 4,
        VT_PLISTFILE    = 6,
        VT_RESOURCETYPE = 8
    };
    const flatbuffers::String* path() const { return GetPointer<const flatbuffers::String*>(VT_PATH); }
    const flatbuffers::String* plistFile() const { return GetPointer<const flatbuffers::String*>(VT_PLISTFILE); }
    int32_t resourceType() const { return GetField<int32_t>(VT_RESOURCETYPE, 0); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_PATH) && verifier.VerifyString(path()) &&
               VerifyOffset(verifier, VT_PLISTFILE) && verifier.VerifyString(plistFile()) &&
               VerifyField<int32_t>(verifier, VT_RESOURCETYPE) && verifier.EndTable();
    }
};

struct ResourceDataBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_path(flatbuffers::Offset<flatbuffers::String> path) { fbb_.AddOffset(ResourceData::VT_PATH, path); }
    void add_plistFile(flatbuffers::Offset<flatbuffers::String> plistFile)
    {
        fbb_.AddOffset(ResourceData::VT_PLISTFILE, plistFile);
    }
    void add_resourceType(int32_t resourceType)
    {
        fbb_.AddElement<int32_t>(ResourceData::VT_RESOURCETYPE, resourceType, 0);
    }
    explicit ResourceDataBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    ResourceDataBuilder& operator=(const ResourceDataBuilder&);
    flatbuffers::Offset<ResourceData> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<ResourceData>(end);
        return o;
    }
};

inline flatbuffers::Offset<ResourceData> CreateResourceData(flatbuffers::FlatBufferBuilder& _fbb,
                                                            flatbuffers::Offset<flatbuffers::String> path      = 0,
                                                            flatbuffers::Offset<flatbuffers::String> plistFile = 0,
                                                            int32_t resourceType                               = 0)
{
    ResourceDataBuilder builder_(_fbb);
    builder_.add_resourceType(resourceType);
    builder_.add_plistFile(plistFile);
    builder_.add_path(path);
    return builder_.Finish();
}

inline flatbuffers::Offset<ResourceData> CreateResourceDataDirect(flatbuffers::FlatBufferBuilder& _fbb,
                                                                  const char* path      = nullptr,
                                                                  const char* plistFile = nullptr,
                                                                  int32_t resourceType  = 0)
{
    auto path__      = path ? _fbb.CreateString(path) : 0;
    auto plistFile__ = plistFile ? _fbb.CreateString(plistFile) : 0;
    return flatbuffers::CreateResourceData(_fbb, path__, plistFile__, resourceType);
}

struct BlendFrame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
    {
        VT_FRAMEINDEX = 4,
        VT_TWEEN      = 6,
        VT_BLENDFUNC  = 8,
        VT_EASINGDATA = 10
    };
    int32_t frameIndex() const { return GetField<int32_t>(VT_FRAMEINDEX, 0); }
    bool tween() const { return GetField<uint8_t>(VT_TWEEN, 1) != 0; }
    const BlendFunc* blendFunc() const { return GetStruct<const BlendFunc*>(VT_BLENDFUNC); }
    const EasingData* easingData() const { return GetPointer<const EasingData*>(VT_EASINGDATA); }
    bool Verify(flatbuffers::Verifier& verifier) const
    {
        return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_FRAMEINDEX) &&
               VerifyField<uint8_t>(verifier, VT_TWEEN) && VerifyField<BlendFunc>(verifier, VT_BLENDFUNC) &&
               VerifyOffset(verifier, VT_EASINGDATA) && verifier.VerifyTable(easingData()) && verifier.EndTable();
    }
};

struct BlendFrameBuilder
{
    flatbuffers::FlatBufferBuilder& fbb_;
    flatbuffers::uoffset_t start_;
    void add_frameIndex(int32_t frameIndex) { fbb_.AddElement<int32_t>(BlendFrame::VT_FRAMEINDEX, frameIndex, 0); }
    void add_tween(bool tween) { fbb_.AddElement<uint8_t>(BlendFrame::VT_TWEEN, static_cast<uint8_t>(tween), 1); }
    void add_blendFunc(const BlendFunc* blendFunc) { fbb_.AddStruct(BlendFrame::VT_BLENDFUNC, blendFunc); }
    void add_easingData(flatbuffers::Offset<EasingData> easingData)
    {
        fbb_.AddOffset(BlendFrame::VT_EASINGDATA, easingData);
    }
    explicit BlendFrameBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
    BlendFrameBuilder& operator=(const BlendFrameBuilder&);
    flatbuffers::Offset<BlendFrame> Finish()
    {
        const auto end = fbb_.EndTable(start_);
        auto o         = flatbuffers::Offset<BlendFrame>(end);
        return o;
    }
};

inline flatbuffers::Offset<BlendFrame> CreateBlendFrame(flatbuffers::FlatBufferBuilder& _fbb,
                                                        int32_t frameIndex                         = 0,
                                                        bool tween                                 = true,
                                                        const BlendFunc* blendFunc                 = 0,
                                                        flatbuffers::Offset<EasingData> easingData = 0)
{
    BlendFrameBuilder builder_(_fbb);
    builder_.add_easingData(easingData);
    builder_.add_blendFunc(blendFunc);
    builder_.add_frameIndex(frameIndex);
    builder_.add_tween(tween);
    return builder_.Finish();
}

inline const flatbuffers::CSParseBinary* GetCSParseBinary(const void* buf)
{
    return flatbuffers::GetRoot<flatbuffers::CSParseBinary>(buf);
}

inline const flatbuffers::CSParseBinary* GetSizePrefixedCSParseBinary(const void* buf)
{
    return flatbuffers::GetSizePrefixedRoot<flatbuffers::CSParseBinary>(buf);
}

inline bool VerifyCSParseBinaryBuffer(flatbuffers::Verifier& verifier)
{
    return verifier.VerifyBuffer<flatbuffers::CSParseBinary>(nullptr);
}

inline bool VerifySizePrefixedCSParseBinaryBuffer(flatbuffers::Verifier& verifier)
{
    return verifier.VerifySizePrefixedBuffer<flatbuffers::CSParseBinary>(nullptr);
}

inline void FinishCSParseBinaryBuffer(flatbuffers::FlatBufferBuilder& fbb,
                                      flatbuffers::Offset<flatbuffers::CSParseBinary> root)
{
    fbb.Finish(root);
}

inline void FinishSizePrefixedCSParseBinaryBuffer(flatbuffers::FlatBufferBuilder& fbb,
                                                  flatbuffers::Offset<flatbuffers::CSParseBinary> root)
{
    fbb.FinishSizePrefixed(root);
}

}  // namespace flatbuffers

#endif  // FLATBUFFERS_GENERATED_CSPARSEBINARY_FLATBUFFERS_H_