// clang-format off

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.1.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

/****************************************************************************
 Copyright (c) 2022-2023 Xiamen Yaji Software Co., Ltd.

 http://www.cocos.com

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 of the Software, and to permit persons to whom the Software is furnished to do so,
 subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
****************************************************************************/

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
#elif defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
#elif defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4101)
#endif


#define SWIG_STD_MOVE(OBJ) std::move(OBJ)


#include <stdio.h>


#include "bindings/jswrapper/SeApi.h"
#include "bindings/manual/jsb_conversions.h"
#include "bindings/manual/jsb_global.h"


#include "bindings/auto/jsb_cocos_auto.h"
#include "bindings/auto/jsb_gfx_auto.h"


#define cc_ICanvasRenderingContext2D_width_set(self_, val_) self_->setWidth(val_)
  

#define cc_ICanvasRenderingContext2D_height_set(self_, val_) self_->setHeight(val_)
  

#define cc_ICanvasRenderingContext2D_lineWidth_set(self_, val_) self_->setLineWidth(val_)
  

#define cc_ICanvasRenderingContext2D_fillStyle_set(self_, val_) self_->setFillStyle(val_)
  

#define cc_ICanvasRenderingContext2D_font_set(self_, val_) self_->setFont(val_)
  

#define cc_ICanvasRenderingContext2D_globalCompositeOperation_set(self_, val_) self_->setGlobalCompositeOperation(val_)
  

#define cc_ICanvasRenderingContext2D_lineCap_set(self_, val_) self_->setLineCap(val_)
  

#define cc_ICanvasRenderingContext2D_strokeStyle_set(self_, val_) self_->setStrokeStyle(val_)
  

#define cc_ICanvasRenderingContext2D_lineJoin_set(self_, val_) self_->setLineJoin(val_)
  

#define cc_ICanvasRenderingContext2D_textAlign_set(self_, val_) self_->setTextAlign(val_)
  

#define cc_ICanvasRenderingContext2D_textBaseline_set(self_, val_) self_->setTextBaseline(val_)
  

#define cc_CCObject_name_get(self_) self_->getName()
#define cc_CCObject_name_set(self_, val_) self_->setName(val_)
  

#define cc_CCObject_hideFlags_get(self_) self_->getHideFlags()
#define cc_CCObject_hideFlags_set(self_, val_) self_->setHideFlags(val_)
  

#define cc_CCObject_isValid_get(self_) self_->isValid()
  


static bool js_cc_clampf(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    float arg1 ;
    float arg2 ;
    float arg3 ;
    float result;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (float)cc::clampf(arg1,arg2,arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_clampf) 

se::Class* __jsb_cc_Vec2_class = nullptr;
se::Object* __jsb_cc_Vec2_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec2) 

static bool js_new_cc_Vec2__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec2 *result;
    result = (cc::Vec2 *)new cc::Vec2();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec2__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float arg1 ;
    float arg2 ;
    cc::Vec2 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Vec2 *)new cc::Vec2(arg1,arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec2__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float *arg1 = (float *) NULL ;
    cc::Vec2 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Vec2 *)new cc::Vec2((float const *)arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec2__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec2 *arg1 = 0 ;
    cc::Vec2 *arg2 = 0 ;
    cc::Vec2 temp1 ;
    cc::Vec2 temp2 ;
    cc::Vec2 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    
    ok &= sevalue_to_native(args[1], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (cc::Vec2 *)new cc::Vec2((cc::Vec2 const &)*arg1,(cc::Vec2 const &)*arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec2__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec2 *arg1 = 0 ;
    cc::Vec2 temp1 ;
    cc::Vec2 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Vec2 *)new cc::Vec2((cc::Vec2 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec2(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Vec2__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_Vec2__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Vec2__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_Vec2__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Vec2__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Vec2");
    return false;
}
SE_BIND_CTOR(js_new_cc_Vec2, __jsb_cc_Vec2_class, js_delete_cc_Vec2)

static bool js_delete_cc_Vec2(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec2) 

bool js_register_cc_Vec2(se::Object* obj) {
    auto* cls = se::Class::create("Vec2", obj, nullptr, _SE(js_new_cc_Vec2)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Vec2));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Vec2>(cls);
    
    __jsb_cc_Vec2_proto = cls->getProto();
    __jsb_cc_Vec2_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Color_class = nullptr;
se::Object* __jsb_cc_Color_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Color) 

static bool js_new_cc_Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Color *result;
    result = (cc::Color *)new cc::Color();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    uint8_t arg1 ;
    uint8_t arg2 ;
    uint8_t arg3 ;
    uint8_t arg4 ;
    cc::Color *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (cc::Color *)new cc::Color(arg1,arg2,arg3,arg4);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Color__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    uint8_t *arg1 = (uint8_t *) NULL ;
    cc::Color *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Color *)new cc::Color((uint8_t const *)arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Color__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    uint32_t arg1 ;
    cc::Color *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (cc::Color *)new cc::Color(arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Color__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Color *arg1 = 0 ;
    cc::Color *arg2 = 0 ;
    cc::Color temp1 ;
    cc::Color temp2 ;
    cc::Color *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    
    ok &= sevalue_to_native(args[1], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (cc::Color *)new cc::Color((cc::Color const &)*arg1,(cc::Color const &)*arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Color__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Color *arg1 = 0 ;
    cc::Color temp1 ;
    cc::Color *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Color *)new cc::Color((cc::Color const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Color(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Color__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 4) {
        ret = js_new_cc_Color__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Color__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Color__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_Color__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Color__SWIG_5(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Color");
    return false;
}
SE_BIND_CTOR(js_new_cc_Color, __jsb_cc_Color_class, js_delete_cc_Color)

static bool js_delete_cc_Color(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Color) 

bool js_register_cc_Color(se::Object* obj) {
    auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_cc_Color)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Color));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Color>(cls);
    
    __jsb_cc_Color_proto = cls->getProto();
    __jsb_cc_Color_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Vec3_class = nullptr;
se::Object* __jsb_cc_Vec3_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec3) 

static bool js_new_cc_Vec3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec3 *result;
    result = (cc::Vec3 *)new cc::Vec3();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float arg1 ;
    float arg2 ;
    float arg3 ;
    cc::Vec3 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Vec3 *)new cc::Vec3(arg1,arg2,arg3);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec3__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float *arg1 = (float *) NULL ;
    cc::Vec3 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Vec3 *)new cc::Vec3((float const *)arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec3__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec3 *arg1 = 0 ;
    cc::Vec3 *arg2 = 0 ;
    cc::Vec3 temp1 ;
    cc::Vec3 temp2 ;
    cc::Vec3 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    
    ok &= sevalue_to_native(args[1], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (cc::Vec3 *)new cc::Vec3((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec3__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec3 *arg1 = 0 ;
    cc::Vec3 temp1 ;
    cc::Vec3 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Vec3 *)new cc::Vec3((cc::Vec3 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec3(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Vec3__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 3) {
        ret = js_new_cc_Vec3__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Vec3__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_Vec3__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Vec3__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Vec3");
    return false;
}
SE_BIND_CTOR(js_new_cc_Vec3, __jsb_cc_Vec3_class, js_delete_cc_Vec3)

static bool js_delete_cc_Vec3(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec3) 

bool js_register_cc_Vec3(se::Object* obj) {
    auto* cls = se::Class::create("Vec3", obj, nullptr, _SE(js_new_cc_Vec3)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Vec3));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Vec3>(cls);
    
    __jsb_cc_Vec3_proto = cls->getProto();
    __jsb_cc_Vec3_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Vec4_class = nullptr;
se::Object* __jsb_cc_Vec4_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec4) 

static bool js_new_cc_Vec4__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec4 *result;
    result = (cc::Vec4 *)new cc::Vec4();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec4__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float arg1 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    cc::Vec4 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Vec4 *)new cc::Vec4(arg1,arg2,arg3,arg4);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec4__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float *arg1 = (float *) NULL ;
    cc::Vec4 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Vec4 *)new cc::Vec4((float const *)arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec4__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec4 *arg1 = 0 ;
    cc::Vec4 *arg2 = 0 ;
    cc::Vec4 temp1 ;
    cc::Vec4 temp2 ;
    cc::Vec4 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    
    ok &= sevalue_to_native(args[1], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (cc::Vec4 *)new cc::Vec4((cc::Vec4 const &)*arg1,(cc::Vec4 const &)*arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec4__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec4 *arg1 = 0 ;
    cc::Vec4 temp1 ;
    cc::Vec4 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Vec4 *)new cc::Vec4((cc::Vec4 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Vec4(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Vec4__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 4) {
        ret = js_new_cc_Vec4__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Vec4__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_Vec4__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Vec4__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Vec4");
    return false;
}
SE_BIND_CTOR(js_new_cc_Vec4, __jsb_cc_Vec4_class, js_delete_cc_Vec4)

static bool js_delete_cc_Vec4(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec4) 

bool js_register_cc_Vec4(se::Object* obj) {
    auto* cls = se::Class::create("Vec4", obj, nullptr, _SE(js_new_cc_Vec4)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Vec4));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Vec4>(cls);
    
    __jsb_cc_Vec4_proto = cls->getProto();
    __jsb_cc_Vec4_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Mat3_class = nullptr;
se::Object* __jsb_cc_Mat3_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mat3) 

static bool js_new_cc_Mat3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Mat3 *result;
    result = (cc::Mat3 *)new cc::Mat3();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float arg1 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    float arg6 ;
    float arg7 ;
    float arg8 ;
    float arg9 ;
    cc::Mat3 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[5], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[6], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[7], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[8], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Mat3 *)new cc::Mat3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat3__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float *arg1 = (float *) NULL ;
    cc::Mat3 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Mat3 *)new cc::Mat3((float const *)arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat3__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Mat3 *arg1 = 0 ;
    cc::Mat3 temp1 ;
    cc::Mat3 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Mat3 *)new cc::Mat3((cc::Mat3 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat3__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Mat4 *arg1 = 0 ;
    cc::Mat4 temp1 ;
    cc::Mat3 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Mat3 *)new cc::Mat3((cc::Mat4 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat3__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Quaternion *arg1 = 0 ;
    cc::Quaternion temp1 ;
    cc::Mat3 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Mat3 *)new cc::Mat3((cc::Quaternion const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat3(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Mat3__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 9) {
        ret = js_new_cc_Mat3__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Mat3__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Mat3__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Mat3__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Mat3__SWIG_5(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Mat3");
    return false;
}
SE_BIND_CTOR(js_new_cc_Mat3, __jsb_cc_Mat3_class, js_delete_cc_Mat3)

static bool js_delete_cc_Mat3(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Mat3) 

bool js_register_cc_Mat3(se::Object* obj) {
    auto* cls = se::Class::create("Mat3", obj, nullptr, _SE(js_new_cc_Mat3)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Mat3));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Mat3>(cls);
    
    __jsb_cc_Mat3_proto = cls->getProto();
    __jsb_cc_Mat3_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Mat4_class = nullptr;
se::Object* __jsb_cc_Mat4_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mat4) 

static bool js_new_cc_Mat4__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Mat4 *result;
    result = (cc::Mat4 *)new cc::Mat4();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat4__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float arg1 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    float arg6 ;
    float arg7 ;
    float arg8 ;
    float arg9 ;
    float arg10 ;
    float arg11 ;
    float arg12 ;
    float arg13 ;
    float arg14 ;
    float arg15 ;
    float arg16 ;
    cc::Mat4 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[5], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[6], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[7], &arg8, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[8], &arg9, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[9], &arg10, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[10], &arg11, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[11], &arg12, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[12], &arg13, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[13], &arg14, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[14], &arg15, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[15], &arg16, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Mat4 *)new cc::Mat4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat4__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float *arg1 = (float *) NULL ;
    cc::Mat4 *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Mat4 *)new cc::Mat4((float const *)arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat4__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Mat4 *arg1 = 0 ;
    cc::Mat4 temp1 ;
    cc::Mat4 *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Mat4 *)new cc::Mat4((cc::Mat4 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Mat4(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Mat4__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 16) {
        ret = js_new_cc_Mat4__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Mat4__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Mat4__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Mat4");
    return false;
}
SE_BIND_CTOR(js_new_cc_Mat4, __jsb_cc_Mat4_class, js_delete_cc_Mat4)

static bool js_delete_cc_Mat4(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Mat4) 

bool js_register_cc_Mat4(se::Object* obj) {
    auto* cls = se::Class::create("Mat4", obj, nullptr, _SE(js_new_cc_Mat4)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Mat4));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Mat4>(cls);
    
    __jsb_cc_Mat4_proto = cls->getProto();
    __jsb_cc_Mat4_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Quaternion_class = nullptr;
se::Object* __jsb_cc_Quaternion_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Quaternion) 

static bool js_new_cc_Quaternion__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Quaternion *result;
    result = (cc::Quaternion *)new cc::Quaternion();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Quaternion__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float arg1 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    cc::Quaternion *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Quaternion *)new cc::Quaternion(arg1,arg2,arg3,arg4);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Quaternion__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    float *arg1 = (float *) NULL ;
    cc::Quaternion *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Quaternion *)new cc::Quaternion(arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Quaternion__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Mat4 *arg1 = 0 ;
    cc::Mat4 temp1 ;
    cc::Quaternion *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    result = (cc::Quaternion *)new cc::Quaternion((cc::Mat4 const &)*arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Quaternion__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::Vec3 *arg1 = 0 ;
    float arg2 ;
    cc::Vec3 temp1 ;
    cc::Quaternion *result;
    
    ok &= sevalue_to_native(args[0], &temp1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg1 = &temp1;
    
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::Quaternion *)new cc::Quaternion((cc::Vec3 const &)*arg1,arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_Quaternion(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_Quaternion__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 4) {
        ret = js_new_cc_Quaternion__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Quaternion__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_Quaternion__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_Quaternion__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Quat");
    return false;
}
SE_BIND_CTOR(js_new_cc_Quaternion, __jsb_cc_Quaternion_class, js_delete_cc_Quaternion)

static bool js_delete_cc_Quaternion(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Quaternion) 

bool js_register_cc_Quaternion(se::Object* obj) {
    auto* cls = se::Class::create("Quat", obj, nullptr, _SE(js_new_cc_Quaternion)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Quaternion));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Quaternion>(cls);
    
    __jsb_cc_Quaternion_proto = cls->getProto();
    __jsb_cc_Quaternion_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_CCObject_class = nullptr;
se::Object* __jsb_cc_CCObject_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CCObject) 

static bool js_cc_CCObject_deferredDestroy_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    cc::CCObject::deferredDestroy();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_CCObject_deferredDestroy_static) 

static bool js_cc_CCObject__objFlags_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_objFlags, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CCObject__objFlags_set) 

static bool js_cc_CCObject__objFlags_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_objFlags, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_objFlags, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CCObject__objFlags_get) 

static bool js_cc_CCObject__name_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_name, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CCObject__name_set) 

static bool js_cc_CCObject__name_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_name, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_name, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CCObject__name_get) 

static bool js_new_cc_CCObject__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    ccstd::string arg1 ;
    cc::CCObject *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (cc::CCObject *)new cc::CCObject(arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_CCObject__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::CCObject *result;
    result = (cc::CCObject *)new cc::CCObject();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_CCObject(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 1) {
        ret = js_new_cc_CCObject__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 0) {
        ret = js_new_cc_CCObject__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of CCObject");
    return false;
}
SE_BIND_CTOR(js_new_cc_CCObject, __jsb_cc_CCObject_class, js_delete_cc_CCObject)

static bool js_delete_cc_CCObject(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_CCObject) 

static bool js_cc_CCObject_destruct(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    (arg1)->destruct();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_CCObject_destruct) 

static bool js_cc_CCObject__destroy(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    bool result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    result = (bool)(arg1)->destroy();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_CCObject__destroy) 

static bool js_cc_CCObject__destroyImmediate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    (arg1)->destroyImmediate();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_CCObject__destroyImmediate) 

static bool js_cc_CCObject_toString(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    ccstd::string result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    result = ((cc::CCObject const *)arg1)->toString();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_CCObject_toString) 

static bool js_cc_CCObject_name_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_CCObject_name_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CCObject_name_set) 

static bool js_cc_CCObject_name_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    ccstd::string *result = 0 ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::string *) &cc_CCObject_name_get(arg1);
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CCObject_name_get) 

static bool js_cc_CCObject_hideFlags_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    cc::CCObject::Flags arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    cc_CCObject_hideFlags_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CCObject_hideFlags_set) 

static bool js_cc_CCObject_hideFlags_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    cc::CCObject::Flags result;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    result = (cc::CCObject::Flags)cc_CCObject_hideFlags_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CCObject_hideFlags_get) 

static bool js_cc_CCObject_isValid_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::CCObject>(s);
    if (nullptr == arg1) return true;
    result = (bool)cc_CCObject_isValid_get(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CCObject_isValid_get) 

bool js_register_cc_CCObject(se::Object* obj) {
    auto* cls = se::Class::create("CCObject", obj, nullptr, _SE(js_new_cc_CCObject)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("_objFlags", _SE(js_cc_CCObject__objFlags_get), _SE(js_cc_CCObject__objFlags_set)); 
    cls->defineProperty("_name", _SE(js_cc_CCObject__name_get), _SE(js_cc_CCObject__name_set)); 
    cls->defineProperty("name", _SE(js_cc_CCObject_name_get), _SE(js_cc_CCObject_name_set)); 
    cls->defineProperty("hideFlags", _SE(js_cc_CCObject_hideFlags_get), _SE(js_cc_CCObject_hideFlags_set)); 
    cls->defineProperty("isValid", _SE(js_cc_CCObject_isValid_get), nullptr); 
    
    cls->defineFunction("destruct", _SE(js_cc_CCObject_destruct)); 
    cls->defineFunction("_destroy", _SE(js_cc_CCObject__destroy)); 
    cls->defineFunction("_destroyImmediate", _SE(js_cc_CCObject__destroyImmediate)); 
    cls->defineFunction("toString", _SE(js_cc_CCObject_toString)); 
    
    
    cls->defineStaticFunction("deferredDestroy", _SE(js_cc_CCObject_deferredDestroy_static)); 
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_CCObject));
    
    
    cls->install();
    JSBClassType::registerClass<cc::CCObject>(cls);
    
    __jsb_cc_CCObject_proto = cls->getProto();
    __jsb_cc_CCObject_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


static bool js_cc_isObjectValid__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    bool arg2 ;
    bool result;
    
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)cc::isObjectValid(arg1,arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_isObjectValid__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::CCObject *arg1 = (cc::CCObject *) NULL ;
    bool result;
    
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)cc::isObjectValid(arg1);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_isObjectValid(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 2) {
        ok = js_cc_isObjectValid__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_isObjectValid__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_isObjectValid) 

se::Class* __jsb_cc_JSBNativeDataHolder_class = nullptr;
se::Object* __jsb_cc_JSBNativeDataHolder_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_JSBNativeDataHolder) 

static bool js_new_cc_JSBNativeDataHolder__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    cc::JSBNativeDataHolder *result;
    result = (cc::JSBNativeDataHolder *)new cc::JSBNativeDataHolder();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_JSBNativeDataHolder__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    uint8_t *arg1 = (uint8_t *) NULL ;
    cc::JSBNativeDataHolder *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::JSBNativeDataHolder *)new cc::JSBNativeDataHolder(arg1);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_JSBNativeDataHolder(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 0) {
        ret = js_new_cc_JSBNativeDataHolder__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 1) {
        ret = js_new_cc_JSBNativeDataHolder__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of JSBNativeDataHolder");
    return false;
}
SE_BIND_CTOR(js_new_cc_JSBNativeDataHolder, __jsb_cc_JSBNativeDataHolder_class, js_delete_cc_JSBNativeDataHolder)

static bool js_delete_cc_JSBNativeDataHolder(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_JSBNativeDataHolder) 

static bool js_cc_JSBNativeDataHolder_destroy(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::JSBNativeDataHolder *arg1 = (cc::JSBNativeDataHolder *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::JSBNativeDataHolder>(s);
    if (nullptr == arg1) return true;
    (arg1)->destroy();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_JSBNativeDataHolder_destroy) 

bool js_register_cc_JSBNativeDataHolder(se::Object* obj) {
    auto* cls = se::Class::create("JSBNativeDataHolder", obj, nullptr, _SE(js_new_cc_JSBNativeDataHolder)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("destroy", _SE(js_cc_JSBNativeDataHolder_destroy)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_JSBNativeDataHolder));
    
    
    cls->install();
    JSBClassType::registerClass<cc::JSBNativeDataHolder>(cls);
    
    __jsb_cc_JSBNativeDataHolder_proto = cls->getProto();
    __jsb_cc_JSBNativeDataHolder_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_ICanvasGradient_class = nullptr;
se::Object* __jsb_cc_ICanvasGradient_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICanvasGradient) 

static bool js_delete_cc_ICanvasGradient(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_ICanvasGradient) 

static bool js_cc_ICanvasGradient_addColorStop(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasGradient *arg1 = (cc::ICanvasGradient *) NULL ;
    float arg2 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasGradient>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    (arg1)->addColorStop(arg2,(ccstd::string const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasGradient_addColorStop) 

bool js_register_cc_ICanvasGradient(se::Object* obj) {
    auto* cls = se::Class::create("ICanvasGradient", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addColorStop", _SE(js_cc_ICanvasGradient_addColorStop)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_ICanvasGradient));
    
    
    cls->install();
    JSBClassType::registerClass<cc::ICanvasGradient>(cls);
    
    __jsb_cc_ICanvasGradient_proto = cls->getProto();
    __jsb_cc_ICanvasGradient_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_ICanvasRenderingContext2D_class = nullptr;
se::Object* __jsb_cc_ICanvasRenderingContext2D_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICanvasRenderingContext2D) 

static bool js_cc_ICanvasRenderingContext2D_rect(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    
    if(argc != 4) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->rect(arg2,arg3,arg4,arg5);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_rect) 

static bool js_cc_ICanvasRenderingContext2D_clearRect(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    
    if(argc != 4) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->clearRect(arg2,arg3,arg4,arg5);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_clearRect) 

static bool js_cc_ICanvasRenderingContext2D_createLinearGradient(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    cc::ICanvasGradient *result = 0 ;
    
    if(argc != 4) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::ICanvasGradient *)(arg1)->createLinearGradient(arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_createLinearGradient) 

static bool js_cc_ICanvasRenderingContext2D_save(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->save();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_save) 

static bool js_cc_ICanvasRenderingContext2D_beginPath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->beginPath();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_beginPath) 

static bool js_cc_ICanvasRenderingContext2D_closePath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->closePath();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_closePath) 

static bool js_cc_ICanvasRenderingContext2D_moveTo(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->moveTo(arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_moveTo) 

static bool js_cc_ICanvasRenderingContext2D_lineTo(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->lineTo(arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_lineTo) 

static bool js_cc_ICanvasRenderingContext2D_fill(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->fill();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fill) 

static bool js_cc_ICanvasRenderingContext2D_stroke(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->stroke();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_stroke) 

static bool js_cc_ICanvasRenderingContext2D_restore(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->restore();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_restore) 

static bool js_cc_ICanvasRenderingContext2D_setShadowBlur(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setShadowBlur(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowBlur) 

static bool js_cc_ICanvasRenderingContext2D_setShadowColor(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    (arg1)->setShadowColor((ccstd::string const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowColor) 

static bool js_cc_ICanvasRenderingContext2D_setShadowOffsetX(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setShadowOffsetX(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowOffsetX) 

static bool js_cc_ICanvasRenderingContext2D_setShadowOffsetY(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setShadowOffsetY(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowOffsetY) 

static bool js_cc_ICanvasRenderingContext2D_fillImageData(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    cc::Data *arg2 = 0 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    float arg6 ;
    cc::Data temp2 ;
    
    if(argc != 5) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->fillImageData((cc::Data const &)*arg2,arg3,arg4,arg5,arg6);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fillImageData) 

static bool js_cc_ICanvasRenderingContext2D_translate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->translate(arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_translate) 

static bool js_cc_ICanvasRenderingContext2D_scale(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->scale(arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_scale) 

static bool js_cc_ICanvasRenderingContext2D_rotate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->rotate(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_rotate) 

static bool js_cc_ICanvasRenderingContext2D_transform(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    float arg6 ;
    float arg7 ;
    
    if(argc != 6) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->transform(arg2,arg3,arg4,arg5,arg6,arg7);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_transform) 

static bool js_cc_ICanvasRenderingContext2D_setTransform(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    float arg6 ;
    float arg7 ;
    
    if(argc != 6) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setTransform(arg2,arg3,arg4,arg5,arg6,arg7);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setTransform) 

static bool js_cc_ICanvasRenderingContext2D_fetchData(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    (arg1)->fetchData();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fetchData) 

static bool js_cc_ICanvasRenderingContext2D_width_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_ICanvasRenderingContext2D_width_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_width_set) 

static bool js_cc_ICanvasRenderingContext2D_height_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_ICanvasRenderingContext2D_height_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_height_set) 

static bool js_cc_ICanvasRenderingContext2D_lineWidth_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    float arg2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc_ICanvasRenderingContext2D_lineWidth_set(arg1,arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineWidth_set) 

static bool js_cc_ICanvasRenderingContext2D_fillStyle_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_fillStyle_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_fillStyle_set) 

static bool js_cc_ICanvasRenderingContext2D_font_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_font_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_font_set) 

static bool js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_globalCompositeOperation_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set) 

static bool js_cc_ICanvasRenderingContext2D_lineCap_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_lineCap_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineCap_set) 

static bool js_cc_ICanvasRenderingContext2D_strokeStyle_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_strokeStyle_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_strokeStyle_set) 

static bool js_cc_ICanvasRenderingContext2D_lineJoin_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_lineJoin_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineJoin_set) 

static bool js_cc_ICanvasRenderingContext2D_textAlign_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_textAlign_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_textAlign_set) 

static bool js_cc_ICanvasRenderingContext2D_textBaseline_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::ICanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    cc_ICanvasRenderingContext2D_textBaseline_set(arg1,*arg2);
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_textBaseline_set) 

static bool js_delete_cc_ICanvasRenderingContext2D(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_ICanvasRenderingContext2D) 

bool js_register_cc_ICanvasRenderingContext2D(se::Object* obj) {
    auto* cls = se::Class::create("ICanvasRenderingContext2D", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("width", nullptr, _SE(js_cc_ICanvasRenderingContext2D_width_set)); 
    cls->defineProperty("height", nullptr, _SE(js_cc_ICanvasRenderingContext2D_height_set)); 
    cls->defineProperty("lineWidth", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineWidth_set)); 
    cls->defineProperty("fillStyle", nullptr, _SE(js_cc_ICanvasRenderingContext2D_fillStyle_set)); 
    cls->defineProperty("font", nullptr, _SE(js_cc_ICanvasRenderingContext2D_font_set)); 
    cls->defineProperty("globalCompositeOperation", nullptr, _SE(js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set)); 
    cls->defineProperty("lineCap", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineCap_set)); 
    cls->defineProperty("strokeStyle", nullptr, _SE(js_cc_ICanvasRenderingContext2D_strokeStyle_set)); 
    cls->defineProperty("lineJoin", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineJoin_set)); 
    cls->defineProperty("textAlign", nullptr, _SE(js_cc_ICanvasRenderingContext2D_textAlign_set)); 
    cls->defineProperty("textBaseline", nullptr, _SE(js_cc_ICanvasRenderingContext2D_textBaseline_set)); 
    
    cls->defineFunction("rect", _SE(js_cc_ICanvasRenderingContext2D_rect)); 
    cls->defineFunction("clearRect", _SE(js_cc_ICanvasRenderingContext2D_clearRect)); 
    cls->defineFunction("createLinearGradient", _SE(js_cc_ICanvasRenderingContext2D_createLinearGradient)); 
    cls->defineFunction("save", _SE(js_cc_ICanvasRenderingContext2D_save)); 
    cls->defineFunction("beginPath", _SE(js_cc_ICanvasRenderingContext2D_beginPath)); 
    cls->defineFunction("closePath", _SE(js_cc_ICanvasRenderingContext2D_closePath)); 
    cls->defineFunction("moveTo", _SE(js_cc_ICanvasRenderingContext2D_moveTo)); 
    cls->defineFunction("lineTo", _SE(js_cc_ICanvasRenderingContext2D_lineTo)); 
    cls->defineFunction("fill", _SE(js_cc_ICanvasRenderingContext2D_fill)); 
    cls->defineFunction("stroke", _SE(js_cc_ICanvasRenderingContext2D_stroke)); 
    cls->defineFunction("restore", _SE(js_cc_ICanvasRenderingContext2D_restore)); 
    cls->defineFunction("setShadowBlur", _SE(js_cc_ICanvasRenderingContext2D_setShadowBlur)); 
    cls->defineFunction("setShadowColor", _SE(js_cc_ICanvasRenderingContext2D_setShadowColor)); 
    cls->defineFunction("setShadowOffsetX", _SE(js_cc_ICanvasRenderingContext2D_setShadowOffsetX)); 
    cls->defineFunction("setShadowOffsetY", _SE(js_cc_ICanvasRenderingContext2D_setShadowOffsetY)); 
    cls->defineFunction("fillImageData", _SE(js_cc_ICanvasRenderingContext2D_fillImageData)); 
    cls->defineFunction("translate", _SE(js_cc_ICanvasRenderingContext2D_translate)); 
    cls->defineFunction("scale", _SE(js_cc_ICanvasRenderingContext2D_scale)); 
    cls->defineFunction("rotate", _SE(js_cc_ICanvasRenderingContext2D_rotate)); 
    cls->defineFunction("transform", _SE(js_cc_ICanvasRenderingContext2D_transform)); 
    cls->defineFunction("setTransform", _SE(js_cc_ICanvasRenderingContext2D_setTransform)); 
    cls->defineFunction("fetchData", _SE(js_cc_ICanvasRenderingContext2D_fetchData)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_ICanvasRenderingContext2D));
    
    
    cls->install();
    JSBClassType::registerClass<cc::ICanvasRenderingContext2D>(cls);
    
    __jsb_cc_ICanvasRenderingContext2D_proto = cls->getProto();
    __jsb_cc_ICanvasRenderingContext2D_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_CanvasGradient_class = nullptr;
se::Object* __jsb_cc_CanvasGradient_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CanvasGradient) 

static bool js_new_cc_CanvasGradient(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::CanvasGradient *result;
    result = (cc::CanvasGradient *)new cc::CanvasGradient();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_CanvasGradient, __jsb_cc_CanvasGradient_class, js_delete_cc_CanvasGradient)

static bool js_delete_cc_CanvasGradient(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_CanvasGradient) 

bool js_register_cc_CanvasGradient(se::Object* obj) {
    auto* cls = se::Class::create("CanvasGradient", obj, __jsb_cc_ICanvasGradient_proto, _SE(js_new_cc_CanvasGradient)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_CanvasGradient));
    
    
    cls->install();
    JSBClassType::registerClass<cc::CanvasGradient>(cls);
    
    __jsb_cc_CanvasGradient_proto = cls->getProto();
    __jsb_cc_CanvasGradient_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_CanvasRenderingContext2D_class = nullptr;
se::Object* __jsb_cc_CanvasRenderingContext2D_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CanvasRenderingContext2D) 

static bool js_new_cc_CanvasRenderingContext2D(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    if (argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    
    float arg1 ;
    float arg2 ;
    cc::CanvasRenderingContext2D *result;
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[1], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (cc::CanvasRenderingContext2D *)new cc::CanvasRenderingContext2D(arg1,arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_CanvasRenderingContext2D, __jsb_cc_CanvasRenderingContext2D_class, js_delete_cc_CanvasRenderingContext2D)

static bool js_delete_cc_CanvasRenderingContext2D(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_CanvasRenderingContext2D) 

static bool js_cc_CanvasRenderingContext2D__width_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_width, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__width_set) 

static bool js_cc_CanvasRenderingContext2D__width_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_width, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__width_get) 

static bool js_cc_CanvasRenderingContext2D__height_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_height, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__height_set) 

static bool js_cc_CanvasRenderingContext2D__height_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_height, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__height_get) 

static bool js_cc_CanvasRenderingContext2D__lineWidth_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_lineWidth, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineWidth_set) 

static bool js_cc_CanvasRenderingContext2D__lineWidth_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_lineWidth, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineWidth_get) 

static bool js_cc_CanvasRenderingContext2D__lineJoin_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_lineJoin, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineJoin_set) 

static bool js_cc_CanvasRenderingContext2D__lineJoin_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_lineJoin, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_lineJoin, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineJoin_get) 

static bool js_cc_CanvasRenderingContext2D__lineCap_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_lineCap, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineCap_set) 

static bool js_cc_CanvasRenderingContext2D__lineCap_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_lineCap, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_lineCap, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineCap_get) 

static bool js_cc_CanvasRenderingContext2D__font_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_font, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__font_set) 

static bool js_cc_CanvasRenderingContext2D__font_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_font, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_font, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__font_get) 

static bool js_cc_CanvasRenderingContext2D__textAlign_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_textAlign, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__textAlign_set) 

static bool js_cc_CanvasRenderingContext2D__textAlign_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_textAlign, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_textAlign, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__textAlign_get) 

static bool js_cc_CanvasRenderingContext2D__textBaseline_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_textBaseline, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__textBaseline_set) 

static bool js_cc_CanvasRenderingContext2D__textBaseline_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_textBaseline, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_textBaseline, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__textBaseline_get) 

static bool js_cc_CanvasRenderingContext2D__fillStyle_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_fillStyle, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__fillStyle_set) 

static bool js_cc_CanvasRenderingContext2D__fillStyle_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_fillStyle, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_fillStyle, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__fillStyle_get) 

static bool js_cc_CanvasRenderingContext2D__strokeStyle_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_strokeStyle, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__strokeStyle_set) 

static bool js_cc_CanvasRenderingContext2D__strokeStyle_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_strokeStyle, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_strokeStyle, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__strokeStyle_get) 

static bool js_cc_CanvasRenderingContext2D__globalCompositeOperation_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->_globalCompositeOperation, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__globalCompositeOperation_set) 

static bool js_cc_CanvasRenderingContext2D__globalCompositeOperation_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::CanvasRenderingContext2D>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->_globalCompositeOperation, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->_globalCompositeOperation, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__globalCompositeOperation_get) 

bool js_register_cc_CanvasRenderingContext2D(se::Object* obj) {
    auto* cls = se::Class::create("CanvasRenderingContext2D", obj, __jsb_cc_ICanvasRenderingContext2D_proto, _SE(js_new_cc_CanvasRenderingContext2D)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("_width", _SE(js_cc_CanvasRenderingContext2D__width_get), _SE(js_cc_CanvasRenderingContext2D__width_set)); 
    cls->defineProperty("_height", _SE(js_cc_CanvasRenderingContext2D__height_get), _SE(js_cc_CanvasRenderingContext2D__height_set)); 
    cls->defineProperty("_lineWidth", _SE(js_cc_CanvasRenderingContext2D__lineWidth_get), _SE(js_cc_CanvasRenderingContext2D__lineWidth_set)); 
    cls->defineProperty("_lineJoin", _SE(js_cc_CanvasRenderingContext2D__lineJoin_get), _SE(js_cc_CanvasRenderingContext2D__lineJoin_set)); 
    cls->defineProperty("_lineCap", _SE(js_cc_CanvasRenderingContext2D__lineCap_get), _SE(js_cc_CanvasRenderingContext2D__lineCap_set)); 
    cls->defineProperty("_font", _SE(js_cc_CanvasRenderingContext2D__font_get), _SE(js_cc_CanvasRenderingContext2D__font_set)); 
    cls->defineProperty("_textAlign", _SE(js_cc_CanvasRenderingContext2D__textAlign_get), _SE(js_cc_CanvasRenderingContext2D__textAlign_set)); 
    cls->defineProperty("_textBaseline", _SE(js_cc_CanvasRenderingContext2D__textBaseline_get), _SE(js_cc_CanvasRenderingContext2D__textBaseline_set)); 
    cls->defineProperty("_fillStyle", _SE(js_cc_CanvasRenderingContext2D__fillStyle_get), _SE(js_cc_CanvasRenderingContext2D__fillStyle_set)); 
    cls->defineProperty("_strokeStyle", _SE(js_cc_CanvasRenderingContext2D__strokeStyle_get), _SE(js_cc_CanvasRenderingContext2D__strokeStyle_set)); 
    cls->defineProperty("_globalCompositeOperation", _SE(js_cc_CanvasRenderingContext2D__globalCompositeOperation_get), _SE(js_cc_CanvasRenderingContext2D__globalCompositeOperation_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_CanvasRenderingContext2D));
    
    
    cls->install();
    JSBClassType::registerClass<cc::CanvasRenderingContext2D>(cls);
    
    __jsb_cc_CanvasRenderingContext2D_proto = cls->getProto();
    __jsb_cc_CanvasRenderingContext2D_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_Device_class = nullptr;
se::Object* __jsb_cc_Device_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Device) 

static bool js_cc_Device_getDPI_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    int result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (int)cc::Device::getDPI();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getDPI_static) 

static bool js_cc_Device_getDevicePixelRatio_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    float result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (float)cc::Device::getDevicePixelRatio();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getDevicePixelRatio_static) 

static bool js_cc_Device_setAccelerometerEnabled_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    bool arg1 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc::Device::setAccelerometerEnabled(arg1);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_setAccelerometerEnabled_static) 

static bool js_cc_Device_setAccelerometerInterval_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    float arg1 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc::Device::setAccelerometerInterval(arg1);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_setAccelerometerInterval_static) 

static bool js_cc_Device_getDeviceOrientation_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::IScreen::Orientation result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (cc::IScreen::Orientation)cc::Device::getDeviceOrientation();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getDeviceOrientation_static) 

static bool js_cc_Device_getDeviceModel_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    ccstd::string result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = cc::Device::getDeviceModel();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getDeviceModel_static) 

static bool js_cc_Device_setKeepScreenOn_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    bool arg1 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc::Device::setKeepScreenOn(arg1);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_setKeepScreenOn_static) 

static bool js_cc_Device_vibrate_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    float arg1 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    
    ok &= sevalue_to_native(args[0], &arg1, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    cc::Device::vibrate(arg1);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_vibrate_static) 

static bool js_cc_Device_getBatteryLevel_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    float result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (float)cc::Device::getBatteryLevel();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getBatteryLevel_static) 

static bool js_cc_Device_getNetworkType_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::INetwork::NetworkType result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (cc::INetwork::NetworkType)cc::Device::getNetworkType();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getNetworkType_static) 

static bool js_cc_Device_getSafeAreaEdge_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::Vec4 result;
    cc::Vec4 *temp ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = cc::Device::getSafeAreaEdge();
    
    temp = ccnew cc::Vec4(result);
    ok &= nativevalue_to_se(temp, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC();
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_Device_getSafeAreaEdge_static) 

static bool js_delete_cc_Device(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_Device) 

bool js_register_cc_Device(se::Object* obj) {
    auto* cls = se::Class::create("Device", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    
    
    cls->defineStaticFunction("getDPI", _SE(js_cc_Device_getDPI_static)); 
    cls->defineStaticFunction("getDevicePixelRatio", _SE(js_cc_Device_getDevicePixelRatio_static)); 
    cls->defineStaticFunction("setAccelerometerEnabled", _SE(js_cc_Device_setAccelerometerEnabled_static)); 
    cls->defineStaticFunction("setAccelerometerInterval", _SE(js_cc_Device_setAccelerometerInterval_static)); 
    cls->defineStaticFunction("getDeviceOrientation", _SE(js_cc_Device_getDeviceOrientation_static)); 
    cls->defineStaticFunction("getDeviceModel", _SE(js_cc_Device_getDeviceModel_static)); 
    cls->defineStaticFunction("setKeepScreenOn", _SE(js_cc_Device_setKeepScreenOn_static)); 
    cls->defineStaticFunction("vibrate", _SE(js_cc_Device_vibrate_static)); 
    cls->defineStaticFunction("getBatteryLevel", _SE(js_cc_Device_getBatteryLevel_static)); 
    cls->defineStaticFunction("getNetworkType", _SE(js_cc_Device_getNetworkType_static)); 
    cls->defineStaticFunction("getSafeAreaEdge", _SE(js_cc_Device_getSafeAreaEdge_static)); 
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_Device));
    
    
    cls->install();
    JSBClassType::registerClass<cc::Device>(cls);
    
    __jsb_cc_Device_proto = cls->getProto();
    __jsb_cc_Device_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_ISystemWindow_class = nullptr;
se::Object* __jsb_cc_ISystemWindow_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindow) 

static bool js_cc_ISystemWindow_createWindow__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    char *arg2 = (char *) NULL ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    int arg6 ;
    int arg7 ;
    ccstd::string temp2 ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = (char *) temp2.c_str(); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[4], &arg6, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[5], &arg7, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)(arg1)->createWindow((char const *)arg2,arg3,arg4,arg5,arg6,arg7);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_ISystemWindow_createWindow__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    char *arg2 = (char *) NULL ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    ccstd::string temp2 ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = (char *) temp2.c_str(); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    ok &= sevalue_to_native(args[3], &arg5, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)(arg1)->createWindow((char const *)arg2,arg3,arg4,arg5);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_ISystemWindow_createWindow(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 6) {
        ok = js_cc_ISystemWindow_createWindow__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 4) {
        ok = js_cc_ISystemWindow_createWindow__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_ISystemWindow_createWindow) 

static bool js_cc_ISystemWindow_getWindowId(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    uint32_t result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    result = ((cc::ISystemWindow const *)arg1)->getWindowId();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindow_getWindowId) 

static bool js_cc_ISystemWindow_closeWindow(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    (arg1)->closeWindow();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindow_closeWindow) 

static bool js_cc_ISystemWindow_getWindowHandle(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    uintptr_t result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    result = ((cc::ISystemWindow const *)arg1)->getWindowHandle();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindow_getWindowHandle) 

static bool js_cc_ISystemWindow_getViewSize(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    cc::ISystemWindow::Size result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    result = ((cc::ISystemWindow const *)arg1)->getViewSize();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindow_getViewSize) 

static bool js_cc_ISystemWindow_setViewSize(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    uint32_t arg2 ;
    uint32_t arg3 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    (arg1)->setViewSize(arg2,arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindow_setViewSize) 

static bool js_cc_ISystemWindow_setCursorEnabled(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ;
    bool arg2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindow>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setCursorEnabled(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindow_setCursorEnabled) 

static bool js_delete_cc_ISystemWindow(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindow) 

bool js_register_cc_ISystemWindow(se::Object* obj) {
    auto* cls = se::Class::create("ISystemWindow", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("createWindow", _SE(js_cc_ISystemWindow_createWindow)); 
    cls->defineFunction("getWindowId", _SE(js_cc_ISystemWindow_getWindowId)); 
    cls->defineFunction("closeWindow", _SE(js_cc_ISystemWindow_closeWindow)); 
    cls->defineFunction("getWindowHandle", _SE(js_cc_ISystemWindow_getWindowHandle)); 
    cls->defineFunction("getViewSize", _SE(js_cc_ISystemWindow_getViewSize)); 
    cls->defineFunction("setViewSize", _SE(js_cc_ISystemWindow_setViewSize)); 
    cls->defineFunction("setCursorEnabled", _SE(js_cc_ISystemWindow_setCursorEnabled)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindow));
    
    
    cls->install();
    JSBClassType::registerClass<cc::ISystemWindow>(cls);
    
    __jsb_cc_ISystemWindow_proto = cls->getProto();
    __jsb_cc_ISystemWindow_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_ISystemWindowInfo_class = nullptr;
se::Object* __jsb_cc_ISystemWindowInfo_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindowInfo) 

static bool js_cc_ISystemWindowInfo_title_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->title, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_title_set) 

static bool js_cc_ISystemWindowInfo_title_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->title, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->title, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_title_get) 

static bool js_cc_ISystemWindowInfo_x_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_x_set) 

static bool js_cc_ISystemWindowInfo_x_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_x_get) 

static bool js_cc_ISystemWindowInfo_y_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_y_set) 

static bool js_cc_ISystemWindowInfo_y_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_y_get) 

static bool js_cc_ISystemWindowInfo_width_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_width_set) 

static bool js_cc_ISystemWindowInfo_width_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_width_get) 

static bool js_cc_ISystemWindowInfo_height_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_height_set) 

static bool js_cc_ISystemWindowInfo_height_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_height_get) 

static bool js_cc_ISystemWindowInfo_flags_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_flags_set) 

static bool js_cc_ISystemWindowInfo_flags_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_flags_get) 

static bool js_cc_ISystemWindowInfo_externalHandle_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    ok &= sevalue_to_native(args[0], &arg1->externalHandle);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_externalHandle_set) 

static bool js_cc_ISystemWindowInfo_externalHandle_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->externalHandle, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->externalHandle, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_externalHandle_get) 

static bool js_new_cc_ISystemWindowInfo(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::ISystemWindowInfo *result;
    result = (cc::ISystemWindowInfo *)new cc::ISystemWindowInfo();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_ISystemWindowInfo, __jsb_cc_ISystemWindowInfo_class, js_delete_cc_ISystemWindowInfo)

static bool js_delete_cc_ISystemWindowInfo(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindowInfo) 

template<>
bool sevalue_to_native(const se::Value &from, cc::ISystemWindowInfo * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::ISystemWindowInfo*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("title", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->title), ctx);
    }
    
    
    json->getProperty("x", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->x), ctx);
    }
    
    
    json->getProperty("y", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->y), ctx);
    }
    
    
    json->getProperty("width", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->width), ctx);
    }
    
    
    json->getProperty("height", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->height), ctx);
    }
    
    
    json->getProperty("flags", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->flags), ctx);
    }
    
    
    json->getProperty("externalHandle", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->externalHandle), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_ISystemWindowInfo(se::Object* obj) {
    auto* cls = se::Class::create("ISystemWindowInfo", obj, nullptr, _SE(js_new_cc_ISystemWindowInfo)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("title", _SE(js_cc_ISystemWindowInfo_title_get), _SE(js_cc_ISystemWindowInfo_title_set)); 
    cls->defineProperty("x", _SE(js_cc_ISystemWindowInfo_x_get), _SE(js_cc_ISystemWindowInfo_x_set)); 
    cls->defineProperty("y", _SE(js_cc_ISystemWindowInfo_y_get), _SE(js_cc_ISystemWindowInfo_y_set)); 
    cls->defineProperty("width", _SE(js_cc_ISystemWindowInfo_width_get), _SE(js_cc_ISystemWindowInfo_width_set)); 
    cls->defineProperty("height", _SE(js_cc_ISystemWindowInfo_height_get), _SE(js_cc_ISystemWindowInfo_height_set)); 
    cls->defineProperty("flags", _SE(js_cc_ISystemWindowInfo_flags_get), _SE(js_cc_ISystemWindowInfo_flags_set)); 
    cls->defineProperty("externalHandle", _SE(js_cc_ISystemWindowInfo_externalHandle_get), _SE(js_cc_ISystemWindowInfo_externalHandle_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindowInfo));
    
    
    cls->install();
    JSBClassType::registerClass<cc::ISystemWindowInfo>(cls);
    
    __jsb_cc_ISystemWindowInfo_proto = cls->getProto();
    __jsb_cc_ISystemWindowInfo_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_ISystemWindowManager_class = nullptr;
se::Object* __jsb_cc_ISystemWindowManager_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindowManager) 

static bool js_cc_ISystemWindowManager_init(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ;
    int result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowManager>(s);
    if (nullptr == arg1) return true;
    result = (int)(arg1)->init();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindowManager_init) 

static bool js_cc_ISystemWindowManager_processEvent(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowManager>(s);
    if (nullptr == arg1) return true;
    (arg1)->processEvent();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindowManager_processEvent) 

static bool js_cc_ISystemWindowManager_createWindow(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ;
    cc::ISystemWindowInfo *arg2 = 0 ;
    cc::ISystemWindowInfo temp2 ;
    cc::ISystemWindow *result = 0 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowManager>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (cc::ISystemWindow *)(arg1)->createWindow((cc::ISystemWindowInfo const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindowManager_createWindow) 

static bool js_cc_ISystemWindowManager_getWindow(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ;
    uint32_t arg2 ;
    cc::ISystemWindow *result = 0 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowManager>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    result = (cc::ISystemWindow *)((cc::ISystemWindowManager const *)arg1)->getWindow(arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindowManager_getWindow) 

static bool js_cc_ISystemWindowManager_getWindows(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ;
    cc::SystemWindowMap *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::ISystemWindowManager>(s);
    if (nullptr == arg1) return true;
    result = (cc::SystemWindowMap *) &((cc::ISystemWindowManager const *)arg1)->getWindows();
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_ISystemWindowManager_getWindows) 

static bool js_delete_cc_ISystemWindowManager(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindowManager) 

bool js_register_cc_ISystemWindowManager(se::Object* obj) {
    auto* cls = se::Class::create("ISystemWindowManager", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("init", _SE(js_cc_ISystemWindowManager_init)); 
    cls->defineFunction("processEvent", _SE(js_cc_ISystemWindowManager_processEvent)); 
    cls->defineFunction("createWindow", _SE(js_cc_ISystemWindowManager_createWindow)); 
    cls->defineFunction("getWindow", _SE(js_cc_ISystemWindowManager_getWindow)); 
    cls->defineFunction("getWindows", _SE(js_cc_ISystemWindowManager_getWindows)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindowManager));
    
    
    cls->install();
    JSBClassType::registerClass<cc::ISystemWindowManager>(cls);
    
    __jsb_cc_ISystemWindowManager_proto = cls->getProto();
    __jsb_cc_ISystemWindowManager_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_FileUtils_class = nullptr;
se::Object* __jsb_cc_FileUtils_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_FileUtils) 

static bool js_cc_FileUtils_getInstance_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (cc::FileUtils *)cc::FileUtils::getInstance();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getInstance_static) 

static bool js_delete_cc_FileUtils(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_FileUtils) 

static bool js_cc_FileUtils_purgeCachedEntries(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    (arg1)->purgeCachedEntries();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_purgeCachedEntries) 

static bool js_cc_FileUtils_getStringFromFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (arg1)->getStringFromFile((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getStringFromFile) 

static bool js_cc_FileUtils_getDataFromFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::Data result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (arg1)->getDataFromFile((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getDataFromFile) 

static bool js_cc_FileUtils_getFileDataFromZip(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    uint32_t *arg4 = (uint32_t *) NULL ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    unsigned char *result = 0 ;
    
    if(argc != 3) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    
    ok &= sevalue_to_native(args[2], &arg4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (unsigned char *)(arg1)->getFileDataFromZip((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getFileDataFromZip) 

static bool js_cc_FileUtils_fullPathForFilename(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = ((cc::FileUtils const *)arg1)->fullPathForFilename((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_fullPathForFilename) 

static bool js_cc_FileUtils_fullPathFromRelativeFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    ccstd::string result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (arg1)->fullPathFromRelativeFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_fullPathFromRelativeFile) 

static bool js_cc_FileUtils_setSearchPaths(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::vector< ccstd::string > *arg2 = 0 ;
    ccstd::vector< ccstd::string > temp2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    (arg1)->setSearchPaths((ccstd::vector< ccstd::string > const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_setSearchPaths) 

static bool js_cc_FileUtils_getDefaultResourceRootPath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::string *) &((cc::FileUtils const *)arg1)->getDefaultResourceRootPath();
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getDefaultResourceRootPath) 

static bool js_cc_FileUtils_setDefaultResourceRootPath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    (arg1)->setDefaultResourceRootPath((ccstd::string const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_setDefaultResourceRootPath) 

static bool js_cc_FileUtils_addSearchPath__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    bool arg3 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &arg3);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->addSearchPath((ccstd::string const &)*arg2,arg3);
    
    
    return true;
}

static bool js_cc_FileUtils_addSearchPath__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    (arg1)->addSearchPath((ccstd::string const &)*arg2);
    
    
    return true;
}

static bool js_cc_FileUtils_addSearchPath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 2) {
        ok = js_cc_FileUtils_addSearchPath__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 1) {
        ok = js_cc_FileUtils_addSearchPath__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_FileUtils_addSearchPath) 

static bool js_cc_FileUtils_getSearchPaths(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::vector< ccstd::string > *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::vector< ccstd::string > *) &((cc::FileUtils const *)arg1)->getSearchPaths();
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getSearchPaths) 

static bool js_cc_FileUtils_getOriginalSearchPaths(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::vector< ccstd::string > *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    result = (ccstd::vector< ccstd::string > *) &((cc::FileUtils const *)arg1)->getOriginalSearchPaths();
    
    ok &= nativevalue_to_se(*result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getOriginalSearchPaths) 

static bool js_cc_FileUtils_getWritablePath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string result;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    result = ((cc::FileUtils const *)arg1)->getWritablePath();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getWritablePath) 

static bool js_cc_FileUtils_setWritablePath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    (arg1)->setWritablePath((ccstd::string const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_setWritablePath) 

static bool js_cc_FileUtils_getValueMapFromFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::ValueMap result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (arg1)->getValueMapFromFile((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getValueMapFromFile) 

static bool js_cc_FileUtils_getValueMapFromData(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    char *arg2 = (char *) NULL ;
    int arg3 ;
    ccstd::string temp2 ;
    cc::ValueMap result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = (char *) temp2.c_str(); 
    
    ok &= sevalue_to_native(args[1], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (arg1)->getValueMapFromData((char const *)arg2,arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getValueMapFromData) 

static bool js_cc_FileUtils_writeToFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    cc::ValueMap *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    cc::ValueMap temp2 ;
    ccstd::string temp3 ;
    bool result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (bool)(arg1)->writeToFile((cc::ValueMap const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_writeToFile) 

static bool js_cc_FileUtils_writeStringToFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    bool result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (bool)(arg1)->writeStringToFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_writeStringToFile) 

static bool js_cc_FileUtils_writeDataToFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    cc::Data *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    cc::Data temp2 ;
    ccstd::string temp3 ;
    bool result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (bool)(arg1)->writeDataToFile((cc::Data const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_writeDataToFile) 

static bool js_cc_FileUtils_writeValueMapToFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    cc::ValueMap *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    cc::ValueMap temp2 ;
    ccstd::string temp3 ;
    bool result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (bool)(arg1)->writeValueMapToFile((cc::ValueMap const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_writeValueMapToFile) 

static bool js_cc_FileUtils_writeValueVectorToFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    cc::ValueVector *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    cc::ValueVector temp2 ;
    ccstd::string temp3 ;
    bool result;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (bool)(arg1)->writeValueVectorToFile((cc::ValueVector const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_writeValueVectorToFile) 

static bool js_cc_FileUtils_getSuitableFOpen(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = ((cc::FileUtils const *)arg1)->getSuitableFOpen((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getSuitableFOpen) 

static bool js_cc_FileUtils_getValueVectorFromFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    cc::ValueVector result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (arg1)->getValueVectorFromFile((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getValueVectorFromFile) 

static bool js_cc_FileUtils_isFileExist(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)((cc::FileUtils const *)arg1)->isFileExist((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_isFileExist) 

static bool js_cc_FileUtils_getFileExtension(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = ((cc::FileUtils const *)arg1)->getFileExtension((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getFileExtension) 

static bool js_cc_FileUtils_isAbsolutePath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)((cc::FileUtils const *)arg1)->isAbsolutePath((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_isAbsolutePath) 

static bool js_cc_FileUtils_isDirectoryExist(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)((cc::FileUtils const *)arg1)->isDirectoryExist((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_isDirectoryExist) 

static bool js_cc_FileUtils_listFiles(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::vector< ccstd::string > result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = ((cc::FileUtils const *)arg1)->listFiles((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_listFiles) 

static bool js_cc_FileUtils_createDirectory(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)(arg1)->createDirectory((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_createDirectory) 

static bool js_cc_FileUtils_removeDirectory(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)(arg1)->removeDirectory((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_removeDirectory) 

static bool js_cc_FileUtils_removeFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)(arg1)->removeFile((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_removeFile) 

static bool js_cc_FileUtils_renameFile__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string *arg4 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    ccstd::string temp4 ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    result = (bool)(arg1)->renameFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_FileUtils_renameFile__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string *arg3 = 0 ;
    ccstd::string temp2 ;
    ccstd::string temp3 ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    result = (bool)(arg1)->renameFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_FileUtils_renameFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 3) {
        ok = js_cc_FileUtils_renameFile__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 2) {
        ok = js_cc_FileUtils_renameFile__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_FileUtils_renameFile) 

static bool js_cc_FileUtils_getFileSize(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    long result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (long)(arg1)->getFileSize((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getFileSize) 

static bool js_cc_FileUtils_normalizePath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = ((cc::FileUtils const *)arg1)->normalizePath((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_normalizePath) 

static bool js_cc_FileUtils_getFileDir(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *arg1 = (cc::FileUtils *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    ccstd::string result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::FileUtils>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = ((cc::FileUtils const *)arg1)->getFileDir((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_FUNC(js_cc_FileUtils_getFileDir) 

bool js_register_cc_FileUtils(se::Object* obj) {
    auto* cls = se::Class::create("FileUtils", obj, nullptr, nullptr); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("purgeCachedEntries", _SE(js_cc_FileUtils_purgeCachedEntries)); 
    cls->defineFunction("getStringFromFile", _SE(js_cc_FileUtils_getStringFromFile)); 
    cls->defineFunction("getDataFromFile", _SE(js_cc_FileUtils_getDataFromFile)); 
    cls->defineFunction("getFileDataFromZip", _SE(js_cc_FileUtils_getFileDataFromZip)); 
    cls->defineFunction("fullPathForFilename", _SE(js_cc_FileUtils_fullPathForFilename)); 
    cls->defineFunction("fullPathFromRelativeFile", _SE(js_cc_FileUtils_fullPathFromRelativeFile)); 
    cls->defineFunction("setSearchPaths", _SE(js_cc_FileUtils_setSearchPaths)); 
    cls->defineFunction("getDefaultResourceRootPath", _SE(js_cc_FileUtils_getDefaultResourceRootPath)); 
    cls->defineFunction("setDefaultResourceRootPath", _SE(js_cc_FileUtils_setDefaultResourceRootPath)); 
    cls->defineFunction("addSearchPath", _SE(js_cc_FileUtils_addSearchPath)); 
    cls->defineFunction("getSearchPaths", _SE(js_cc_FileUtils_getSearchPaths)); 
    cls->defineFunction("getOriginalSearchPaths", _SE(js_cc_FileUtils_getOriginalSearchPaths)); 
    cls->defineFunction("getWritablePath", _SE(js_cc_FileUtils_getWritablePath)); 
    cls->defineFunction("setWritablePath", _SE(js_cc_FileUtils_setWritablePath)); 
    cls->defineFunction("getValueMapFromFile", _SE(js_cc_FileUtils_getValueMapFromFile)); 
    cls->defineFunction("getValueMapFromData", _SE(js_cc_FileUtils_getValueMapFromData)); 
    cls->defineFunction("writeToFile", _SE(js_cc_FileUtils_writeToFile)); 
    cls->defineFunction("writeStringToFile", _SE(js_cc_FileUtils_writeStringToFile)); 
    cls->defineFunction("writeDataToFile", _SE(js_cc_FileUtils_writeDataToFile)); 
    cls->defineFunction("writeValueMapToFile", _SE(js_cc_FileUtils_writeValueMapToFile)); 
    cls->defineFunction("writeValueVectorToFile", _SE(js_cc_FileUtils_writeValueVectorToFile)); 
    cls->defineFunction("getSuitableFOpen", _SE(js_cc_FileUtils_getSuitableFOpen)); 
    cls->defineFunction("getValueVectorFromFile", _SE(js_cc_FileUtils_getValueVectorFromFile)); 
    cls->defineFunction("isFileExist", _SE(js_cc_FileUtils_isFileExist)); 
    cls->defineFunction("getFileExtension", _SE(js_cc_FileUtils_getFileExtension)); 
    cls->defineFunction("isAbsolutePath", _SE(js_cc_FileUtils_isAbsolutePath)); 
    cls->defineFunction("isDirectoryExist", _SE(js_cc_FileUtils_isDirectoryExist)); 
    cls->defineFunction("listFiles", _SE(js_cc_FileUtils_listFiles)); 
    cls->defineFunction("createDirectory", _SE(js_cc_FileUtils_createDirectory)); 
    cls->defineFunction("removeDirectory", _SE(js_cc_FileUtils_removeDirectory)); 
    cls->defineFunction("removeFile", _SE(js_cc_FileUtils_removeFile)); 
    cls->defineFunction("renameFile", _SE(js_cc_FileUtils_renameFile)); 
    cls->defineFunction("getFileSize", _SE(js_cc_FileUtils_getFileSize)); 
    cls->defineFunction("normalizePath", _SE(js_cc_FileUtils_normalizePath)); 
    cls->defineFunction("getFileDir", _SE(js_cc_FileUtils_getFileDir)); 
    
    
    cls->defineStaticFunction("getInstance", _SE(js_cc_FileUtils_getInstance_static)); 
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_FileUtils));
    
    
    cls->install();
    JSBClassType::registerClass<cc::FileUtils>(cls);
    
    __jsb_cc_FileUtils_proto = cls->getProto();
    __jsb_cc_FileUtils_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


static bool js_cc_createFileUtils(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::FileUtils *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (cc::FileUtils *)cc::createFileUtils();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_createFileUtils) 

se::Class* __jsb_cc_SAXParser_class = nullptr;
se::Object* __jsb_cc_SAXParser_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SAXParser) 

static bool js_new_cc_SAXParser(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::SAXParser *result;
    result = (cc::SAXParser *)new cc::SAXParser();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_SAXParser, __jsb_cc_SAXParser_class, js_delete_cc_SAXParser)

static bool js_delete_cc_SAXParser(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_SAXParser) 

static bool js_cc_PlistParser_init(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::SAXParser *arg1 = (cc::SAXParser *) NULL ;
    char *arg2 = (char *) NULL ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::SAXParser>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = (char *) temp2.c_str(); 
    result = (bool)(arg1)->init((char const *)arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_PlistParser_init) 

static bool js_cc_PlistParser_parse(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::SAXParser *arg1 = (cc::SAXParser *) NULL ;
    ccstd::string *arg2 = 0 ;
    ccstd::string temp2 ;
    bool result;
    
    if(argc != 1) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
        return false;
    }
    arg1 = SE_THIS_OBJECT<cc::SAXParser>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    result = (bool)(arg1)->parse((ccstd::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_PlistParser_parse) 

bool js_register_cc_SAXParser(se::Object* obj) {
    auto* cls = se::Class::create("PlistParser", obj, nullptr, _SE(js_new_cc_SAXParser)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("init", _SE(js_cc_PlistParser_init)); 
    cls->defineFunction("parse", _SE(js_cc_PlistParser_parse)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_SAXParser));
    
    
    cls->install();
    JSBClassType::registerClass<cc::SAXParser>(cls);
    
    __jsb_cc_SAXParser_proto = cls->getProto();
    __jsb_cc_SAXParser_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}

#if CC_USE_DEBUG_RENDERER

se::Class* __jsb_cc_DebugTextInfo_class = nullptr;
se::Object* __jsb_cc_DebugTextInfo_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DebugTextInfo) 

static bool js_new_cc_DebugTextInfo(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::DebugTextInfo *result;
    result = (cc::DebugTextInfo *)new cc::DebugTextInfo();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_DebugTextInfo, __jsb_cc_DebugTextInfo_class, js_delete_cc_DebugTextInfo)

static bool js_cc_DebugTextInfo_color_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_color_set) 

static bool js_cc_DebugTextInfo_color_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_color_get) 

static bool js_cc_DebugTextInfo_bold_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->bold);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_bold_set) 

static bool js_cc_DebugTextInfo_bold_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->bold, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_bold_get) 

static bool js_cc_DebugTextInfo_italic_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->italic);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_italic_set) 

static bool js_cc_DebugTextInfo_italic_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->italic, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_italic_get) 

static bool js_cc_DebugTextInfo_shadow_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->shadow);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadow_set) 

static bool js_cc_DebugTextInfo_shadow_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->shadow, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadow_get) 

static bool js_cc_DebugTextInfo_shadowThickness_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->shadowThickness, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadowThickness_set) 

static bool js_cc_DebugTextInfo_shadowThickness_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->shadowThickness, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadowThickness_get) 

static bool js_cc_DebugTextInfo_shadowColor_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->shadowColor, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadowColor_set) 

static bool js_cc_DebugTextInfo_shadowColor_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->shadowColor, s.rval(), s.thisObject() /*ctx*/);
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(arg1->shadowColor, s.thisObject(), s.rval());
    
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadowColor_get) 

static bool js_cc_DebugTextInfo_scale_set(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg1->scale, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    
    return true;
}
SE_BIND_PROP_SET(js_cc_DebugTextInfo_scale_set) 

static bool js_cc_DebugTextInfo_scale_get(se::State& s)
{
    CC_UNUSED bool ok = true;
    cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugTextInfo>(s);
    if (nullptr == arg1) return true;
    
    ok &= nativevalue_to_se(arg1->scale, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_PROP_GET(js_cc_DebugTextInfo_scale_get) 

static bool js_delete_cc_DebugTextInfo(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_DebugTextInfo) 

template<>
bool sevalue_to_native(const se::Value &from, cc::DebugTextInfo * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::DebugTextInfo*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("color", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->color), ctx);
    }
    
    
    json->getProperty("bold", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->bold), ctx);
    }
    
    
    json->getProperty("italic", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->italic), ctx);
    }
    
    
    json->getProperty("shadow", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->shadow), ctx);
    }
    
    
    json->getProperty("shadowThickness", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->shadowThickness), ctx);
    }
    
    
    json->getProperty("shadowColor", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->shadowColor), ctx);
    }
    
    
    json->getProperty("scale", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->scale), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_DebugTextInfo(se::Object* obj) {
    auto* cls = se::Class::create("DebugTextInfo", obj, nullptr, _SE(js_new_cc_DebugTextInfo)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("color", _SE(js_cc_DebugTextInfo_color_get), _SE(js_cc_DebugTextInfo_color_set)); 
    cls->defineProperty("bold", _SE(js_cc_DebugTextInfo_bold_get), _SE(js_cc_DebugTextInfo_bold_set)); 
    cls->defineProperty("italic", _SE(js_cc_DebugTextInfo_italic_get), _SE(js_cc_DebugTextInfo_italic_set)); 
    cls->defineProperty("shadow", _SE(js_cc_DebugTextInfo_shadow_get), _SE(js_cc_DebugTextInfo_shadow_set)); 
    cls->defineProperty("shadowThickness", _SE(js_cc_DebugTextInfo_shadowThickness_get), _SE(js_cc_DebugTextInfo_shadowThickness_set)); 
    cls->defineProperty("shadowColor", _SE(js_cc_DebugTextInfo_shadowColor_get), _SE(js_cc_DebugTextInfo_shadowColor_set)); 
    cls->defineProperty("scale", _SE(js_cc_DebugTextInfo_scale_get), _SE(js_cc_DebugTextInfo_scale_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_DebugTextInfo));
    
    
    cls->install();
    JSBClassType::registerClass<cc::DebugTextInfo>(cls);
    
    __jsb_cc_DebugTextInfo_proto = cls->getProto();
    __jsb_cc_DebugTextInfo_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}

#endif // CC_USE_DEBUG_RENDERER
#if CC_USE_DEBUG_RENDERER

se::Class* __jsb_cc_DebugRenderer_class = nullptr;
se::Object* __jsb_cc_DebugRenderer_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DebugRenderer) 

static bool js_cc_DebugRenderer_getInstance_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::DebugRenderer *result = 0 ;
    
    if(argc != 0) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
        return false;
    }
    result = (cc::DebugRenderer *)cc::DebugRenderer::getInstance();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_DebugRenderer_getInstance_static) 

static bool js_new_cc_DebugRenderer(se::State& s) // NOLINT(readability-identifier-naming)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    cc::DebugRenderer *result;
    result = (cc::DebugRenderer *)new cc::DebugRenderer();
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}
SE_BIND_CTOR(js_new_cc_DebugRenderer, __jsb_cc_DebugRenderer_class, js_delete_cc_DebugRenderer)

static bool js_delete_cc_DebugRenderer(se::State& s)
{
    return true;
}
SE_BIND_FINALIZE_FUNC(js_delete_cc_DebugRenderer) 

static bool js_cc_DebugRenderer_addText__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::DebugRenderer *arg1 = (cc::DebugRenderer *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::Vec2 *arg3 = 0 ;
    ccstd::string temp2 ;
    cc::Vec2 temp3 ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugRenderer>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    (arg1)->addText((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3);
    
    
    return true;
}

static bool js_cc_DebugRenderer_addText__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::DebugRenderer *arg1 = (cc::DebugRenderer *) NULL ;
    ccstd::string *arg2 = 0 ;
    cc::Vec2 *arg3 = 0 ;
    cc::DebugTextInfo *arg4 = 0 ;
    ccstd::string temp2 ;
    cc::Vec2 temp3 ;
    cc::DebugTextInfo temp4 ;
    
    arg1 = SE_THIS_OBJECT<cc::DebugRenderer>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &temp2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg2 = &temp2;
    
    
    ok &= sevalue_to_native(args[1], &temp3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg3 = &temp3;
    
    
    ok &= sevalue_to_native(args[2], &temp4, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments");
    arg4 = &temp4;
    
    (arg1)->addText((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3,(cc::DebugTextInfo const &)*arg4);
    
    
    return true;
}

static bool js_cc_DebugRenderer_addText(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    
    
    if (argc == 2) {
        ok = js_cc_DebugRenderer_addText__SWIG_0(s);
        if (ok) {
            return true; 
        }
    } 
    if (argc == 3) {
        ok = js_cc_DebugRenderer_addText__SWIG_1(s);
        if (ok) {
            return true; 
        }
    } 
    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
    return false;
}
SE_BIND_FUNC(js_cc_DebugRenderer_addText) 

bool js_register_cc_DebugRenderer(se::Object* obj) {
    auto* cls = se::Class::create("DebugRenderer", obj, nullptr, _SE(js_new_cc_DebugRenderer)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("addText", _SE(js_cc_DebugRenderer_addText)); 
    
    
    cls->defineStaticFunction("getInstance", _SE(js_cc_DebugRenderer_getInstance_static)); 
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_DebugRenderer));
    
    
    cls->install();
    JSBClassType::registerClass<cc::DebugRenderer>(cls);
    
    __jsb_cc_DebugRenderer_proto = cls->getProto();
    __jsb_cc_DebugRenderer_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}

#endif // CC_USE_DEBUG_RENDERER



bool register_all_engine(se::Object* obj) {
    // Get the ns
    se::Value nsVal;
    if (!obj->getProperty("jsb", &nsVal, true))
    {
        se::HandleObject jsobj(se::Object::createPlainObject());
        nsVal.setObject(jsobj);
        obj->setProperty("jsb", nsVal);
    }
    se::Object* ns = nsVal.toObject();
    /* Register classes */
    js_register_cc_Vec2(ns); 
    js_register_cc_Color(ns); 
    js_register_cc_Vec3(ns); 
    js_register_cc_Vec4(ns); 
    js_register_cc_Mat3(ns); 
    js_register_cc_Mat4(ns); 
    js_register_cc_Quaternion(ns); 
    js_register_cc_CCObject(ns); 
    js_register_cc_JSBNativeDataHolder(ns); 
    js_register_cc_ICanvasGradient(ns); 
    js_register_cc_ICanvasRenderingContext2D(ns); 
    js_register_cc_CanvasGradient(ns); 
    js_register_cc_CanvasRenderingContext2D(ns); 
    js_register_cc_Device(ns); 
    js_register_cc_ISystemWindow(ns); 
    js_register_cc_ISystemWindowInfo(ns); 
    js_register_cc_ISystemWindowManager(ns); 
    js_register_cc_FileUtils(ns); 
    js_register_cc_SAXParser(ns); 
#if CC_USE_DEBUG_RENDERER
    js_register_cc_DebugTextInfo(ns); 
#endif // CC_USE_DEBUG_RENDERER
#if CC_USE_DEBUG_RENDERER
    js_register_cc_DebugRenderer(ns); 
#endif // CC_USE_DEBUG_RENDERER
    
    /* Register global variables & global functions */
    
    
    
    return true;
}


#if defined(__clang__)
#pragma clang diagnostic pop
#elif defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic pop
#elif defined(_MSC_VER)
#pragma warning(pop)
#endif
// clang-format on
