// 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_extension_auto.h"



se::Class* __jsb_cc_extension_EventAssetsManagerEx_class = nullptr;
se::Object* __jsb_cc_extension_EventAssetsManagerEx_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_EventAssetsManagerEx) 

static bool js_cc_extension_EventAssetsManager_getEventCode(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    cc::extension::EventAssetsManagerEx::EventCode 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (cc::extension::EventAssetsManagerEx::EventCode)((cc::extension::EventAssetsManagerEx const *)arg1)->getEventCode();
    
    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_extension_EventAssetsManager_getEventCode) 

static bool js_cc_extension_EventAssetsManager_getCURLECode(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getCURLECode();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getCURLECode) 

static bool js_cc_extension_EventAssetsManager_getCURLMCode(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getCURLMCode();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getCURLMCode) 

static bool js_cc_extension_EventAssetsManager_getMessage(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    std::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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = ((cc::extension::EventAssetsManagerEx const *)arg1)->getMessage();
    
    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_extension_EventAssetsManager_getMessage) 

static bool js_cc_extension_EventAssetsManager_getAssetId(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    std::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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = ((cc::extension::EventAssetsManagerEx const *)arg1)->getAssetId();
    
    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_extension_EventAssetsManager_getAssetId) 

static bool js_cc_extension_EventAssetsManager_getAssetsManagerEx(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    cc::extension::AssetsManagerEx *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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (cc::extension::AssetsManagerEx *)((cc::extension::EventAssetsManagerEx const *)arg1)->getAssetsManagerEx();
    
    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_extension_EventAssetsManager_getAssetsManagerEx) 

static bool js_cc_extension_EventAssetsManager_isResuming(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::extension::EventAssetsManagerEx const *)arg1)->isResuming();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_isResuming) 

static bool js_cc_extension_EventAssetsManager_getPercent(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    float 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (float)((cc::extension::EventAssetsManagerEx const *)arg1)->getPercent();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getPercent) 

static bool js_cc_extension_EventAssetsManager_getPercentByFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    float 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (float)((cc::extension::EventAssetsManagerEx const *)arg1)->getPercentByFile();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getPercentByFile) 

static bool js_cc_extension_EventAssetsManager_getDownloadedBytes(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    double 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (double)((cc::extension::EventAssetsManagerEx const *)arg1)->getDownloadedBytes();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getDownloadedBytes) 

static bool js_cc_extension_EventAssetsManager_getTotalBytes(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ;
    double 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (double)((cc::extension::EventAssetsManagerEx const *)arg1)->getTotalBytes();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getTotalBytes) 

static bool js_cc_extension_EventAssetsManager_getDownloadedFiles(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getDownloadedFiles();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getDownloadedFiles) 

static bool js_cc_extension_EventAssetsManager_getTotalFiles(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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::extension::EventAssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getTotalFiles();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getTotalFiles) 

static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::EventAssetsManagerEx::EventCode arg3 ;
    std::string arg4 ;
    std::string arg5 ;
    int arg6 ;
    int arg7 ;
    std::string temp1 ;
    cc::extension::EventAssetsManagerEx *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"); 
    
    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"); 
    result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::EventAssetsManagerEx::EventCode arg3 ;
    std::string arg4 ;
    std::string arg5 ;
    int arg6 ;
    std::string temp1 ;
    cc::extension::EventAssetsManagerEx *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"); 
    
    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"); 
    result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::EventAssetsManagerEx::EventCode arg3 ;
    std::string arg4 ;
    std::string arg5 ;
    std::string temp1 ;
    cc::extension::EventAssetsManagerEx *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"); 
    
    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"); 
    
    result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::EventAssetsManagerEx::EventCode arg3 ;
    std::string arg4 ;
    std::string temp1 ;
    cc::extension::EventAssetsManagerEx *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"); 
    
    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::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::EventAssetsManagerEx::EventCode arg3 ;
    std::string temp1 ;
    cc::extension::EventAssetsManagerEx *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"); 
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_EventAssetsManagerEx(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 7) {
        ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 6) {
        ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 5) {
        ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 4) {
        ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_3(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 3) {
        ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_4(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of EventAssetsManager");
    return false;
}
SE_BIND_CTOR(js_new_cc_extension_EventAssetsManagerEx, __jsb_cc_extension_EventAssetsManagerEx_class, js_delete_cc_extension_EventAssetsManagerEx)

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

bool js_register_cc_extension_EventAssetsManagerEx(se::Object* obj) {
    auto* cls = se::Class::create("EventAssetsManager", obj, nullptr, _SE(js_new_cc_extension_EventAssetsManagerEx)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("getEventCode", _SE(js_cc_extension_EventAssetsManager_getEventCode)); 
    cls->defineFunction("getCURLECode", _SE(js_cc_extension_EventAssetsManager_getCURLECode)); 
    cls->defineFunction("getCURLMCode", _SE(js_cc_extension_EventAssetsManager_getCURLMCode)); 
    cls->defineFunction("getMessage", _SE(js_cc_extension_EventAssetsManager_getMessage)); 
    cls->defineFunction("getAssetId", _SE(js_cc_extension_EventAssetsManager_getAssetId)); 
    cls->defineFunction("getAssetsManagerEx", _SE(js_cc_extension_EventAssetsManager_getAssetsManagerEx)); 
    cls->defineFunction("isResuming", _SE(js_cc_extension_EventAssetsManager_isResuming)); 
    cls->defineFunction("getPercent", _SE(js_cc_extension_EventAssetsManager_getPercent)); 
    cls->defineFunction("getPercentByFile", _SE(js_cc_extension_EventAssetsManager_getPercentByFile)); 
    cls->defineFunction("getDownloadedBytes", _SE(js_cc_extension_EventAssetsManager_getDownloadedBytes)); 
    cls->defineFunction("getTotalBytes", _SE(js_cc_extension_EventAssetsManager_getTotalBytes)); 
    cls->defineFunction("getDownloadedFiles", _SE(js_cc_extension_EventAssetsManager_getDownloadedFiles)); 
    cls->defineFunction("getTotalFiles", _SE(js_cc_extension_EventAssetsManager_getTotalFiles)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_extension_EventAssetsManagerEx));
    
    
    cls->install();
    JSBClassType::registerClass<cc::extension::EventAssetsManagerEx>(cls);
    
    __jsb_cc_extension_EventAssetsManagerEx_proto = cls->getProto();
    __jsb_cc_extension_EventAssetsManagerEx_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_extension_DownloadUnit_class = nullptr;
se::Object* __jsb_cc_extension_DownloadUnit_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_DownloadUnit) 

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

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

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

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

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

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

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

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

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

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

template<>
bool sevalue_to_native(const se::Value &from, cc::extension::DownloadUnit * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::extension::DownloadUnit*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("srcUrl", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->srcUrl), ctx);
    }
    
    
    json->getProperty("storagePath", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->storagePath), ctx);
    }
    
    
    json->getProperty("customId", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->customId), ctx);
    }
    
    
    json->getProperty("size", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->size), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_extension_DownloadUnit(se::Object* obj) {
    auto* cls = se::Class::create("DownloadUnit", obj, nullptr, _SE(js_new_cc_extension_DownloadUnit)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("srcUrl", _SE(js_cc_extension_DownloadUnit_srcUrl_get), _SE(js_cc_extension_DownloadUnit_srcUrl_set)); 
    cls->defineProperty("storagePath", _SE(js_cc_extension_DownloadUnit_storagePath_get), _SE(js_cc_extension_DownloadUnit_storagePath_set)); 
    cls->defineProperty("customId", _SE(js_cc_extension_DownloadUnit_customId_get), _SE(js_cc_extension_DownloadUnit_customId_set)); 
    cls->defineProperty("size", _SE(js_cc_extension_DownloadUnit_size_get), _SE(js_cc_extension_DownloadUnit_size_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_extension_DownloadUnit));
    
    
    cls->install();
    JSBClassType::registerClass<cc::extension::DownloadUnit>(cls);
    
    __jsb_cc_extension_DownloadUnit_proto = cls->getProto();
    __jsb_cc_extension_DownloadUnit_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_extension_ManifestAsset_class = nullptr;
se::Object* __jsb_cc_extension_ManifestAsset_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_ManifestAsset) 

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

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

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

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

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

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

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

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

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

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

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

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

template<>
bool sevalue_to_native(const se::Value &from, cc::extension::ManifestAsset * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::extension::ManifestAsset*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("md5", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->md5), ctx);
    }
    
    
    json->getProperty("path", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->path), ctx);
    }
    
    
    json->getProperty("compressed", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->compressed), ctx);
    }
    
    
    json->getProperty("size", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->size), ctx);
    }
    
    
    json->getProperty("downloadState", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->downloadState), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_extension_ManifestAsset(se::Object* obj) {
    auto* cls = se::Class::create("ManifestAsset", obj, nullptr, _SE(js_new_cc_extension_ManifestAsset)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("md5", _SE(js_cc_extension_ManifestAsset_md5_get), _SE(js_cc_extension_ManifestAsset_md5_set)); 
    cls->defineProperty("path", _SE(js_cc_extension_ManifestAsset_path_get), _SE(js_cc_extension_ManifestAsset_path_set)); 
    cls->defineProperty("compressed", _SE(js_cc_extension_ManifestAsset_compressed_get), _SE(js_cc_extension_ManifestAsset_compressed_set)); 
    cls->defineProperty("size", _SE(js_cc_extension_ManifestAsset_size_get), _SE(js_cc_extension_ManifestAsset_size_set)); 
    cls->defineProperty("downloadState", _SE(js_cc_extension_ManifestAsset_downloadState_get), _SE(js_cc_extension_ManifestAsset_downloadState_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_extension_ManifestAsset));
    
    
    cls->install();
    JSBClassType::registerClass<cc::extension::ManifestAsset>(cls);
    
    __jsb_cc_extension_ManifestAsset_proto = cls->getProto();
    __jsb_cc_extension_ManifestAsset_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_extension_Manifest_class = nullptr;
se::Object* __jsb_cc_extension_Manifest_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_Manifest) 

se::Class* __jsb_cc_extension_Manifest_AssetDiff_class = nullptr;
se::Object* __jsb_cc_extension_Manifest_AssetDiff_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_Manifest_AssetDiff) 

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

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

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

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

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

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

template<>
bool sevalue_to_native(const se::Value &from, cc::extension::Manifest::AssetDiff * to, se::Object *ctx)
{
    assert(from.isObject());
    se::Object *json = from.toObject();
    auto* data = reinterpret_cast<cc::extension::Manifest::AssetDiff*>(json->getPrivateData());
    if (data) {
        *to = *data;
        return true;
    }
    se::Value field;
    bool ok = true;
    
    json->getProperty("asset", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->asset), ctx);
    }
    
    
    json->getProperty("type", &field, true);
    if (!field.isNullOrUndefined()) {
        ok &= sevalue_to_native(field, &(to->type), ctx);
    }
    
    
    return ok;
}


bool js_register_cc_extension_Manifest_AssetDiff(se::Object* obj) {
    auto* cls = se::Class::create({"Manifest", "AssetDiff"}, obj, nullptr, _SE(js_new_cc_extension_Manifest_AssetDiff)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    cls->defineProperty("asset", _SE(js_cc_extension_Manifest_AssetDiff_asset_get), _SE(js_cc_extension_Manifest_AssetDiff_asset_set)); 
    cls->defineProperty("type", _SE(js_cc_extension_Manifest_AssetDiff_type_get), _SE(js_cc_extension_Manifest_AssetDiff_type_set)); 
    
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_extension_Manifest_AssetDiff));
    
    
    cls->install();
    JSBClassType::registerClass<cc::extension::Manifest::AssetDiff>(cls);
    
    __jsb_cc_extension_Manifest_AssetDiff_proto = cls->getProto();
    __jsb_cc_extension_Manifest_AssetDiff_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


static bool js_cc_extension_Manifest_isVersionLoaded(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::extension::Manifest const *)arg1)->isVersionLoaded();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_Manifest_isVersionLoaded) 

static bool js_cc_extension_Manifest_isLoaded(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::extension::Manifest const *)arg1)->isLoaded();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_Manifest_isLoaded) 

static bool js_cc_extension_Manifest_getPackageUrl(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (std::string *) &((cc::extension::Manifest const *)arg1)->getPackageUrl();
    
    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_extension_Manifest_getPackageUrl) 

static bool js_cc_extension_Manifest_getManifestFileUrl(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (std::string *) &((cc::extension::Manifest const *)arg1)->getManifestFileUrl();
    
    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_extension_Manifest_getManifestFileUrl) 

static bool js_cc_extension_Manifest_getVersionFileUrl(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (std::string *) &((cc::extension::Manifest const *)arg1)->getVersionFileUrl();
    
    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_extension_Manifest_getVersionFileUrl) 

static bool js_cc_extension_Manifest_getVersion(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (std::string *) &((cc::extension::Manifest const *)arg1)->getVersion();
    
    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_extension_Manifest_getVersion) 

static bool js_cc_extension_Manifest_getSearchPaths(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::vector< std::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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = ((cc::extension::Manifest const *)arg1)->getSearchPaths();
    
    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_extension_Manifest_getSearchPaths) 

static bool js_cc_extension_Manifest_getManifestRoot(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (std::string *) &((cc::extension::Manifest const *)arg1)->getManifestRoot();
    
    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_extension_Manifest_getManifestRoot) 

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


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


static bool js_new_cc_extension_Manifest__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    std::string *arg2 = 0 ;
    std::string temp1 ;
    std::string temp2 ;
    cc::extension::Manifest *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::extension::Manifest *)new cc::extension::Manifest((std::string const &)*arg1,(std::string const &)*arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_Manifest(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 1) {
        ret = js_new_cc_extension_Manifest__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 0) {
        ret = js_new_cc_extension_Manifest__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 2) {
        ret = js_new_cc_extension_Manifest__SWIG_2(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of Manifest");
    return false;
}
SE_BIND_CTOR(js_new_cc_extension_Manifest, __jsb_cc_extension_Manifest_class, js_delete_cc_extension_Manifest)

static bool js_cc_extension_Manifest_parseFile(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::string *arg2 = 0 ;
    std::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::extension::Manifest>(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)->parseFile((std::string const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_Manifest_parseFile) 

static bool js_cc_extension_Manifest_parseJSONString(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ;
    std::string *arg2 = 0 ;
    std::string *arg3 = 0 ;
    std::string temp2 ;
    std::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::extension::Manifest>(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)->parseJSONString((std::string const &)*arg2,(std::string const &)*arg3);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_Manifest_parseJSONString) 

static bool js_cc_extension_Manifest_isUpdating(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::extension::Manifest const *)arg1)->isUpdating();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_Manifest_isUpdating) 

static bool js_cc_extension_Manifest_setUpdating(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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::extension::Manifest>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2);
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setUpdating(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_Manifest_setUpdating) 

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

bool js_register_cc_extension_Manifest(se::Object* obj) {
    auto* cls = se::Class::create("Manifest", obj, nullptr, _SE(js_new_cc_extension_Manifest)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("isVersionLoaded", _SE(js_cc_extension_Manifest_isVersionLoaded)); 
    cls->defineFunction("isLoaded", _SE(js_cc_extension_Manifest_isLoaded)); 
    cls->defineFunction("getPackageUrl", _SE(js_cc_extension_Manifest_getPackageUrl)); 
    cls->defineFunction("getManifestFileUrl", _SE(js_cc_extension_Manifest_getManifestFileUrl)); 
    cls->defineFunction("getVersionFileUrl", _SE(js_cc_extension_Manifest_getVersionFileUrl)); 
    cls->defineFunction("getVersion", _SE(js_cc_extension_Manifest_getVersion)); 
    cls->defineFunction("getSearchPaths", _SE(js_cc_extension_Manifest_getSearchPaths)); 
    cls->defineFunction("getManifestRoot", _SE(js_cc_extension_Manifest_getManifestRoot)); 
    cls->defineFunction("parseFile", _SE(js_cc_extension_Manifest_parseFile)); 
    cls->defineFunction("parseJSONString", _SE(js_cc_extension_Manifest_parseJSONString)); 
    cls->defineFunction("isUpdating", _SE(js_cc_extension_Manifest_isUpdating)); 
    cls->defineFunction("setUpdating", _SE(js_cc_extension_Manifest_setUpdating)); 
    
    
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_extension_Manifest));
    
    
    cls->install();
    JSBClassType::registerClass<cc::extension::Manifest>(cls);
    
    __jsb_cc_extension_Manifest_proto = cls->getProto();
    __jsb_cc_extension_Manifest_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}


se::Class* __jsb_cc_extension_AssetsManagerEx_class = nullptr;
se::Object* __jsb_cc_extension_AssetsManagerEx_proto = nullptr;
SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_AssetsManagerEx) 

static bool js_cc_extension_AssetsManager_create_static(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    std::string *arg1 = 0 ;
    std::string *arg2 = 0 ;
    std::string temp1 ;
    std::string temp2 ;
    cc::extension::AssetsManagerEx *result = 0 ;
    
    if(argc != 2) {
        SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
        return false;
    }
    
    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::extension::AssetsManagerEx *)cc::extension::AssetsManagerEx::create((std::string const &)*arg1,(std::string 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_extension_AssetsManager_create_static) 

static bool js_new_cc_extension_AssetsManagerEx__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    std::string *arg2 = 0 ;
    std::string temp1 ;
    std::string temp2 ;
    cc::extension::AssetsManagerEx *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::extension::AssetsManagerEx *)new cc::extension::AssetsManagerEx((std::string const &)*arg1,(std::string const &)*arg2);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_AssetsManagerEx__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming)
{
    const auto& args = s.args();
    CC_UNUSED bool ok = true;
    std::string *arg1 = 0 ;
    std::string *arg2 = 0 ;
    cc::extension::AssetsManagerEx::VersionCompareHandle arg3 ;
    std::string temp1 ;
    std::string temp2 ;
    cc::extension::AssetsManagerEx *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;
    
    
    ok &= sevalue_to_native(args[2], &arg3, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    
    result = (cc::extension::AssetsManagerEx *)new cc::extension::AssetsManagerEx((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    
    
    auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result);
    s.thisObject()->setPrivateObject(ptr);
    return true;
}


static bool js_new_cc_extension_AssetsManagerEx(se::State& s) // NOLINT(readability-identifier-naming)
{
    size_t argc = s.args().size();
    bool ret = false;
    
    if(argc == 2) {
        ret = js_new_cc_extension_AssetsManagerEx__SWIG_0(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    if(argc == 3) {
        ret = js_new_cc_extension_AssetsManagerEx__SWIG_1(s);
        if (ret) {
            return ret; 
        } /* reset exception and return */
    }
    
    SE_REPORT_ERROR("Illegal arguments for construction of AssetsManager");
    return false;
}
SE_BIND_CTOR(js_new_cc_extension_AssetsManagerEx, __jsb_cc_extension_AssetsManagerEx_class, js_delete_cc_extension_AssetsManagerEx)

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

static bool js_cc_extension_AssetsManager_checkUpdate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    (arg1)->checkUpdate();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_checkUpdate) 

static bool js_cc_extension_AssetsManager_prepareUpdate(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    (arg1)->prepareUpdate();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_prepareUpdate) 

static bool js_cc_extension_AssetsManager_update(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    (arg1)->update();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_update) 

static bool js_cc_extension_AssetsManager_downloadFailedAssets(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    (arg1)->downloadFailedAssets();
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_downloadFailedAssets) 

static bool js_cc_extension_AssetsManager_getState(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::AssetsManagerEx::State 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (cc::extension::AssetsManagerEx::State)((cc::extension::AssetsManagerEx const *)arg1)->getState();
    
    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_extension_AssetsManager_getState) 

static bool js_cc_extension_AssetsManager_getStoragePath(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    std::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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (std::string *) &((cc::extension::AssetsManagerEx const *)arg1)->getStoragePath();
    
    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_extension_AssetsManager_getStoragePath) 

static bool js_cc_extension_AssetsManager_getLocalManifest(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::Manifest *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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (cc::extension::Manifest *)((cc::extension::AssetsManagerEx const *)arg1)->getLocalManifest();
    
    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_extension_AssetsManager_getLocalManifest) 

static bool js_cc_extension_AssetsManager_loadLocalManifest__SWIG_0(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::Manifest *arg2 = (cc::extension::Manifest *) NULL ;
    std::string *arg3 = 0 ;
    std::string temp3 ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::extension::AssetsManagerEx>(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;
    
    result = (bool)(arg1)->loadLocalManifest(arg2,(std::string const &)*arg3);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

static bool js_cc_extension_AssetsManager_loadLocalManifest__SWIG_1(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    std::string *arg2 = 0 ;
    std::string temp2 ;
    bool result;
    
    arg1 = SE_THIS_OBJECT<cc::extension::AssetsManagerEx>(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)->loadLocalManifest((std::string const &)*arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}

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

static bool js_cc_extension_AssetsManager_getRemoteManifest(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::Manifest *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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (cc::extension::Manifest *)((cc::extension::AssetsManagerEx const *)arg1)->getRemoteManifest();
    
    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_extension_AssetsManager_getRemoteManifest) 

static bool js_cc_extension_AssetsManager_loadRemoteManifest(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::Manifest *arg2 = (cc::extension::Manifest *) NULL ;
    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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    result = (bool)(arg1)->loadRemoteManifest(arg2);
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_loadRemoteManifest) 

static bool js_cc_extension_AssetsManager_isResuming(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (bool)((cc::extension::AssetsManagerEx const *)arg1)->isResuming();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject());
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_isResuming) 

static bool js_cc_extension_AssetsManager_getTotalBytes(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    double 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (double)((cc::extension::AssetsManagerEx const *)arg1)->getTotalBytes();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_getTotalBytes) 

static bool js_cc_extension_AssetsManager_getDownloadedBytes(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    double 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (double)((cc::extension::AssetsManagerEx const *)arg1)->getDownloadedBytes();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_getDownloadedBytes) 

static bool js_cc_extension_AssetsManager_getTotalFiles(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getTotalFiles();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_getTotalFiles) 

static bool js_cc_extension_AssetsManager_getDownloadedFiles(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getDownloadedFiles();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_getDownloadedFiles) 

static bool js_cc_extension_AssetsManager_getMaxConcurrentTask(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getMaxConcurrentTask();
    
    ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); 
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_getMaxConcurrentTask) 

static bool js_cc_extension_AssetsManager_setMaxConcurrentTask(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    int 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::extension::AssetsManagerEx>(s);
    if (nullptr == arg1) return true;
    
    ok &= sevalue_to_native(args[0], &arg2, s.thisObject());
    SE_PRECONDITION2(ok, false, "Error processing arguments"); 
    (arg1)->setMaxConcurrentTask(arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_setMaxConcurrentTask) 

static bool js_cc_extension_AssetsManager_setVersionCompareHandle(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::AssetsManagerEx::VersionCompareHandle *arg2 = 0 ;
    cc::extension::AssetsManagerEx::VersionCompareHandle 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::extension::AssetsManagerEx>(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)->setVersionCompareHandle((cc::extension::AssetsManagerEx::VersionCompareHandle const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_setVersionCompareHandle) 

static bool js_cc_extension_AssetsManager_setVerifyCallback(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::AssetsManagerEx::VerifyCallback *arg2 = 0 ;
    cc::extension::AssetsManagerEx::VerifyCallback 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::extension::AssetsManagerEx>(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)->setVerifyCallback((cc::extension::AssetsManagerEx::VerifyCallback const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_setVerifyCallback) 

static bool js_cc_extension_AssetsManager_setEventCallback(se::State& s)
{
    CC_UNUSED bool ok = true;
    const auto& args = s.args();
    size_t argc = args.size();
    cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ;
    cc::extension::AssetsManagerEx::EventCallback *arg2 = 0 ;
    cc::extension::AssetsManagerEx::EventCallback 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::extension::AssetsManagerEx>(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)->setEventCallback((cc::extension::AssetsManagerEx::EventCallback const &)*arg2);
    
    
    return true;
}
SE_BIND_FUNC(js_cc_extension_AssetsManager_setEventCallback) 

bool js_register_cc_extension_AssetsManagerEx(se::Object* obj) {
    auto* cls = se::Class::create("AssetsManager", obj, nullptr, _SE(js_new_cc_extension_AssetsManagerEx)); 
    
    cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE);
    
    cls->defineFunction("checkUpdate", _SE(js_cc_extension_AssetsManager_checkUpdate)); 
    cls->defineFunction("prepareUpdate", _SE(js_cc_extension_AssetsManager_prepareUpdate)); 
    cls->defineFunction("update", _SE(js_cc_extension_AssetsManager_update)); 
    cls->defineFunction("downloadFailedAssets", _SE(js_cc_extension_AssetsManager_downloadFailedAssets)); 
    cls->defineFunction("getState", _SE(js_cc_extension_AssetsManager_getState)); 
    cls->defineFunction("getStoragePath", _SE(js_cc_extension_AssetsManager_getStoragePath)); 
    cls->defineFunction("getLocalManifest", _SE(js_cc_extension_AssetsManager_getLocalManifest)); 
    cls->defineFunction("loadLocalManifest", _SE(js_cc_extension_AssetsManager_loadLocalManifest)); 
    cls->defineFunction("getRemoteManifest", _SE(js_cc_extension_AssetsManager_getRemoteManifest)); 
    cls->defineFunction("loadRemoteManifest", _SE(js_cc_extension_AssetsManager_loadRemoteManifest)); 
    cls->defineFunction("isResuming", _SE(js_cc_extension_AssetsManager_isResuming)); 
    cls->defineFunction("getTotalBytes", _SE(js_cc_extension_AssetsManager_getTotalBytes)); 
    cls->defineFunction("getDownloadedBytes", _SE(js_cc_extension_AssetsManager_getDownloadedBytes)); 
    cls->defineFunction("getTotalFiles", _SE(js_cc_extension_AssetsManager_getTotalFiles)); 
    cls->defineFunction("getDownloadedFiles", _SE(js_cc_extension_AssetsManager_getDownloadedFiles)); 
    cls->defineFunction("getMaxConcurrentTask", _SE(js_cc_extension_AssetsManager_getMaxConcurrentTask)); 
    cls->defineFunction("setMaxConcurrentTask", _SE(js_cc_extension_AssetsManager_setMaxConcurrentTask)); 
    cls->defineFunction("setVersionCompareHandle", _SE(js_cc_extension_AssetsManager_setVersionCompareHandle)); 
    cls->defineFunction("setVerifyCallback", _SE(js_cc_extension_AssetsManager_setVerifyCallback)); 
    cls->defineFunction("setEventCallback", _SE(js_cc_extension_AssetsManager_setEventCallback)); 
    
    
    cls->defineStaticFunction("create", _SE(js_cc_extension_AssetsManager_create_static)); 
    
    
    cls->defineFinalizeFunction(_SE(js_delete_cc_extension_AssetsManagerEx));
    
    
    cls->install();
    JSBClassType::registerClass<cc::extension::AssetsManagerEx>(cls);
    
    __jsb_cc_extension_AssetsManagerEx_proto = cls->getProto();
    __jsb_cc_extension_AssetsManagerEx_class = cls;
    se::ScriptEngine::getInstance()->clearException();
    return true;
}




bool register_all_extension(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_extension_EventAssetsManagerEx(ns); 
    js_register_cc_extension_DownloadUnit(ns); 
    js_register_cc_extension_ManifestAsset(ns); 
    js_register_cc_extension_Manifest(ns); 
    js_register_cc_extension_Manifest_AssetDiff(ns); 
    js_register_cc_extension_AssetsManagerEx(ns); 
    
    /* 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
