@lcap/nasl 2.22.1 → 2.22.2

package/src/concepts/dist/App__.js

@@ -0,0 +1,2204 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+exports.App = void 0;
+var jsoner_1 = require("../service/storage/jsoner");
+var utils_1 = require("../automate/engine/utils");
+var ConfigProperty__1 = require("./ConfigProperty__");
+var decorators_1 = require("../decorators");
+var utils = require("../utils");
+var BaseNode_1 = require("../common/BaseNode");
+var classMap_1 = require("../common/classMap");
+var DataSource__1 = require("./DataSource__");
+var Structure__1 = require("./Structure__");
+var Enum__1 = require("./Enum__");
+var Logic__1 = require("./Logic__");
+var OverriddenLogic__1 = require("./OverriddenLogic__");
+var Interface__1 = require("./Interface__");
+var AuthInterface__1 = require("./AuthInterface__");
+var Frontend__1 = require("./Frontend__");
+var Backend__1 = require("./Backend__");
+var Process__1 = require("./Process__");
+var Role__1 = require("./Role__");
+var Configuration__1 = require("./Configuration__");
+var Module__1 = require("./Module__");
+var Connector__1 = require("./Connector__");
+var AuthLogic__1 = require("./AuthLogic__");
+var AuthLogicForCallInterface__1 = require("./AuthLogicForCallInterface__");
+/**
+ * 应用
+ */
+var App = /** @class */ (function (_super) {
+    __extends(App, _super);
+    /**
+     * @param source 需要合并的部分参数
+     */
+    function App(source) {
+        var _this = this;
+        source = Object.assign({}, App_1.getDefaultOptions(), source);
+        _this = _super.call(this, source) || this;
+        /**
+         * 应用 Id
+         */
+        _this.id = undefined;
+        /**
+         * 产品概念
+         */
+        _this.concept = 'App';
+        /**
+         * IDE 版本
+         */
+        _this.ideVersion = undefined;
+        /**
+         * 应用标识
+         */
+        _this.name = undefined;
+        /**
+         * 应用标题
+         */
+        _this.title = undefined;
+        /**
+         * 应用图标
+         */
+        _this.icon = undefined;
+        /**
+         * 应用描述
+         */
+        _this.desc = undefined;
+        /**
+         * 域名
+         */
+        _this.dnsAddr = undefined;
+        /**
+         * 是否有用户中心
+         */
+        _this.hasUserCenter = undefined;
+        /**
+         * 是否有权限
+         */
+        _this.hasAuth = undefined;
+        /**
+         * 数据源列表
+         */
+        _this.dataSources = [];
+        /**
+         * 数据结构列表
+         */
+        _this.structures = [];
+        /**
+         * 枚举列表
+         */
+        _this.enums = [];
+        /**
+         * 逻辑列表
+         */
+        _this.logics = [];
+        /**
+         * 逻辑列表
+         */
+        _this.overriddenLogics = [];
+        /**
+         * interfaces
+         */
+        _this.interfaces = [];
+        /**
+         * 端列表
+         */
+        _this.frontends = [];
+        /**
+         * 后端
+         */
+        _this.backend = new Backend__1["default"]();
+        /**
+         * 流程列表
+         */
+        _this.processes = [];
+        /**
+         * 角色列表
+         */
+        _this.roles = [];
+        /**
+         * 配置管理
+         */
+        _this.configuration = new Configuration__1["default"]();
+        /**
+         * 扩展模块列表
+         */
+        _this.dependencies = [];
+        /**
+         * 接口应用列表（兼容老版）
+         */
+        _this.interfaceDependencies = [];
+        /**
+         * 集成
+         */
+        _this.integration = undefined;
+        /**
+         * 暴露接口的接口鉴权
+         */
+        _this.authLogics = [];
+        /**
+         * 调用接口的鉴权模板
+         */
+        _this.authLogicsForCallInterface = [];
+        /**
+         * 是否为官方应用
+         */
+        _this.officialType = undefined;
+        /**
+         * 轻舟项目 Id
+         */
+        _this.projectId = undefined;
+        /**
+         * 租户 Id
+         */
+        _this.tenantId = undefined;
+        /**
+         * 租户 Id
+         */
+        _this.userGroupId = undefined;
+        /**
+         * 多环境
+         */
+        _this.envs = undefined;
+        /**
+         * 多环境
+         */
+        _this.envList = ['dev', 'online'];
+        /**
+         * 发布状态
+         */
+        _this.deploying = undefined;
+        /**
+         * 发布 Id
+         */
+        _this.deploymentId = undefined;
+        /**
+         * 从模板创建的模板 Id
+         */
+        _this.templateId = undefined;
+        /**
+         * 全局设置
+         */
+        _this.preferenceMap = {};
+        _this.packageInfos = [];
+        /**
+         * 当前正在发布的环境，临时状态
+         */
+        _this.curDeployEnv = 'dev';
+        _this.__databaseTypeMap = {};
+        _super.prototype.subConstructor.call(_this, source);
+        return _this;
+    }
+    App_1 = App;
+    App.prototype.getClassName = function () {
+        return 'App';
+    };
+    App.from = function (source, parentNode, parentKey) {
+        return _super.from.call(this, source, parentNode, parentKey);
+    };
+    /**
+     * 从父级删除该节点
+     * @internal
+     */
+    App.prototype._delete = function () {
+        var _a, _b;
+        var params = null;
+        if (this.parentNode) {
+            params = (_b = (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.__removeApp) === null || _b === void 0 ? void 0 : _b.call(_a, this);
+        }
+        return params;
+    };
+    /**
+     * 设置集成
+     */
+    App.prototype.setIntegration = function (integration) {
+        integration._delete();
+        var relationOptions = { parentNode: this, parentKey: 'integration' };
+        Object.assign(integration, relationOptions);
+        var object = {
+            integration: integration
+        };
+        this.update(__assign({}, object));
+    };
+    App.prototype.getDataSourceUniqueName = function (name) {
+        if (name === void 0) { name = 'dataSource1'; }
+        return utils.unique(name, this.getDataSourceExistingNames(), undefined, true);
+    };
+    App.prototype._insertDataSourceAt = function (options, index) {
+        var dataSourceOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'dataSources' };
+        var dataSource;
+        if (!options) {
+            dataSource = DataSource__1["default"].from(__assign(__assign({}, dataSourceOptions), { name: this.getDataSourceUniqueName() }), this, 'dataSources');
+        }
+        else if (typeof options === 'string') {
+            dataSource = DataSource__1["default"].from(__assign(__assign({}, dataSourceOptions), { name: options }), this, 'dataSources');
+        }
+        else if (options instanceof DataSource__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            dataSource = options;
+            Object.assign(dataSource, relationOptions);
+        }
+        else {
+            dataSource = DataSource__1["default"].from(__assign(__assign({}, dataSourceOptions), options), this, 'dataSources');
+        }
+        this.dataSources.splice(index, 0, dataSource);
+        return dataSource;
+    };
+    App.prototype.insertDataSourceAt = function (options, index) {
+        var node = this._insertDataSourceAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'dataSources'
+        });
+        return node;
+    };
+    App.prototype._addDataSource = function (options) {
+        var index = this.dataSources.length;
+        return this._insertDataSourceAt(options, index);
+    };
+    App.prototype.addDataSource = function (options) {
+        var node = this._addDataSource(options);
+        var index = this.dataSources.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'dataSources'
+        });
+        return node;
+    };
+    App.prototype.getStructureExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.structures || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getStructureUniqueName = function (name) {
+        if (name === void 0) { name = 'Structure1'; }
+        return utils.unique(name, this.getStructureExistingNames(), undefined, true);
+    };
+    App.prototype._insertStructureAt = function (options, index) {
+        var structureOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'structures' };
+        var structure;
+        if (!options) {
+            structure = Structure__1["default"].from(__assign(__assign({}, structureOptions), { name: this.getStructureUniqueName() }), this, 'structures');
+        }
+        else if (typeof options === 'string') {
+            structure = Structure__1["default"].from(__assign(__assign({}, structureOptions), { name: options }), this, 'structures');
+        }
+        else if (options instanceof Structure__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            structure = options;
+            Object.assign(structure, relationOptions);
+        }
+        else {
+            structure = Structure__1["default"].from(__assign(__assign({}, structureOptions), options), this, 'structures');
+        }
+        this.structures.splice(index, 0, structure);
+        return structure;
+    };
+    App.prototype.insertStructureAt = function (options, index) {
+        var node = this._insertStructureAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'structures'
+        });
+        return node;
+    };
+    App.prototype._addStructure = function (options) {
+        var index = 0;
+        return this._insertStructureAt(options, index);
+    };
+    App.prototype.addStructure = function (options) {
+        var node = this._addStructure(options);
+        var index = this.structures.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'structures'
+        });
+        return node;
+    };
+    App.prototype.getEnumExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.enums || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getEnumUniqueName = function (name) {
+        if (name === void 0) { name = 'Enum1'; }
+        return utils.unique(name, this.getEnumExistingNames(), undefined, true);
+    };
+    App.prototype._insertEnumAt = function (options, index) {
+        var enumerationOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'enums' };
+        var enumeration;
+        if (!options) {
+            enumeration = Enum__1["default"].from(__assign(__assign({}, enumerationOptions), { name: this.getEnumUniqueName() }), this, 'enums');
+        }
+        else if (typeof options === 'string') {
+            enumeration = Enum__1["default"].from(__assign(__assign({}, enumerationOptions), { name: options }), this, 'enums');
+        }
+        else if (options instanceof Enum__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            enumeration = options;
+            Object.assign(enumeration, relationOptions);
+        }
+        else {
+            enumeration = Enum__1["default"].from(__assign(__assign({}, enumerationOptions), options), this, 'enums');
+        }
+        this.enums.splice(index, 0, enumeration);
+        return enumeration;
+    };
+    App.prototype.insertEnumAt = function (options, index) {
+        var node = this._insertEnumAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'enums'
+        });
+        return node;
+    };
+    App.prototype._addEnum = function (options) {
+        var index = 0;
+        return this._insertEnumAt(options, index);
+    };
+    App.prototype.addEnum = function (options) {
+        var node = this._addEnum(options);
+        var index = this.enums.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'enums'
+        });
+        return node;
+    };
+    App.prototype.getLogicExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.logics || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getLogicUniqueName = function (name) {
+        if (name === void 0) { name = 'logic1'; }
+        return utils.unique(name, this.getLogicExistingNames(), undefined, true);
+    };
+    App.prototype._insertLogicAt = function (options, index) {
+        var logicOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'logics' };
+        var logic;
+        if (!options) {
+            logic = Logic__1["default"].from(__assign(__assign({}, logicOptions), { name: this.getLogicUniqueName() }), this, 'logics');
+        }
+        else if (typeof options === 'string') {
+            logic = Logic__1["default"].from(__assign(__assign({}, logicOptions), { name: options }), this, 'logics');
+        }
+        else if (options instanceof Logic__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            logic = options;
+            Object.assign(logic, relationOptions);
+        }
+        else {
+            logic = Logic__1["default"].from(__assign(__assign({}, logicOptions), options), this, 'logics');
+        }
+        this.logics.splice(index, 0, logic);
+        return logic;
+    };
+    App.prototype.insertLogicAt = function (options, index) {
+        var node = this._insertLogicAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'logics'
+        });
+        return node;
+    };
+    App.prototype._addLogic = function (options) {
+        var index = 0;
+        return this._insertLogicAt(options, index);
+    };
+    App.prototype.addLogic = function (options) {
+        var node = this._addLogic(options);
+        var index = this.logics.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'logics'
+        });
+        return node;
+    };
+    App.prototype._insertAuthLogicInAuthLogicsAt = function (options, index) {
+        var authLogicOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'authLogics' };
+        var authLogic;
+        if (!options) {
+            authLogic = AuthLogic__1["default"].from(__assign(__assign({}, authLogicOptions), { name: this.getAuthLogicUniqueName() }), this, 'authLogics');
+        }
+        else if (typeof options === 'string') {
+            authLogic = AuthLogic__1["default"].from(__assign(__assign({}, authLogicOptions), { name: options }), this, 'authLogics');
+        }
+        else if (options instanceof AuthLogic__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogic = options;
+            Object.assign(authLogic, relationOptions);
+        }
+        else {
+            authLogic = AuthLogic__1["default"].from(__assign(__assign({}, authLogicOptions), options), this, 'authLogics');
+        }
+        this.authLogics.splice(index, 0, authLogic);
+        return authLogic;
+    };
+    App.prototype.insertAuthLogicInAuthLogicsAt = function (options, index) {
+        var node = this._insertAuthLogicInAuthLogicsAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'authLogics'
+        });
+        return node;
+    };
+    App.prototype._addAuthLogicInAuthLogics = function (options) {
+        var index = this.authLogics.length;
+        return this._insertAuthLogicInAuthLogicsAt(options, index);
+    };
+    App.prototype.addAuthLogicInAuthLogics = function (options) {
+        var node = this._addAuthLogicInAuthLogics(options);
+        var index = this.authLogics.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'authLogics'
+        });
+        return node;
+    };
+    App.prototype.getOverriddenLogicExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.overriddenLogics || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getOverriddenLogicUniqueName = function (name) {
+        if (name === void 0) { name = 'overriddenLogic1'; }
+        return utils.unique(name, this.getOverriddenLogicExistingNames(), undefined, true);
+    };
+    App.prototype._insertOverriddenLogicAt = function (options, index) {
+        var overriddenLogicOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'overriddenLogics' };
+        var overriddenLogic;
+        if (!options) {
+            overriddenLogic = OverriddenLogic__1["default"].from(__assign(__assign({}, overriddenLogicOptions), { name: this.getOverriddenLogicUniqueName() }), this, 'overriddenLogics');
+        }
+        else if (typeof options === 'string') {
+            overriddenLogic = OverriddenLogic__1["default"].from(__assign(__assign({}, overriddenLogicOptions), { name: options }), this, 'overriddenLogics');
+        }
+        else if (options instanceof OverriddenLogic__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            overriddenLogic = options;
+            Object.assign(overriddenLogic, relationOptions);
+        }
+        else {
+            overriddenLogic = OverriddenLogic__1["default"].from(__assign(__assign({}, overriddenLogicOptions), options), this, 'overriddenLogics');
+        }
+        this.overriddenLogics.splice(index, 0, overriddenLogic);
+        return overriddenLogic;
+    };
+    App.prototype.insertOverriddenLogicAt = function (options, index) {
+        var node = this._insertOverriddenLogicAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'overriddenLogics'
+        });
+        return node;
+    };
+    App.prototype._addOverriddenLogic = function (options) {
+        var index = 0;
+        return this._insertOverriddenLogicAt(options, index);
+    };
+    App.prototype.addOverriddenLogic = function (options) {
+        var node = this._addOverriddenLogic(options);
+        var index = this.overriddenLogics.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'overriddenLogics'
+        });
+        return node;
+    };
+    App.prototype.getInterfaceExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.interfaces || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getInterfaceUniqueName = function (name) {
+        if (name === void 0) { name = 'Interface1'; }
+        return utils.unique(name, this.getInterfaceExistingNames(), undefined, true);
+    };
+    App.prototype._insertInterfaceInInterfacesAt = function (options, index) {
+        var itfaceOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        var itface;
+        if (!options) {
+            itface = Interface__1["default"].from(__assign(__assign({}, itfaceOptions), { name: this.getInterfaceUniqueName() }), this, 'interfaces');
+        }
+        else if (typeof options === 'string') {
+            itface = Interface__1["default"].from(__assign(__assign({}, itfaceOptions), { name: options }), this, 'interfaces');
+        }
+        else if (options instanceof Interface__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        }
+        else {
+            itface = Interface__1["default"].from(__assign(__assign({}, itfaceOptions), options), this, 'interfaces');
+        }
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    };
+    App.prototype.insertInterfaceInInterfacesAt = function (options, index) {
+        var node = this._insertInterfaceInInterfacesAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'interfaces'
+        });
+        return node;
+    };
+    App.prototype._addInterfaceInInterfaces = function (options) {
+        var index = 0;
+        return this._insertInterfaceInInterfacesAt(options, index);
+    };
+    App.prototype.addInterfaceInInterfaces = function (options) {
+        var node = this._addInterfaceInInterfaces(options);
+        var index = this.interfaces.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'interfaces'
+        });
+        return node;
+    };
+    App.prototype._insertAuthInterfaceInInterfacesAt = function (options, index) {
+        var itfaceOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        var itface;
+        if (!options) {
+            itface = AuthInterface__1["default"].from(__assign(__assign({}, itfaceOptions), { name: this.getAuthInterfaceUniqueName() }), this, 'interfaces');
+        }
+        else if (typeof options === 'string') {
+            itface = AuthInterface__1["default"].from(__assign(__assign({}, itfaceOptions), { name: options }), this, 'interfaces');
+        }
+        else if (options instanceof AuthInterface__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        }
+        else {
+            itface = AuthInterface__1["default"].from(__assign(__assign({}, itfaceOptions), options), this, 'interfaces');
+        }
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    };
+    App.prototype.insertAuthInterfaceInInterfacesAt = function (options, index) {
+        var node = this._insertAuthInterfaceInInterfacesAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'interfaces'
+        });
+        return node;
+    };
+    App.prototype._addAuthInterfaceInInterfaces = function (options) {
+        var index = 0;
+        return this._insertAuthInterfaceInInterfacesAt(options, index);
+    };
+    App.prototype.addAuthInterfaceInInterfaces = function (options) {
+        var node = this._addAuthInterfaceInInterfaces(options);
+        var index = this.interfaces.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'interfaces'
+        });
+        return node;
+    };
+    App.prototype.getFrontendExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.frontends || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getFrontendUniqueName = function (name) {
+        if (name === void 0) { name = 'frontend1'; }
+        return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
+    };
+    App.prototype._insertFrontendAt = function (options, index) {
+        var frontendOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'frontends' };
+        var frontend;
+        if (!options) {
+            frontend = Frontend__1["default"].from(__assign(__assign({}, frontendOptions), { name: this.getFrontendUniqueName() }), this, 'frontends');
+        }
+        else if (typeof options === 'string') {
+            frontend = Frontend__1["default"].from(__assign(__assign({}, frontendOptions), { name: options }), this, 'frontends');
+        }
+        else if (options instanceof Frontend__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            frontend = options;
+            Object.assign(frontend, relationOptions);
+        }
+        else {
+            frontend = Frontend__1["default"].from(__assign(__assign({}, frontendOptions), options), this, 'frontends');
+        }
+        this.frontends.splice(index, 0, frontend);
+        return frontend;
+    };
+    App.prototype.insertFrontendAt = function (options, index) {
+        var node = this._insertFrontendAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'frontends'
+        });
+        return node;
+    };
+    App.prototype._addFrontend = function (options) {
+        var index = this.frontends.length;
+        return this._insertFrontendAt(options, index);
+    };
+    App.prototype.addFrontend = function (options) {
+        var node = this._addFrontend(options);
+        var index = this.frontends.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'frontends'
+        });
+        return node;
+    };
+    App.prototype.getProcessExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.processes || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getProcessUniqueName = function (name) {
+        if (name === void 0) { name = 'Process1'; }
+        return utils.unique(name, this.getProcessExistingNames(), undefined, true);
+    };
+    App.prototype._insertProcessAt = function (options, index) {
+        var processOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'processes' };
+        var process;
+        if (!options) {
+            process = Process__1["default"].from(__assign(__assign({}, processOptions), { name: this.getProcessUniqueName() }), this, 'processes');
+        }
+        else if (typeof options === 'string') {
+            process = Process__1["default"].from(__assign(__assign({}, processOptions), { name: options }), this, 'processes');
+        }
+        else if (options instanceof Process__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            process = options;
+            Object.assign(process, relationOptions);
+        }
+        else {
+            process = Process__1["default"].from(__assign(__assign({}, processOptions), options), this, 'processes');
+        }
+        this.processes.splice(index, 0, process);
+        return process;
+    };
+    App.prototype.insertProcessAt = function (options, index) {
+        var node = this._insertProcessAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'processes'
+        });
+        return node;
+    };
+    App.prototype._addProcess = function (options) {
+        var index = 0;
+        return this._insertProcessAt(options, index);
+    };
+    App.prototype.addProcess = function (options) {
+        var node = this._addProcess(options);
+        var index = this.processes.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'processes'
+        });
+        return node;
+    };
+    App.prototype.getRoleExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.roles || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getRoleUniqueName = function (name) {
+        if (name === void 0) { name = 'role1'; }
+        return utils.unique(name, this.getRoleExistingNames(), undefined, true);
+    };
+    App.prototype._insertRoleAt = function (options, index) {
+        var roleOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'roles' };
+        var role;
+        if (!options) {
+            role = Role__1["default"].from(__assign(__assign({}, roleOptions), { name: this.getRoleUniqueName() }), this, 'roles');
+        }
+        else if (typeof options === 'string') {
+            role = Role__1["default"].from(__assign(__assign({}, roleOptions), { name: options }), this, 'roles');
+        }
+        else if (options instanceof Role__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            role = options;
+            Object.assign(role, relationOptions);
+        }
+        else {
+            role = Role__1["default"].from(__assign(__assign({}, roleOptions), options), this, 'roles');
+        }
+        this.roles.splice(index, 0, role);
+        return role;
+    };
+    App.prototype.insertRoleAt = function (options, index) {
+        var node = this._insertRoleAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'roles'
+        });
+        return node;
+    };
+    App.prototype._addRole = function (options) {
+        var index = this.roles.length;
+        return this._insertRoleAt(options, index);
+    };
+    App.prototype.addRole = function (options) {
+        var node = this._addRole(options);
+        var index = this.roles.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'roles'
+        });
+        return node;
+    };
+    App.prototype.getModuleExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.dependencies || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getModuleUniqueName = function (name) {
+        if (name === void 0) { name = 'module1'; }
+        return utils.unique(name, this.getModuleExistingNames(), undefined, false);
+    };
+    App.prototype._insertModuleInDependenciesAt = function (options, index) {
+        var moduleOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'dependencies' };
+        var module;
+        if (!options) {
+            module = Module__1["default"].from(__assign(__assign({}, moduleOptions), { name: this.getModuleUniqueName() }), this, 'dependencies');
+        }
+        else if (typeof options === 'string') {
+            module = Module__1["default"].from(__assign(__assign({}, moduleOptions), { name: options }), this, 'dependencies');
+        }
+        else if (options instanceof Module__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        }
+        else {
+            module = Module__1["default"].from(__assign(__assign({}, moduleOptions), options), this, 'dependencies');
+        }
+        this.dependencies.splice(index, 0, module);
+        return module;
+    };
+    App.prototype.insertModuleInDependenciesAt = function (options, index) {
+        var node = this._insertModuleInDependenciesAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'dependencies'
+        });
+        return node;
+    };
+    App.prototype._addModuleInDependencies = function (options) {
+        var index = this.dependencies.length;
+        return this._insertModuleInDependenciesAt(options, index);
+    };
+    App.prototype.addModuleInDependencies = function (options) {
+        var node = this._addModuleInDependencies(options);
+        var index = this.dependencies.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'dependencies'
+        });
+        return node;
+    };
+    App.prototype._insertConnectorInDependenciesAt = function (options, index) {
+        var connectorOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'dependencies' };
+        var connector;
+        if (!options) {
+            connector = Connector__1["default"].from(__assign(__assign({}, connectorOptions), { name: this.getConnectorUniqueName() }), this, 'dependencies');
+        }
+        else if (typeof options === 'string') {
+            connector = Connector__1["default"].from(__assign(__assign({}, connectorOptions), { name: options }), this, 'dependencies');
+        }
+        else if (options instanceof Connector__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            connector = options;
+            Object.assign(connector, relationOptions);
+        }
+        else {
+            connector = Connector__1["default"].from(__assign(__assign({}, connectorOptions), options), this, 'dependencies');
+        }
+        this.dependencies.splice(index, 0, connector);
+        return connector;
+    };
+    App.prototype.insertConnectorInDependenciesAt = function (options, index) {
+        var node = this._insertConnectorInDependenciesAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'dependencies'
+        });
+        return node;
+    };
+    App.prototype._addConnectorInDependencies = function (options) {
+        var index = this.dependencies.length;
+        return this._insertConnectorInDependenciesAt(options, index);
+    };
+    App.prototype.addConnectorInDependencies = function (options) {
+        var node = this._addConnectorInDependencies(options);
+        var index = this.dependencies.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'dependencies'
+        });
+        return node;
+    };
+    App.prototype._insertModuleInInterfaceDependenciesAt = function (options, index) {
+        var moduleOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
+        var module;
+        if (!options) {
+            module = Module__1["default"].from(__assign(__assign({}, moduleOptions), { name: this.getModuleUniqueName() }), this, 'interfaceDependencies');
+        }
+        else if (typeof options === 'string') {
+            module = Module__1["default"].from(__assign(__assign({}, moduleOptions), { name: options }), this, 'interfaceDependencies');
+        }
+        else if (options instanceof Module__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            module = options;
+            Object.assign(module, relationOptions);
+        }
+        else {
+            module = Module__1["default"].from(__assign(__assign({}, moduleOptions), options), this, 'interfaceDependencies');
+        }
+        this.interfaceDependencies.splice(index, 0, module);
+        return module;
+    };
+    App.prototype.insertModuleInInterfaceDependenciesAt = function (options, index) {
+        var node = this._insertModuleInInterfaceDependenciesAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies'
+        });
+        return node;
+    };
+    App.prototype._addModuleInInterfaceDependencies = function (options) {
+        var index = this.interfaceDependencies.length;
+        return this._insertModuleInInterfaceDependenciesAt(options, index);
+    };
+    App.prototype.addModuleInInterfaceDependencies = function (options) {
+        var node = this._addModuleInInterfaceDependencies(options);
+        var index = this.interfaceDependencies.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'interfaceDependencies'
+        });
+        return node;
+    };
+    App.prototype.getAuthLogicForCallInterfaceExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.authLogicsForCallInterface || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getAuthLogicForCallInterfaceUniqueName = function (name) {
+        if (name === void 0) { name = 'authLogicForCallInterface1'; }
+        return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+    };
+    App.prototype._insertAuthLogicForCallInterfaceAt = function (options, index) {
+        var authLogicForCallInterfaceOptions = {};
+        var relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+        var authLogicForCallInterface;
+        if (!options) {
+            authLogicForCallInterface = AuthLogicForCallInterface__1["default"].from(__assign(__assign({}, authLogicForCallInterfaceOptions), { name: this.getAuthLogicForCallInterfaceUniqueName() }), this, 'authLogicsForCallInterface');
+        }
+        else if (typeof options === 'string') {
+            authLogicForCallInterface = AuthLogicForCallInterface__1["default"].from(__assign(__assign({}, authLogicForCallInterfaceOptions), { name: options }), this, 'authLogicsForCallInterface');
+        }
+        else if (options instanceof AuthLogicForCallInterface__1["default"]) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            authLogicForCallInterface = options;
+            Object.assign(authLogicForCallInterface, relationOptions);
+        }
+        else {
+            authLogicForCallInterface = AuthLogicForCallInterface__1["default"].from(__assign(__assign({}, authLogicForCallInterfaceOptions), options), this, 'authLogicsForCallInterface');
+        }
+        this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+        return authLogicForCallInterface;
+    };
+    App.prototype.insertAuthLogicForCallInterfaceAt = function (options, index) {
+        var node = this._insertAuthLogicForCallInterfaceAt(options, index);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface'
+        });
+        return node;
+    };
+    App.prototype._addAuthLogicForCallInterface = function (options) {
+        var index = this.authLogicsForCallInterface.length;
+        return this._insertAuthLogicForCallInterfaceAt(options, index);
+    };
+    App.prototype.addAuthLogicForCallInterface = function (options) {
+        var node = this._addAuthLogicForCallInterface(options);
+        var index = this.authLogicsForCallInterface.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'authLogicsForCallInterface'
+        });
+        return node;
+    };
+    App.prototype.removeDataSource = function (options) {
+        var dataSource;
+        if (typeof options === 'string') {
+            dataSource = this.dataSources.find(function (item) { return item.name === options; });
+            if (!dataSource) {
+                throw new Error('找不到数据源 ' + options);
+            }
+        }
+        else {
+            dataSource = options;
+        }
+        return dataSource["delete"]();
+    };
+    App.prototype.__removeDataSource = function (dataSource) {
+        var parentKey = dataSource.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: dataSource
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(dataSource);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === dataSource) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeStructure = function (options) {
+        var structure;
+        if (typeof options === 'string') {
+            structure = this.structures.find(function (item) { return item.name === options; });
+            if (!structure) {
+                throw new Error('找不到数据结构 ' + options);
+            }
+        }
+        else {
+            structure = options;
+        }
+        return structure["delete"]();
+    };
+    App.prototype.__removeStructure = function (structure) {
+        var parentKey = structure.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: structure
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(structure);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === structure) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeEnum = function (options) {
+        var enumeration;
+        if (typeof options === 'string') {
+            enumeration = this.enums.find(function (item) { return item.name === options; });
+            if (!enumeration) {
+                throw new Error('找不到枚举 ' + options);
+            }
+        }
+        else {
+            enumeration = options;
+        }
+        return enumeration["delete"]();
+    };
+    App.prototype.__removeEnum = function (enumeration) {
+        var parentKey = enumeration.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: enumeration
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(enumeration);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === enumeration) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeLogic = function (options) {
+        var logic;
+        if (typeof options === 'string') {
+            logic = this.logics.find(function (item) { return item.name === options; });
+            if (!logic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        }
+        else {
+            logic = options;
+        }
+        return logic["delete"]();
+    };
+    App.prototype.removeAuthLogicInAuthLogics = function (options) {
+        var authLogic;
+        if (typeof options === 'string') {
+            authLogic = this.authLogics.find(function (item) { return item.name === options; });
+            if (!authLogic) {
+                throw new Error('找不到开放接口的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogic = options;
+        }
+        return authLogic["delete"]();
+    };
+    App.prototype.__removeLogic = function (logic) {
+        var parentKey = logic.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: logic
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(logic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === logic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeOverriddenLogic = function (options) {
+        var overriddenLogic;
+        if (typeof options === 'string') {
+            overriddenLogic = this.overriddenLogics.find(function (item) { return item.name === options; });
+            if (!overriddenLogic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        }
+        else {
+            overriddenLogic = options;
+        }
+        return overriddenLogic["delete"]();
+    };
+    App.prototype.__removeOverriddenLogic = function (overriddenLogic) {
+        var parentKey = overriddenLogic.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: overriddenLogic
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(overriddenLogic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === overriddenLogic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeInterfaceInInterfaces = function (options) {
+        var itface;
+        if (typeof options === 'string') {
+            itface = this.interfaces.find(function (item) { return item.name === options; });
+            if (!itface) {
+                throw new Error('找不到接口 ' + options);
+            }
+        }
+        else {
+            itface = options;
+        }
+        return itface["delete"]();
+    };
+    App.prototype.removeAuthInterfaceInInterfaces = function (options) {
+        var itface;
+        if (typeof options === 'string') {
+            itface = this.interfaces.find(function (item) { return item.name === options; });
+            if (!itface) {
+                throw new Error('找不到接口 ' + options);
+            }
+        }
+        else {
+            itface = options;
+        }
+        return itface["delete"]();
+    };
+    App.prototype.__removeInterface = function (itface) {
+        var parentKey = itface.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: itface
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(itface);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === itface) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeFrontend = function (options) {
+        var frontend;
+        if (typeof options === 'string') {
+            frontend = this.frontends.find(function (item) { return item.name === options; });
+            if (!frontend) {
+                throw new Error('找不到端 ' + options);
+            }
+        }
+        else {
+            frontend = options;
+        }
+        return frontend["delete"]();
+    };
+    App.prototype.__removeFrontend = function (frontend) {
+        var parentKey = frontend.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: frontend
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(frontend);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === frontend) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeBackend = function (options) {
+        var backend;
+        if (typeof options === 'string') {
+            backend = this.backend;
+            if (!backend) {
+                throw new Error('找不到后端 ' + options);
+            }
+        }
+        else {
+            backend = options;
+        }
+        return backend["delete"]();
+    };
+    App.prototype.__removeBackend = function (backend) {
+        var parentKey = backend.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: backend
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(backend);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === backend) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeProcess = function (options) {
+        var process;
+        if (typeof options === 'string') {
+            process = this.processes.find(function (item) { return item.name === options; });
+            if (!process) {
+                throw new Error('找不到流程 ' + options);
+            }
+        }
+        else {
+            process = options;
+        }
+        return process["delete"]();
+    };
+    App.prototype.__removeProcess = function (process) {
+        var parentKey = process.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: process
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(process);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === process) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeRole = function (options) {
+        var role;
+        if (typeof options === 'string') {
+            role = this.roles.find(function (item) { return item.name === options; });
+            if (!role) {
+                throw new Error('找不到角色 ' + options);
+            }
+        }
+        else {
+            role = options;
+        }
+        return role["delete"]();
+    };
+    App.prototype.__removeRole = function (role) {
+        var parentKey = role.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: role
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(role);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === role) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeConfiguration = function (options) {
+        var configuration;
+        if (typeof options === 'string') {
+            configuration = this.configuration;
+            if (!configuration) {
+                throw new Error('找不到配置管理 ' + options);
+            }
+        }
+        else {
+            configuration = options;
+        }
+        return configuration["delete"]();
+    };
+    App.prototype.__removeConfiguration = function (configuration) {
+        var parentKey = configuration.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: configuration
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(configuration);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === configuration) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeModuleInDependencies = function (options) {
+        var module;
+        if (typeof options === 'string') {
+            module = this.dependencies.find(function (item) { return item.name === options; });
+            if (!module) {
+                throw new Error('找不到模块 ' + options);
+            }
+        }
+        else {
+            module = options;
+        }
+        return module["delete"]();
+    };
+    App.prototype.removeConnectorInDependencies = function (options) {
+        var connector;
+        if (typeof options === 'string') {
+            connector = this.dependencies.find(function (item) { return item.name === options; });
+            if (!connector) {
+                throw new Error('找不到连接器 ' + options);
+            }
+        }
+        else {
+            connector = options;
+        }
+        return connector["delete"]();
+    };
+    App.prototype.removeModuleInInterfaceDependencies = function (options) {
+        var module;
+        if (typeof options === 'string') {
+            module = this.interfaceDependencies.find(function (item) { return item.name === options; });
+            if (!module) {
+                throw new Error('找不到模块 ' + options);
+            }
+        }
+        else {
+            module = options;
+        }
+        return module["delete"]();
+    };
+    App.prototype.__removeModule = function (module) {
+        var parentKey = module.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: module
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(module);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === module) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeIntegration = function (options) {
+        var integration;
+        if (typeof options === 'string') {
+            integration = this.integration;
+            if (!integration) {
+                throw new Error('找不到集成 ' + options);
+            }
+        }
+        else {
+            integration = options;
+        }
+        return integration["delete"]();
+    };
+    App.prototype.__removeIntegration = function (integration) {
+        var parentKey = integration.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: integration
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(integration);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === integration) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    App.prototype.removeAuthLogicForCallInterface = function (options) {
+        var authLogicForCallInterface;
+        if (typeof options === 'string') {
+            authLogicForCallInterface = this.authLogicsForCallInterface.find(function (item) { return item.name === options; });
+            if (!authLogicForCallInterface) {
+                throw new Error('找不到调用的鉴权逻辑 ' + options);
+            }
+        }
+        else {
+            authLogicForCallInterface = options;
+        }
+        return authLogicForCallInterface["delete"]();
+    };
+    App.prototype.__removeAuthLogic = function (authLogic) {
+        var parentKey = authLogic.parentKey;
+        var params = {
+            parentNode: this,
+            parentKey: parentKey,
+            index: -1,
+            object: null,
+            oldObject: authLogic
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                var index = this[parentKey].indexOf(authLogic);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === authLogic) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    };
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+    App.prototype.findDataSourceByName = function (name) {
+        return this.dataSources.find(function (dataSourceItem) { return dataSourceItem.name === name; });
+    };
+    Object.defineProperty(App.prototype, "defaultDS", {
+        get: function () {
+            var _a;
+            return (_a = this.dataSources) === null || _a === void 0 ? void 0 : _a.find(function (dataSource) { return dataSource.name === 'defaultDS'; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    App.prototype.findEnumByName = function (name) {
+        return this.enums.find(function (enumItem) { return enumItem.name === name; });
+    };
+    App.prototype.findStructureByName = function (name) {
+        return this.structures.find(function (item) { return item.name === name; });
+    };
+    App.prototype.findLogicByName = function (name) {
+        return this.logics.find(function (logic) { return logic.name === name; });
+    };
+    /**
+     * 获取命名空间
+     */
+    App.prototype.getNamespace = function () {
+        return 'app';
+    };
+    App.prototype.getTsNamespace = function () {
+        return "app";
+    };
+    App.prototype.findNodeByPath = function (nodePath) {
+        return jsoner_1.queryNodeByPath(this, nodePath);
+    };
+    App.prototype.findNodeByCompleteName = function (completeName) {
+        var nameArr = (completeName === null || completeName === void 0 ? void 0 : completeName.split('.')) || [];
+        var node = this;
+        // 先处理平台的
+        if (completeName.startsWith('nasl')) {
+            node = utils_1.getNaslNodeByNodeCallee(nameArr.splice(0, nameArr.length - 1).join('.'), nameArr[nameArr.length - 1]);
+            return node;
+        }
+        var start = nameArr.shift();
+        var mod = 0;
+        var modulesMap = {
+            extensions: node.dependencies,
+            apis: node.interfaceDependencies,
+            components: node.componentDependencies
+        };
+        var modules = modulesMap[start];
+        if (Array.isArray(modules)) {
+            var moduleName_1 = nameArr.shift();
+            node = modules.find(function (moduleItem) { return moduleItem.name === moduleName_1; });
+        }
+        var _loop_1 = function (index) {
+            if (!node) {
+                return { value: null };
+            }
+            var nameItem = nameArr[index];
+            // const isKeyword = index % 2 === mod;
+            // if (!isKeyword && Array.isArray(node)) {
+            //     node = node.find(({ name }) => name === nameItem);
+            // } else {
+            //     node = node[nameItem];
+            // }
+            if (Array.isArray(node)) {
+                node = node.find(function (_a) {
+                    var name = _a.name;
+                    return name === nameItem;
+                });
+            }
+            else {
+                node = node[nameItem];
+            }
+        };
+        for (var index = 0; index < nameArr.length; index++) {
+            var state_1 = _loop_1(index);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        return node;
+    };
+    App.prototype.loadEnvList = function () {
+        this.envList = ['dev', 'online'];
+    };
+    App.prototype.loadPackageInfo = function (scope) {
+        var dependencyMap = window.globalData.ideVersionDetail.dependencies;
+        var packageInfo = {
+            template: { name: '', version: '', scope: scope },
+            ui: { name: '', version: '', scope: scope },
+            scope: scope
+        };
+        packageInfo.template.name = scope === 'h5' ? '@lcap/mobile-template' : 'lcap-pc-template';
+        packageInfo.template.version = scope === 'h5' ? dependencyMap.FrontendArchH5.version : dependencyMap.FrontendArchPC.version;
+        packageInfo.ui.name = scope === 'h5' ? '@lcap/mobile-ui' : 'cloud-ui.vusion';
+        packageInfo.ui.version = scope === 'h5' ? dependencyMap.FrontendComponentLibraryH5.version : dependencyMap.FrontendComponentLibraryPC.version;
+        return packageInfo;
+    };
+    App.prototype.loadPackageInfos = function () {
+        var _this = this;
+        this.packageInfos = [];
+        var scopes = ['pc', 'h5'];
+        scopes.forEach(function (scope) {
+            _this.packageInfos.push(_this.loadPackageInfo(scope));
+        });
+    };
+    /**
+     * 根据 packageInfo 的信息生成用于 load 的 assetsInfo
+     * 在环境中需要 basic 和 custom 分开 load，否则容易报错
+     * @param prefix
+     */
+    App.prototype.genAllAssetsInfo = function (prefix, scope) {
+        // const packageInfo = this.packageInfo;
+        var packageInfo = this.packageInfos.find(function (info) { return info.scope === scope; });
+        var result = {
+            basic: {
+                js: [
+                    prefix + "/packages/vue@2/dist/vue.min.js",
+                    // `${prefix}/packages/vue-router@3/dist/vue-router.min.js`,
+                    scope === 'h5' ? prefix + "/packages/@lcap/mobile-ui@" + packageInfo.ui.version + "/dist-theme/index.js" : prefix + "/packages/cloud-ui.vusion@" + packageInfo.ui.version + "/dist-theme/index.js",
+                    scope === 'h5' ? prefix + "/packages/@lcap/mobile-template@" + packageInfo.template.version + "/cloudAdminDesigner.umd.min.js" : prefix + "/packages/lcap-pc-template@" + packageInfo.template.version + "/cloudAdminDesigner.umd.min.js",
+                ],
+                css: [
+                    scope === 'h5' ? prefix + "/packages/@lcap/mobile-ui@" + packageInfo.ui.version + "/dist-theme/index.css" : prefix + "/packages/cloud-ui.vusion@" + packageInfo.ui.version + "/dist-theme/index.css",
+                    scope === 'h5' ? prefix + "/packages/@lcap/mobile-template@" + packageInfo.template.version + "/cloudAdminDesigner.css" : prefix + "/packages/lcap-pc-template@" + packageInfo.template.version + "/cloudAdminDesigner.css",
+                ]
+            },
+            custom: {
+                js: [],
+                css: [],
+                names: []
+            }
+        };
+        var frontends = this.frontends.filter(function (frontend) { return frontend.type === scope; });
+        var existingSet = new Set();
+        frontends.forEach(function (frontend) {
+            frontend.componentDependencies.forEach(function (dep) {
+                var name = dep.name, version = dep.version;
+                var jsName = prefix + "/packages/" + name + "@" + version + "/dist-theme/index.js";
+                if (!existingSet.has(jsName)) {
+                    existingSet.add(jsName);
+                    result.custom.js.push(jsName);
+                    if (utils.shouldLoadCss(name, version)) {
+                        result.custom.css.push(prefix + "/packages/" + name + "@" + version + "/dist-theme/index.css");
+                    }
+                    result.custom.names.push(name);
+                }
+            });
+        });
+        this.dependencies.forEach(function (dep) {
+            (dep.frontends || []).forEach(function (frontend) {
+                if (frontend.type === scope) {
+                    var jsName = prefix + "/packages/" + dep.name + "@" + dep.version + "/dist-theme/index.js";
+                    if (!existingSet.has(jsName)) {
+                        existingSet.add(jsName);
+                        result.custom.js.push(jsName);
+                        result.custom.names.push(dep.name);
+                    }
+                }
+            });
+        });
+        return result;
+    };
+    App.prototype.onChange = function ($event) {
+        this.emit('change', $event);
+    };
+    App.prototype.addModuleInDependenciesWithDataSource = function (options) {
+        var _this = this;
+        var _a;
+        this.emit('collect:start', {
+            actionMsg: '导入依赖库'
+        });
+        var existSameNameNode = this.dependencies.find(function (l) { return l.name === options.name; });
+        // 同名同版本的依赖库会替换 同名不同版本的依赖库会保留并设置为禁用
+        // (options as Module).enable = true;
+        if (existSameNameNode) {
+            // const hasSameVersion = existSameNameNode.version === (options as Module).version;
+            // if (hasSameVersion) {
+            existSameNameNode["delete"]();
+            // }
+            // 同名的依赖库 只启用第一个
+            // (options as Module).enable = hasSameVersion;
+        }
+        //  导入依赖库的时候如果有logic 且logic 可以被覆写 需要在app overideLogic 新增一个
+        // 但是导入局部模板的时候已经手动新增了 这里就不需要了
+        // 当依赖库被删除 的时候同样要删除 overideLogic
+        // 支持局部模板导出导入overideLogic
+        // 只复制 depLogic  输入输出参数
+        var node = this.addModuleInDependencies(options);
+        if ((node === null || node === void 0 ? void 0 : node.logics) && (node === null || node === void 0 ? void 0 : node.logics.length) > 0) {
+            node.logics.forEach(function (logic) {
+                if (logic === null || logic === void 0 ? void 0 : logic.overridable) {
+                    var existing = _this.overriddenLogics.find(function (ol) { return ol.name === logic.name; });
+                    !existing && _this.addOverriddenLogic({
+                        name: logic.name,
+                        description: logic.description,
+                        overriddenModule: node.name,
+                        returns: logic.returns.map(function (r) { return r.toJSON(); }),
+                        params: logic.params.map(function (r) { return r.toJSON(); })
+                    });
+                }
+            });
+        }
+        // 启用的依赖库才创建数据源
+        // if (node.enable && node.dataSources) {
+        if (node.dataSources) {
+            var dataSourceGroup_1 = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.getGroup('dataSource');
+            if (dataSourceGroup_1) {
+                node.dataSources.forEach(function (datasource) {
+                    var body = ConfigProperty__1["default"].from({
+                        name: datasource.name,
+                        description: '',
+                        isPrivate: false,
+                        values: [
+                            { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
+                            { env: 'online', value: '', concept: 'ConfigPropertyValue' },
+                        ]
+                    });
+                    dataSourceGroup_1.addConfigProperty(body);
+                });
+            }
+        }
+        this.emit('collect:end');
+    };
+    App.prototype.statistics = function () {
+        var sum = function (list) { return list.reduce(function (curr, prev) { return prev + curr; }, 0); };
+        var countView = function (list) { return list.length + sum(list.map(function (view) { return countView(view.children); })); };
+        return {
+            entityCount: sum(this.dataSources.map(function (dataSource) { return dataSource.entities.length; })),
+            structureCount: this.structures.length,
+            enumCount: this.enums.length,
+            logicCount: this.logics.length,
+            viewCount: sum(this.frontends.map(function (frontend) { return countView(frontend.views); })),
+            processCount: this.processes.length
+        };
+    };
+    /**
+     * 需要包含依赖库里的dataSources，不自动生成
+     */
+    App.prototype.getDataSourceExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        var dependDatasources = [];
+        var modules = __spreadArrays(this.dependencies);
+        modules.forEach(function (module) {
+            if (Array.isArray(module.dataSources)) {
+                dependDatasources.push.apply(dependDatasources, module.dataSources);
+            }
+        });
+        var dataSources = this.dataSources.concat(dependDatasources);
+        return (dataSources || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    /**
+     * 更新全局设置 preferenceMap
+     */
+    App.prototype.updatePreferenceMap = function (preferences) {
+        if (preferences === void 0) { preferences = {}; }
+        this.emit('collect:start', { actionMsg: '修改实体表名列名' });
+        var oldPreferenceMap = __assign({}, this.preferenceMap);
+        Object.assign(this.preferenceMap, preferences);
+        // 更新实体表名和列名
+        this.dataSources.forEach(function (ds) {
+            ds.entities.forEach(function (e) {
+                if (oldPreferenceMap['namingConvention.tableName'] !== preferences['namingConvention.tableName']) {
+                    e.formatTableName();
+                }
+                if (oldPreferenceMap['namingConvention.columnName'] !== preferences['namingConvention.columnName']) {
+                    e.formatPropertyColumnName();
+                }
+            });
+        });
+        // 使撤销生效
+        Object.assign(this.preferenceMap, oldPreferenceMap);
+        this.update({
+            preferenceMap: preferences
+        });
+        this.emit('collect:end');
+    };
+    /* 判断接口是否有误，需要重新导出 */
+    App.prototype.getQualifiedInterface = function (interfaces) {
+        var _this = this;
+        if (interfaces === void 0) { interfaces = this.interfaces; }
+        var errorList = [];
+        interfaces.forEach(function (item) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            var logic = _this.logics.find(function (logic) { return logic.name === item.originLogicName; });
+            var logicParamMap = {};
+            logic.params.forEach(function (param) {
+                logicParamMap[param.name] = param.typeAnnotation;
+            });
+            item.params.forEach(function (param) {
+                var _a;
+                var logicTypeAnnotation = (_a = logicParamMap[param.name]) === null || _a === void 0 ? void 0 : _a.toJSON();
+                delete logicParamMap[param.name];
+                if (!logicTypeAnnotation) {
+                    return errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        param: param.name,
+                        type: 1,
+                        message: "\u53C2\u6570\u201C" + param.name + "\u201D\u5DF2\u88AB\u5220\u9664\uFF0C\u8BF7\u786E\u5B9A\u8BF7\u6C42\u7C7B\u578B\u65E0\u8BEF\u540E\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                    });
+                }
+                var interfaceTypeAnnotation = param.typeAnnotation.toJSON();
+                var isSame = false;
+                if ((logicTypeAnnotation === null || logicTypeAnnotation === void 0 ? void 0 : logicTypeAnnotation.typeNamespace) === 'app.enums') {
+                    if (interfaceTypeAnnotation.typeNamespace === 'nasl.core' && interfaceTypeAnnotation.typeName === 'String') {
+                        isSame = true;
+                    }
+                }
+                if (JSON.stringify(logicTypeAnnotation) === JSON.stringify(interfaceTypeAnnotation)) {
+                    isSame = true;
+                }
+                if (!isSame) {
+                    errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        param: param.name,
+                        type: 2,
+                        message: "\u53C2\u6570\u201C" + param.name + "\u201D\u6570\u636E\u7C7B\u578B\u53D8\u66F4\uFF0C\u8BF7\u786E\u5B9A\u8BF7\u6C42\u7C7B\u578B\u65E0\u8BEF\u540E\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                    });
+                }
+            });
+            var logicReturns = logic.returns;
+            var interfaceReturns = item.returns;
+            if ((logicReturns === null || logicReturns === void 0 ? void 0 : logicReturns.length) > (interfaceReturns === null || interfaceReturns === void 0 ? void 0 : interfaceReturns.length)) {
+                if (!logicReturns[0].typeAnnotation) {
+                    errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        resultName: logicReturns[0].name,
+                        type: 4,
+                        message: "\u8F93\u51FA\u53C2\u6570\u53D1\u751F\u53D8\u66F4\uFF0C\u8BF7\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                    });
+                }
+                else {
+                    errorList.push({
+                        logicName: logic.name,
+                        interfaceName: item.name,
+                        resultName: logicReturns[0].name,
+                        type: 4,
+                        message: "\u8F93\u51FA\u53C2\u6570\u53D1\u751F\u53D8\u66F4\uFF0C\u8BF7\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                    });
+                }
+            }
+            else if ((logicReturns === null || logicReturns === void 0 ? void 0 : logicReturns.length) < (interfaceReturns === null || interfaceReturns === void 0 ? void 0 : interfaceReturns.length)) {
+                errorList.push({
+                    logicName: logic.name,
+                    interfaceName: item.name,
+                    resultName: interfaceReturns[0].name,
+                    type: 4,
+                    message: "\u8F93\u51FA\u53C2\u6570\u53D1\u751F\u53D8\u66F4\uFF0C\u8BF7\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                });
+            }
+            else if ((logicReturns === null || logicReturns === void 0 ? void 0 : logicReturns.length) === (interfaceReturns === null || interfaceReturns === void 0 ? void 0 : interfaceReturns.length)) {
+                if (logicReturns.length !== 0) {
+                    if (logicReturns[0].name !== interfaceReturns[0].name) {
+                        errorList.push({
+                            logicName: logic.name,
+                            interfaceName: item.name,
+                            resultName: logicReturns[0].name,
+                            type: 4,
+                            message: "\u8F93\u51FA\u53C2\u6570\u53D1\u751F\u53D8\u66F4\uFF0C\u8BF7\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                        });
+                    }
+                    else if (!logicReturns[0].typeAnnotation) {
+                        if (!((_a = logicReturns[0]) === null || _a === void 0 ? void 0 : _a.__TypeAnnotation)) {
+                            errorList.push({
+                                logicName: logic.name,
+                                interfaceName: item.name,
+                                resultName: logicReturns[0].name,
+                                type: 7,
+                                message: "\u8F93\u51FA\u53C2\u6570\u201C" + logicReturns[0].name + "\u201D\u6CA1\u6709\u6570\u636E\u7C7B\u578B\uFF0C\u65E0\u6CD5\u5BFC\u51FA"
+                            });
+                        }
+                        else if (!((_b = logicReturns[0]) === null || _b === void 0 ? void 0 : _b.__TypeAnnotation.isSame((_c = interfaceReturns[0]) === null || _c === void 0 ? void 0 : _c.typeAnnotation))) {
+                            errorList.push({
+                                logicName: logic.name,
+                                interfaceName: item.name,
+                                resultName: logicReturns[0].name,
+                                type: 4,
+                                message: "\u8F93\u51FA\u53C2\u6570\u53D1\u751F\u53D8\u66F4\uFF0C\u8BF7\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                            });
+                        }
+                    }
+                    else if (JSON.stringify((_e = (_d = logicReturns[0]) === null || _d === void 0 ? void 0 : _d.typeAnnotation) === null || _e === void 0 ? void 0 : _e.toJSON()) !== JSON.stringify((_g = (_f = interfaceReturns[0]) === null || _f === void 0 ? void 0 : _f.typeAnnotation) === null || _g === void 0 ? void 0 : _g.toJSON())) {
+                        errorList.push({
+                            logicName: logic.name,
+                            interfaceName: item.name,
+                            resultName: logicReturns[0].name,
+                            type: 4,
+                            message: "\u8F93\u51FA\u53C2\u6570\u53D1\u751F\u53D8\u66F4\uFF0C\u8BF7\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D"
+                        });
+                    }
+                }
+            }
+            for (var i in logicParamMap) {
+                errorList.push({
+                    logicName: logic.name,
+                    param: i,
+                    message: "\u65B0\u589E\u53C2\u6570\u201C" + i + "\u201D\uFF0C\u8BF7\u786E\u5B9A\u8BF7\u6C42\u7C7B\u578B\u65E0\u8BEF\u540E\u70B9\u51FB\u201C\u91CD\u65B0\u5BFC\u51FA\u201D",
+                    type: 3
+                });
+            }
+        });
+        return errorList;
+    };
+    App.prototype.addFrontendForType = function (options) {
+        var insertIndex = -1;
+        this.frontends.forEach(function (frontend, index) {
+            if (frontend.type === options.type) {
+                insertIndex = index;
+            }
+        });
+        if (options.type === 'h5' && insertIndex === -1) {
+            insertIndex = this.frontends.length;
+        }
+        var node = this._insertFrontendAt(options, insertIndex + 1);
+        var index = this.frontends.indexOf(node);
+        node.create({
+            index: index,
+            parentNode: this,
+            parentKey: 'frontends'
+        });
+        return node;
+    };
+    App.prototype.getFrontendExistingTitles = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.frontends || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.title; });
+    };
+    App.prototype.getExtensionsCallbackLogics = function () {
+        var resultLogics = [];
+        this.frontends.forEach(function (frontend) {
+            resultLogics = __spreadArrays(resultLogics, frontend.getExtensionsCallbackLogics());
+        });
+        return Array.from(new Set(resultLogics));
+    };
+    App.prototype.getJavaLogicUniqueName = function (name) {
+        if (name === void 0) { name = 'javalogic1'; }
+        return utils.unique(name, this.getLogicExistingNames(), undefined, true);
+    };
+    App.prototype.getJavaLogicClassUniqueName = function (name) {
+        if (name === void 0) { name = 'Javalogic1'; }
+        return utils.unique(name, this.getLogicExistingNames(), undefined, true) + 'Service';
+    };
+    App.prototype.genAllCustomComponents = function () {
+        var frontends = this.frontends;
+        var compMap = {
+            pc: [],
+            h5: []
+        };
+        var existingSet = new Set();
+        frontends.forEach(function (frontend) {
+            if (frontend.componentDependencies) {
+                frontend.componentDependencies.forEach(function (dep) {
+                    var name = dep.name;
+                    if (!existingSet.has(name)) {
+                        compMap[frontend.type].push(dep);
+                    }
+                });
+            }
+        });
+        return compMap;
+    };
+    Object.defineProperty(App.prototype, "sysPrefixPath", {
+        /**
+         * 获取 “系统统一路径前缀”
+         * @returns
+         */
+        get: function () {
+            var _this = this;
+            var _a, _b, _c, _d, _e, _f;
+            var uniformPathPrefix = (_f = (_e = (_d = (_c = (_b = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.find(function (item) { return item.name === 'system'; })) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.find(function (item) { return item.name === 'uniformPathPrefix'; })) === null || _e === void 0 ? void 0 : _e.values.find(function (item) { return item.env === _this.curDeployEnv; })) === null || _f === void 0 ? void 0 : _f.value;
+            var sysPrefixPath = uniformPathPrefix && uniformPathPrefix !== '/' ? uniformPathPrefix : '';
+            return sysPrefixPath;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    App.prototype.getAuthLogicExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.authLogics || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getAuthLogicUniqueName = function (name) {
+        if (name === void 0) { name = 'authentication1'; }
+        return utils.unique(name, this.getAuthLogicExistingNames(), undefined, true);
+    };
+    App.prototype.getAuthInterfaceUniqueName = function (name) {
+        if (name === void 0) { name = 'authInterface1'; }
+        // never used
+    };
+    Object.defineProperty(App.prototype, "appTimeZone", {
+        get: function () {
+            var _this = this;
+            var _a, _b, _c, _d, _e, _f;
+            return (_f = (_e = (_d = (_c = (_b = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.find(function (item) { return item.name === 'system'; })) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.find(function (item) { return item.name === 'appTimeZone'; })) === null || _e === void 0 ? void 0 : _e.values.find(function (item) { return item.env === _this.curDeployEnv; })) === null || _f === void 0 ? void 0 : _f.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // FIXME: 没有设置 dontGenGetUniqueName 为什么 不会生成 唯一标识逻辑？？？
+    App.prototype.getConnectorExistingNames = function (excludedList) {
+        if (excludedList === void 0) { excludedList = []; }
+        var excludedSet = new Set(excludedList);
+        return (this.dependencies || []).filter(function (item) { return !excludedSet.has(item); }).map(function (item) { return item.name; });
+    };
+    App.prototype.getConnectorUniqueName = function (name) {
+        if (name === void 0) { name = 'connector1'; }
+        return utils.unique(name, this.getConnectorExistingNames(), undefined, false);
+    };
+    var App_1;
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "id");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "concept");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "ideVersion");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "name");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "title");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "icon");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "desc");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "dnsAddr");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "hasUserCenter");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "hasAuth");
+    __decorate([
+        decorators_1.property('DataSource')
+    ], App.prototype, "dataSources");
+    __decorate([
+        decorators_1.property('Structure')
+    ], App.prototype, "structures");
+    __decorate([
+        decorators_1.property('Enum')
+    ], App.prototype, "enums");
+    __decorate([
+        decorators_1.property('Logic')
+    ], App.prototype, "logics");
+    __decorate([
+        decorators_1.property('OverriddenLogic')
+    ], App.prototype, "overriddenLogics");
+    __decorate([
+        decorators_1.property('Interface | AuthInterface')
+    ], App.prototype, "interfaces");
+    __decorate([
+        decorators_1.property('Frontend')
+    ], App.prototype, "frontends");
+    __decorate([
+        decorators_1.property('Backend')
+    ], App.prototype, "backend");
+    __decorate([
+        decorators_1.property('Process')
+    ], App.prototype, "processes");
+    __decorate([
+        decorators_1.property('Role')
+    ], App.prototype, "roles");
+    __decorate([
+        decorators_1.property('Configuration')
+    ], App.prototype, "configuration");
+    __decorate([
+        decorators_1.property('Module | Connector')
+    ], App.prototype, "dependencies");
+    __decorate([
+        decorators_1.property('Module')
+    ], App.prototype, "interfaceDependencies");
+    __decorate([
+        decorators_1.property('Integration')
+    ], App.prototype, "integration");
+    __decorate([
+        decorators_1.property('AuthLogic')
+    ], App.prototype, "authLogics");
+    __decorate([
+        decorators_1.property('AuthLogicForCallInterface')
+    ], App.prototype, "authLogicsForCallInterface");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "officialType");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "projectId");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "tenantId");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "userGroupId");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "envs");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "envList");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "deploying");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "deploymentId");
+    __decorate([
+        decorators_1.excludedInJSON()
+    ], App.prototype, "templateId");
+    __decorate([
+        decorators_1.property()
+    ], App.prototype, "preferenceMap");
+    App = App_1 = __decorate([
+        decorators_1.concept('应用')
+    ], App);
+    return App;
+}(BaseNode_1["default"]));
+exports.App = App;
+classMap_1["default"].App = App;
+exports["default"] = App;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================