@lcap/nasl 3.6.4-beta.3 → 3.6.4-beta.5

package/dist/src/server/naslServer.d.ts

@@ -0,0 +1,391 @@
+/// <reference types="node" />
+import { Worker } from 'worker_threads';
+import * as tsProtocol from 'typescript/lib/protocol';
+import type { AxiosInstance } from 'axios';
+import Messager from '../common/Messager';
+import { Module, BaseNode, App, Logic, TypeAnnotation, Param, Argument, ViewElement, CallInterface, Connector, Connection, types } from '../concepts';
+import * as utils from '../utils';
+import { SourceMapItem } from '../translator';
+import { MinRange } from './translator';
+import { EventPayload } from '../common';
+import { Diagnostic, DiagnosticManager } from '../manager/diagnostic';
+import { EventEmitter } from '../common/EventEmitter';
+interface RenameMinRange extends MinRange {
+    newValue?: any;
+    setTypeMethods?: string;
+}
+interface QuoteNode {
+    icon: any;
+    node: BaseNode;
+    expanded: boolean;
+    children?: QuoteNode[];
+}
+export interface UiTsOptions {
+    tsCode: string;
+    baseComponents: Record<string, any>;
+}
+export interface NaslServerOptions {
+    http: AxiosInstance;
+    logger?: utils.Logger;
+}
+declare type QuickInfoNodes = Array<{
+    filePath: string;
+    node: BaseNode;
+    item: SourceMapItem;
+}>;
+declare type QuickInfoMap = Map<BaseNode, TypeAnnotation | {
+    typeAnnotation: TypeAnnotation;
+    option: any;
+}>;
+export declare function getDisplayString2Type(displayString: string): string[];
+declare class NaslServer {
+    /** naslStdlib文件缓存 */
+    naslStdlibFileCacheMap: Map<string, tsProtocol.OpenRequestArgs>;
+    messager: Messager;
+    worker: Worker;
+    /**
+     * 按道理 fileSourceMap: new Map<string, SourceMap>() 比较合理，
+     * 但是要多维护一层 vertex 增删 -> file 增删的关系问题，
+     * 先用挂在点上面，简单的方法实现，后期再考虑解耦
+     */
+    file2NodeMap: Map<string, BaseNode>;
+    /** TS 翻译的源码 */
+    tsFiles: Map<string, string>;
+    /**
+     * 调试时是否储存 ts 文件
+     */
+    openDebugEmbedded: boolean;
+    elementsLogic: {
+        [elementLogicName: string]: Array<Logic>;
+    };
+    diagnosticManager: DiagnosticManager;
+    embeddedTSEmitter: EventEmitter;
+    changeStackList: Array<EventPayload>;
+    filesToCheck: Set<string>;
+    singleFileChangeIng: Boolean;
+    logicSetWithComponentLogic: Set<string>;
+    performance: boolean;
+    http: AxiosInstance;
+    logger: utils.Logger;
+    constructor(opt: NaslServerOptions);
+    start(): Promise<void>;
+    terminate(): void;
+    createUiTs(components: any, options: UiTsOptions): Promise<void>;
+    private contentToFile;
+    openApp(app: App, performance?: boolean): Promise<void>;
+    refreshApp(app: App): Promise<void>;
+    /**
+     * 初始化之前添加文件
+     */
+    addFile(file: tsProtocol.OpenRequestArgs, { cache }?: {
+        cache?: boolean;
+    }): Promise<void>;
+    cacheFile(options: tsProtocol.OpenRequestArgs): void;
+    /**
+     * 只新增文件
+     * @param {*} files
+     */
+    writeFiles(files: Array<tsProtocol.OpenRequestArgs>): Promise<void>;
+    /**
+     * 新增、修改
+     * 删除文件 文件用修改内容为空模拟，防止报错
+     * @param {*} args
+     */
+    updateFiles(args: {
+        outputFiles: Array<tsProtocol.OpenRequestArgs>;
+    }): Promise<void>;
+    /**
+     * 清除一个目录下的所有文件
+     */
+    deleteDirectoryFiles(args: {
+        directoryName: string;
+    }): Promise<void>;
+    _debugInFileStorage(node: BaseNode, openFiles: Array<tsProtocol.OpenRequestArgs>): Promise<void>;
+    open(): Promise<void>;
+    updateOpen(args: tsProtocol.UpdateOpenRequestArgs): Promise<void>;
+    fileReferences(filePath: string): Promise<void>;
+    references(args: tsProtocol.FileLocationRequestArgs): Promise<tsProtocol.ReferencesResponseBody>;
+    getValueSelectCompletion(node: BaseNode, value: string, noFilterList?: Array<string>): Promise<void>;
+    _getValueSelectCompletion(args: any): Promise<void>;
+    /**
+     * 获取 Convert 的可选类型
+     * @param node 传入当前已经选择的变量
+     * @returns 可以选择的类型数组
+     */
+    getConvertTypeInfo(node: BaseNode): Promise<{
+        title: string;
+        children: TypeAnnotation[];
+    }[]>;
+    /**
+     * 获取表格的dataschema类型
+     * @param node 当前表格节点
+     * @param allType 是不是需要全部类型 默认不要
+     * @returns 全部类型的str 或者 最后一个.后的内容
+     */
+    getDataSchemaType(node: BaseNode, allType?: boolean): Promise<string>;
+    getDataSchemaStructureOrTypeAnnotation(node: ViewElement): Promise<any>;
+    /**
+     * ts的 quickInfo方法，查询指定位置的详情
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
+    _getTypeQuickinfo(args: any): {
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    };
+    _getQuickInfoFull(args: Array<any>): {
+        responseRequired: boolean;
+        response: Array<tsProtocol.QuickInfoResponseBody>;
+    };
+    /**
+     * 获取nasl节点的 指定位置的详情
+     * 而且可以返回正确类型
+     * @param args 文件信息数组
+     * @returns 查询到的
+     */
+    getNaslNodeQuickInfoFull(args: Array<any>): Promise<{
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody[];
+    }>;
+    _getTypeFull(args: Array<any>): {
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    };
+    _getTypeBatch(args: Array<any>): {
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    };
+    getNaslNodeTypeFull(args: Array<any>): Promise<{
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    }>;
+    getNaslNodeTypeBatch(args: Array<any>): Promise<{
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    }>;
+    /**
+     * 获取已经选中的内容的 下一级的内容
+     * @param node 已经选中的内容
+     * @param noFilterList 不过滤的key 的数据
+     * @returns 可以选择的数据数组
+     */
+    getSelectNextCompletion(node: BaseNode, noFilterList?: Array<string>): Promise<void>;
+    _getSelectNextCompletion(args: any): Promise<void>;
+    getDiagnosticRecordsAndPushAll(fileNames?: Array<string>): Promise<void>;
+    /**
+     * 节点异常是只能挂载单个，如果已经了就不赋值了
+     */
+    baseNodeAssignmentTsError(node: BaseNode, tsErrorDetail: Diagnostic): void;
+    private _resolveDiagnosticRecordsWithGenerator;
+    /**
+     * 处理诊断结果
+     * @param records 结果
+     * @returns 过滤或者转换后的诊断结果
+     */
+    private _resolveDiagnosticRecords;
+    /**
+     * 判断是否是Javalogic
+     */
+    _isJavalogic(node: Logic): boolean;
+    /**
+     * 额外的建议诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    private _attachSuggestionDiagnosticsWithGenerator;
+    hasComponentLogics(expression: BaseNode): boolean;
+    /** 是否被 触发器依赖, 如果存在，返回第一个触发器对应的名称 */
+    isRefedByTriggerAndReturnFirstRef(fileNode: BaseNode): Promise<{
+        isRefedByTrigger: boolean;
+        fRefNames: string[];
+    }>;
+    /**
+     * 是否符合 触发器规则
+     * 规则：
+     */
+    isTriggerRule(fileNode: Logic, fRefNames: string[]): {
+        isTriggerRule: boolean;
+        errorFRefNames: string[];
+    };
+    /**
+     * 额外的诊断
+     * @param fileNode 文件级别的节点
+     * @returns 诊断结果
+     */
+    private _attachDiagnosticsWithGenerator;
+    _treeMetadataType2CoreType(type: TypeAnnotation, app: App): Generator<any, void, any>;
+    _isDuplicateCoreType(type: TypeAnnotation): Generator<any, boolean, any>;
+    checkNodeError(node: BaseNode, diagnostics: Diagnostic[]): any;
+    /**
+     * 判断当前CallInterface 对应的 Interface 是否含有鉴权方式
+     */
+    hasAuth(node: CallInterface): boolean;
+    private existStructureFix;
+    /**
+     * 单个问题的诊断处理
+     * @param diagnostic 诊断问题
+     * @param fileNode 页面节点
+     * @returns 处理后的结果
+     */
+    private _resolveDiagnosticWithGenerator;
+    /**
+     * 查找节点
+     *
+     * @description 生成器原型函数
+     */
+    private _findMinRangeWithGenerator;
+    /**
+     * 查找节点
+     *
+     * @description 同步模式
+     */
+    _findMinRange(...args: Parameters<NaslServer['_findMinRangeWithGenerator']>): MinRange;
+    /**
+     * 查看当前节点是不是有引用
+     * @param node 节点
+     * @returns 查找到的数组
+     */
+    _isHaveRef(node: BaseNode): Promise<tsProtocol.ReferencesResponseItem[]>;
+    /**
+     * 查找引用，并且做一些 修改前的准备工作，
+     * 有引用有的话，就返回集合
+     * @param node 当前重命名的节点
+     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
+     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
+     * @returns 找到的引用
+     */
+    _renamePrepare(node: BaseNode, refsList: any[], newValue: string): RenameMinRange[];
+    _addParamsEffect(refsList: any[], node: Param): void;
+    _addParamsPrepare(node: BaseNode, refsList: any[], needAdd?: boolean): BaseNode;
+    findReferences(node: BaseNode): Promise<Map<any, any>>;
+    nodeFindRefNodes(node: BaseNode): Promise<BaseNode[]>;
+    _getTreeMap(minRange: MinRange, fileNode: BaseNode, resMap: Map<BaseNode, Array<Array<QuoteNode>>>, nodeMap: Map<BaseNode, QuoteNode>): void;
+    handleTreeMap(resMap: Map<BaseNode, Array<Array<QuoteNode>>>): Map<any, any>;
+    /**
+     * 处理tree的队列，把相同节点进行合并
+     * 这里把当前二维数组进行一个整合
+     * @param arr 当前页面下的queue的二维数组，一个数组下有多条链路
+     * @returns 最后要使用到的节点和对应的子集
+     */
+    handleTreeQueue(queueLists: Array<Array<QuoteNode>>): QuoteNode;
+    /**
+     * 递归调用输出结果
+     * @param root 一个根节点
+     * @param map 当前所有节点的map对象
+     * @returns 当前节点，最后输出所有节点
+     */
+    _recursionCreateResult(root: QuoteNode, map: Map<QuoteNode, Array<QuoteNode>>): QuoteNode;
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    getCurrentSource(node: BaseNode): {
+        currentSource: import("../translator").Range;
+        fileNode: utils.FileNode & types.SyntaxNode;
+    } | {
+        fileNode: utils.FileNode & types.SyntaxNode;
+        currentSource?: undefined;
+    };
+    handlingCurrentSourceException(currentSource: SourceMapItem, node: BaseNode): void;
+    getFieldKeySelectCompletion(node: BaseNode, fieldKey?: string): Promise<void>;
+    _getFieldKeySelectCompletion(args: any): Promise<void>;
+    /**
+     * 获取模块下多个CallInterface 被依赖的页面节点
+     * 查找callInterface 被依赖的页面级别的节点，要让他们重新生成一次代码，因为多个Interface重新导入，需要查找到引用的额内容
+     * 对应引用地方，需要重新生成，因为是生成方控制是不是必填的，
+     * @param oldInterfaceModule 发生修改的module，查他下面的Interface被引用的地方
+     * @returns 查找到的有引用这个内容的页面级别节点
+     */
+    findModulesCallInterfaceFileRef(oldInterfaceModule: Module): Promise<BaseNode[]>;
+    /**
+     * 查找calllogic 被依赖的页面级别的节点，要让他们重新生成一次代码，因为logic，参数必填非必填发生修改，
+     * 对应引用地方，需要重新生成，因为是生成方控制是不是必填的，
+     * @param logic 发生修改的logic
+     * @returns 查找到的有引用这个内容的页面级别节点
+     */
+    findCallLogicFileRef(logic: Logic): Promise<BaseNode[]>;
+    /** 获取当前节点的已知类型
+     * @param node 当前要获取类型的节点
+     * @returns 不需要去查就可以返回类型的节点
+     */
+    getCurrentNodeKnownTypeAnnotation(node: BaseNode): TypeAnnotation;
+    /**
+     * 获取传入节点的 TypeAnnotation
+     *
+     * @description 生成器模式原型
+     */
+    private _getQuickInfoNodesTypeMapWithGenerator;
+    /**
+     * 获取传入节点的 TypeAnnotation
+     */
+    getQuickInfoNodesTypeMap(nodes: QuickInfoNodes, flag?: boolean): Promise<QuickInfoMap>;
+    getNaslAnnotatedJSON(app: App, releaseFlag: boolean): Promise<any>;
+    private _incrementalAnnotationJSONWithGenerator;
+    annotationToJson(typesMap: Map<BaseNode, TypeAnnotation | {
+        typeAnnotation: TypeAnnotation;
+        option: any;
+    }>, json: {}): void;
+    /**
+     * 获取getArgument的参数位的类型
+     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
+     * 获取logic的默认值和原来Arg的类型和默认值对应
+     */
+    getArgumentTypeAnnotationWithGenerator(node: Argument, QuickInfoNodes: QuickInfoNodes, types: Map<BaseNode, TypeAnnotation>): Generator<void, TypeAnnotation, void>;
+    getCurrentTypeAnnotation(node: BaseNode, outTime?: number): Promise<unknown>;
+    getBaseNodesTypeMap(nodes: Array<BaseNode>): Promise<QuickInfoMap>;
+    _getTypeStrFull(args: Array<any>): {
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    };
+    getNaslNodeTypeStrFull(args: Array<any>): Promise<{
+        responseRequired: boolean;
+        response: tsProtocol.QuickInfoResponseBody;
+    }>;
+    /**
+     * 满足一些条件，不去查找依赖去check
+     * @param fileNode 当前删除节点的文件级别节点
+     * @param targetNode 当前操作的节点
+     */
+    noFileRefCheck(fileNode: BaseNode, targetNode: BaseNode, action: string): boolean;
+    /**
+     * 处理删除节点
+     * @param fileNode 当前删除节点的文件级别节点
+     * @param targetNode 当前操作的节点
+     * @param result toTs生成的内容
+     */
+    handleDelete(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult): Promise<void>;
+    /**
+     * 除去rename场景下的更新
+     * @param fileNode 文件级别的节点
+     * @param targetNode 触发修改的节点
+     * @param result 生成代码的code 和位置信息
+     */
+    handleChange(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult, action: string): Promise<void>;
+    /**
+     * 重命名的更新
+     * @param fileNode 文件级别的节点
+     * @param targetNode 触发修改的节点
+     * @param result 生成代码的code 和位置信息
+     * @param isRename 是不是修改名字
+     * @param oldFilePath 如果是改名，文件级别的才会有这个参数，用于文件新增替换
+     */
+    handleRename(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult, oldFilePath?: string): Promise<void>;
+    /**
+     * 处理一些节点操作，子节点需要更新并且check的场景
+     * 因为删除，新增父页面，或者重命名会一起
+     * 删除或者新增view而且他有子集 就要执行同样的操作
+     * @param action 当前操作类型
+     * @param fileNode 文件节点
+     * @param targetNode 操作节点  这里要两个相等才会走家去面对哦逻辑
+     * @param oldpath 触发内容的oldpath
+     */
+    incidentalAction(action: string, fileNode: BaseNode, targetNode: BaseNode, oldpath?: string): Promise<void>;
+    receiveHandleChange($event: EventPayload): Promise<boolean>;
+    changeFileNext(): void;
+    /**
+     * 获取 Connector 对应 Connector 的properties
+     */
+    static getPropertyNames(fileNode: Connection | Connector): string[];
+    private getNodeCode;
+}
+export { NaslServer };

package/dist/src/server/naslStdlibMap.d.ts

@@ -0,0 +1,2 @@
+declare let naslStdlibMap: any;
+export default naslStdlibMap;

package/dist/src/server/process2LogicNamespace.d.ts

@@ -0,0 +1,26 @@
+import { Namespace, Logic, Process } from '..';
+/**
+ * 给调用逻辑用
+ * @param process
+ * @returns
+ */
+export declare function process2LogicNamespace(process: Process): Namespace;
+interface processTreeFragment {
+    level: 'processTreeFragment';
+    name: string;
+    id: string;
+    logics: Array<Logic>;
+    elements: Array<{
+        level: 'processTreeElementFragment';
+        name: string;
+        id: string;
+        logics: Array<Logic>;
+    }>;
+}
+/**
+ * 给侧边栏树形用
+ * @param process
+ * @returns
+ */
+export declare function processToTreeFragment(process: Process): processTreeFragment;
+export {};

package/dist/src/server/translator.d.ts

@@ -0,0 +1,26 @@
+import { BaseNode } from '../concepts';
+import { SourceMapItem } from '../translator';
+import { Diagnostic } from '../manager/diagnostic';
+export interface MinRange {
+    node: BaseNode;
+    item: SourceMapItem;
+}
+export declare function outOriginalvalue(value: string): string;
+export declare function translateDiagnosticMessage(message: string): string;
+/**
+ * 节点和ts 报错结合，转成更精准的ts报错
+ * @param minRange
+ * @param tsErrorDetail 报错具体信息
+ * @returns
+ */
+export declare function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diagnostic): {
+    id?: string;
+    severity: string;
+    originalDiagnostic?: import("typescript/lib/protocol").DiagnosticWithFileName;
+    message?: string;
+    code?: number;
+    node: BaseNode;
+    text?: string;
+    titleTip?: string;
+};
+export declare function checkAStructure_(errorText: string): boolean;

package/dist/src/service/creator/add.configs.d.ts

@@ -0,0 +1 @@
+export default function _default(service: any): void;

package/dist/src/service/creator/errHandles.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    defaults({ config }: {
+        config: any;
+    }, err?: {}): void;
+    401({ config }: {
+        config: any;
+    }, err?: {}): void;
+    500({ config }: {
+        config: any;
+    }, err?: {}): void;
+    400({ config }: {
+        config: any;
+    }, err?: {}): void;
+    localError({ config }: {
+        config: any;
+    }, err?: {}): void;
+};
+export default _default;

package/dist/src/service/creator/index.d.ts

@@ -0,0 +1 @@
+export function createService(apiSchemaList: any, serviceConfig: any, dynamicServices: any): any;

package/dist/src/service/datasource/api.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    namespace pingDatabase {
+        namespace config {
+            const noErrorTip: boolean;
+        }
+        namespace url {
+            const method: string;
+            const path: string;
+        }
+    }
+}
+export default _default;

package/dist/src/service/datasource/index.d.ts

@@ -0,0 +1,2 @@
+export default service;
+declare const service: any;

package/dist/src/service/logic/api.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    namespace queryDebugTypescript {
+        namespace url {
+            const path: string;
+            const method: string;
+        }
+    }
+}
+export default _default;

package/dist/src/service/logic/checktypeSocket.d.ts

@@ -0,0 +1,5 @@
+export function createLogicSocketClient(appId: any): Promise<any>;
+export namespace checkTypeClient {
+    const client: any;
+    const connect: boolean;
+}

package/dist/src/service/logic/index.d.ts

@@ -0,0 +1,2 @@
+export default service;
+declare const service: any;

package/dist/src/service/storage/api.d.ts

@@ -0,0 +1,54 @@
+declare namespace _default {
+    namespace batchQuery {
+        namespace url {
+            const method: string;
+            const path: string;
+        }
+    }
+    namespace batchAction {
+        export namespace url_1 {
+            const method_1: string;
+            export { method_1 as method };
+            const path_1: string;
+            export { path_1 as path };
+        }
+        export { url_1 as url };
+    }
+    namespace batchInstruct {
+        export namespace url_2 {
+            const method_2: string;
+            export { method_2 as method };
+            const path_2: string;
+            export { path_2 as path };
+        }
+        export { url_2 as url };
+    }
+    namespace saveFrontendNasl {
+        export namespace url_3 {
+            const method_3: string;
+            export { method_3 as method };
+            const path_3: string;
+            export { path_3 as path };
+        }
+        export { url_3 as url };
+    }
+    namespace breakpoint {
+        export namespace url_4 {
+            const method_4: string;
+            export { method_4 as method };
+            const path_4: string;
+            export { path_4 as path };
+        }
+        export { url_4 as url };
+    }
+    namespace databaseTypes {
+        export namespace url_5 {
+            const method_5: string;
+            export { method_5 as method };
+            const path_5: string;
+            export { path_5 as path };
+        }
+        export { url_5 as url };
+    }
+}
+export default _default;

package/dist/src/service/storage/index.d.ts

@@ -0,0 +1,2 @@
+import axios from 'axios';
+export default axios;

package/dist/src/service/storage/init.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+import { App } from '../../concepts';
+import type { NaslServer } from 'src/server/naslServer';
+export declare const batchQuery: ({ body, headers, config }: {
+    body: any[];
+    headers: Record<string, string>;
+    config?: object;
+}) => any;
+export declare const batchAction: ({ body, headers }: {
+    body: any[];
+    headers: Record<string, string>;
+}) => any;
+export declare const batchInstruct: ({ body, headers }: {
+    body: any[];
+    headers: Record<string, string>;
+}) => any;
+export declare const breakpoint: ({ body }: {
+    body: any;
+}) => any;
+export declare const databaseTypes: ({ query }: {
+    query: any;
+}) => any;
+export declare const operationRecordInfoMap: Map<string, any>;
+export declare function doOperationRecord(operation: Operation): void;
+export declare function operationRecordQuery(app: any): Promise<unknown>;
+export declare function operationRecordPlayback(app: any, operationRecordAction: 'undo' | 'redo'): Promise<any>;
+declare type Instruct = {
+    uuid: string;
+    actions: any[];
+    oldUUid?: string;
+    riskList?: string[];
+};
+declare type TaskOption = {
+    app: any;
+    hasFrontEnd: boolean;
+    hasBackEnd: boolean;
+    instructList: Instruct[];
+    operationList: Operation[];
+};
+declare enum TaskQueueStatus {
+    ExceedMaxTaskCount = 0,
+    Retrying = 1
+}
+declare type RefreshNaslOptions = {
+    errorInfo: {
+        message?: string;
+        stack?: string;
+    };
+};
+declare class TaskQueue {
+    queue: TaskOption[];
+    lastQueue: TaskOption[];
+    running: Boolean;
+    maxTaskCount: number;
+    status?: TaskQueueStatus;
+    addTask(task: TaskOption): void;
+    clear(): void;
+    run(queue?: TaskOption[]): Promise<void>;
+    retry(): void;
+    refreshNasl(app: App, options?: RefreshNaslOptions): Promise<void>;
+    recover(app: App): void;
+}
+export declare const taskQueue: TaskQueue;
+declare class Operation {
+    appId?: string;
+    branchId?: string;
+    accountId?: string;
+    userId?: string;
+    phone?: string;
+    actionItem: any;
+    res?: any;
+    err?: any;
+    parentKey?: string;
+    timestamp?: any;
+    type?: string;
+    uuid?: string;
+    action?: string;
+}
+export interface ProxyApp extends App {
+    _isCollectingCount: number;
+    _collectingList: number[];
+    _historyList: number[];
+    _historyIndex: number;
+    _historying: boolean;
+    _timer: NodeJS.Timeout;
+    _noTimer: NodeJS.Timeout;
+    _actionMsg: string;
+    _action: string;
+    _extra?: any;
+    naslServer: NaslServer;
+}
+export declare function handleApp(app: ProxyApp): void;
+/**
+ * 加载 app
+ * @param appId 如果是从文件读，就不需要传
+ * @returns app 对象
+ */
+export declare function loadApp(appId?: string): Promise<App>;
+export declare function mountDatabaseTypes(app: App): Promise<void>;
+/**
+ * 加载 app
+ * @returns app 对象
+ */
+export declare function loadAppSync(): App;
+export {};