/// <reference types="node" />
import { tsProtocol, NASLObject } from '@lcap/nasl-types';
import type { AxiosInstance } from 'axios';
import Messager from '../common/Messager';
import { Worker } from 'worker_threads';
import { Module, BaseNode, App, Logic, TypeAnnotation, Param, Interface, Argument, ViewElement, BindAttribute, CallInterface, Connector, Connection, SyntaxNode, EventEmitter, AuthLogicForCallInterface } from '../concepts';
import * as utils from '../utils';
import { Embedded, Translator, Logger, NaslServer as ServerInterface } from '@lcap/nasl-types';
import { MinRange } from './translator';
import { DiagnosticRecord, Diagnostic, DiagnosticManager } from '../manager/diagnostic';
type SourceMapItem = Translator.SourceMapItem;
type FileNode = Embedded.FileNode<BaseNode>;
type NaslServerOptions = ServerInterface.Options;
type SharedAppVersion = {
    name: string;
    provider: string;
    version: string;
    ideVersion: string;
};
import { SemanticData } from '@lcap/nasl-concepts';
import { ConcreteOQLDiagnostic, SymbolGraph, DefConcept, SemEnv } from '@lcap/nasl-language-server-core';
type IsHaveRefResultType = {
    node: SyntaxNode;
    fileNode: SyntaxNode;
    file: string;
};
interface RenameResult {
    node: SyntaxNode;
    fileNode: SyntaxNode;
    file: string;
    newValue?: any;
    setTypeMethods?: string;
    doNotChange?: boolean;
}
type QuickInfoNode = {
    filePath: string;
    node: BaseNode;
    item: SourceMapItem;
};
type QuickInfoNodes = Array<QuickInfoNode>;
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;
    promise: Promise<void>;
    /**
     * 按道理 fileSourceMap: new Map<string, SourceMap>() 比较合理，
     * 但是要多维护一层 vertex 增删 -> file 增删的关系问题，
     * 先用挂在点上面，简单的方法实现，后期再考虑解耦
     */
    file2NodeMap: Map<string, SyntaxNode>;
    /** TS 翻译的源码 */
    tsFiles: Map<string, string>;
    /**
     * 调试时是否储存 ts 文件
     */
    openDebugEmbedded: boolean;
    elementsLogic: {
        [elementLogicName: string]: Array<Logic>;
    };
    diagnosticManager: DiagnosticManager;
    embeddedTSEmitter: EventEmitter;
    changeStackList: Array<NASLObject.EventPayload>;
    typerCheckFiles: Set<SyntaxNode>;
    typerRemoveNodes: Set<SyntaxNode>;
    typerCreateNodes: Set<SyntaxNode>;
    oqlRemoveNodesTsPath: Set<string>;
    removedConnectors: Set<Connector>;
    originProxyTargetNodes: Set<SyntaxNode>;
    createUiTsArg0Copy: any;
    createUiTsArg1Copy: any;
    typerErrRecords: DiagnosticRecord[];
    cachedEventPayloadValues: Array<any>;
    currentRenameMode: 'rename-only' | 'update' | null;
    oqlDisaster: boolean;
    getProxyApp: () => App;
    singleFileChangeIng: Boolean;
    /**
     * @deprecated FIXME wudengke 删除这个属性
     */
    performance: boolean;
    http: AxiosInstance;
    logger: Logger;
    isFirstScreen: boolean;
    semData: SemanticData;
    symbolGraph: SymbolGraph;
    semEnv: SemEnv;
    private sqlSignatureFiles;
    /**
     * 语言服务运行完毕
     *
     * @description 初始化以及每次修改内容时都会重置
     */
    lsRunEnd: Promise<void>;
    /**
     * 语言服务运行完毕标记
     *
     * @description `lsRunEnd`属性的内部状态
     */
    private _lsRunEndSwitch;
    /**
     * 标注模式
     *
     * @description generator-fe 镜像中类型标注时使用，此模式下将会禁用所有因节点变化造成的 ts 文件修改
     */
    isAnnotationMode: boolean;
    readonly flags: NaslServerOptions['flags'];
    constructor(opt: NaslServerOptions);
    start(): Promise<void>;
    terminate(): void;
    handlePublishDiagnostics: (_: {
        data: {
            event: string;
            records: DiagnosticRecord[];
            versions: number[];
        };
    }) => Promise<void>;
    private loadFlags;
    launch(opt: NaslServerOptions): Promise<void>;
    uiTsInited: Promise<() => void> | undefined;
    private uiTsInitedResolve;
    createUiTs(components: any, options: {
        basicUITsCode: string;
        withTypeLibraryTsCode: string;
        standardUIComponents: Record<string, any>;
    }): Promise<void>;
    private contentToFile;
    _sqlFunctions?: any[];
    requestDatabaseConfigs(http: any, app: App): Promise<void>;
    requestSqlFunctions(http: any, appName: string): Promise<{
        file: string;
        fileContent: any;
    }[]>;
    getSqlFunctions(dbType: string): any;
    getSqlFunction(dbType: string, functionName?: string): any;
    _latestVersionsOfSharedApp: SharedAppVersion[];
    requestLatestVersionsOfSharedApp(app: App): Promise<void>;
    getStatusOfSharedApp(sharedApp: Module): "delete" | "update";
    sharedAppsUpdated(app: App): boolean;
    checkStatusOfSharedApps(app: App): Promise<void>;
    getLatestVersionsOfSharedApp(): SharedAppVersion[];
    getUpdatedSharedApp(app: App): Module;
    fetchDtsFile(url: string): Promise<string>;
    private firstScreenEndWork;
    openApp(app: App, performance?: boolean, needRegisterCommand?: boolean): Promise<void>;
    refreshApp(app: App, performance?: boolean): 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>;
    _debugPutFilesInAnonymousApp(files: Array<tsProtocol.OpenRequestArgs>): Promise<void>;
    _debugPutFilesByAppId(appId: string, openFiles: Array<tsProtocol.OpenRequestArgs>): 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> | Promise<any[]>;
    references(args: tsProtocol.FileLocationRequestArgs): Promise<tsProtocol.ReferencesResponseBody>;
    getValueSelectCompletion(node: BaseNode, value: string, noFilterList?: Array<string>): Promise<void> | Promise<any[]>;
    _getValueSelectCompletion(args: any): Promise<void> | Promise<any[]>;
    getDataSchemaStructureOrTypeAnnotation(node: ViewElement): Promise<any>;
    /**
     * ts的 quickInfo方法，查询指定位置的详情
     * @param args 文件信息数组
     * @returns 查询到的
     */
    _getTypeQuickinfo(args: any): Promise<{
        responseRequired: boolean;
        response: any;
    }> | {
        responseRequired: boolean;
        response: tsProtocol.QuickInfoResponseBody;
    };
    _getQuickInfoFull(args: Array<any>): Promise<{
        responseRequired: boolean;
        response: any[];
    }> | {
        responseRequired: boolean;
        response: Array<tsProtocol.QuickInfoResponseBody>;
    };
    /**
     * 获取nasl节点的 指定位置的详情
     * 而且可以返回正确类型
     * @param args 文件信息数组
     * @returns 查询到的
     */
    getNaslNodeQuickInfoFull(args: Array<any>): Promise<{
        responseRequired: boolean;
        response: any[];
    } | {
        responseRequired: boolean;
        response: tsProtocol.QuickInfoResponseBody[];
    }>;
    _getTypeFull(args: Array<any>): Promise<{
        responseRequired: boolean;
        response: any;
    }> | {
        responseRequired: boolean;
        response: tsProtocol.QuickInfoResponseBody;
    };
    _getTypeBatch(args: Array<any>): Promise<{
        responseRequired: boolean;
        response: any;
    }> | {
        responseRequired: boolean;
        response: tsProtocol.QuickInfoResponseBody;
    };
    getNaslNodeTypeFull(args: Array<any>): Promise<{
        responseRequired: boolean;
        response: any;
    } | {
        responseRequired: boolean;
        response: tsProtocol.QuickInfoResponseBody;
    }>;
    getNaslNodeTypeBatch(args: Array<any>): Promise<{
        responseRequired: boolean;
        response: any;
    } | {
        responseRequired: boolean;
        response: tsProtocol.QuickInfoResponseBody;
    }>;
    /**
     * 获取已经选中的内容的 下一级的内容
     * @param node 已经选中的内容
     * @param noFilterList 不过滤的key 的数据
     * @returns 可以选择的数据数组
     */
    getSelectNextCompletion(node: BaseNode, noFilterList?: Array<string>): Promise<void> | Promise<any[]>;
    _getSelectNextCompletion(args: any): Promise<void> | Promise<any[]>;
    getDiagnosticRecordsAndPushAllAndWaitPublishDiagnosticsEnd(fileNames?: Array<string>): Promise<ConcreteOQLDiagnostic[]>;
    notifyPublishDiagnosticsEnd(tsDiagnostics: ConcreteOQLDiagnostic[]): void;
    getDiagnosticRecordsAndPushAll(fileNames?: Array<string>): Promise<void>;
    /**
     * 将原始诊断信息与NASL节点进行关联并翻译成为中文。注意：只处理 OqlQueryComponent 节点
     * @param diagnostic 诊断问题
     * @param fileNode 诊断所在的文件节点
     * @returns 处理后的诊断信息
     */
    private _resolveSingleDiagnostic;
    private _resolveDiagnosticRecordsWithGenerator;
    /**
     * 处理诊断结果，标注到 OQL 节点上
     * @param records 结果
     * @returns 过滤或者转换后的诊断结果
     */
    private _resolveDiagnosticRecords;
    /**
     * 判断是否是Javalogic
     */
    _isJavalogic(node: Logic): boolean;
    isEntityUpdate(node: BaseNode): boolean;
    timeoutCheck(fileNodeRaw: Connection | Interface, fileNode: SyntaxNode, diagnostics: Diagnostic[]): void;
    _treeMetadataType2CoreType(type: TypeAnnotation, app: App): Generator<any, void, any>;
    _isDuplicateCoreType(type: TypeAnnotation): Generator<any, boolean, any>;
    checkRemoteConfig(node: Connection): boolean;
    /**
     * 判断当前CallInterface 对应的 Interface 是否含有鉴权方式
     */
    hasAuth(node: CallInterface): boolean;
    /**
     * 查找节点
     *
     * @description 同步模式
     */
    _fastFindMinRange(diagnostic: tsProtocol.Diagnostic, fileNode: FileNode): MinRange | undefined;
    _findMinRange(diagnostic: tsProtocol.DiagnosticWithFileName | tsProtocol.ReferencesResponseItem, fileNode: FileNode): MinRange;
    /**
     * 查看当前节点是不是有引用
     * @param node 节点
     * @returns 查找到的数组
     *
     * @description FIXME: 保留旧的逻辑，验证完成之后需要删除
     */
    /**
     * @warning 主要是 rename 等内部调用的查找引用，不是用户点击的 "查找引用"
     */
    _isHaveRef(__node: SyntaxNode): Promise<IsHaveRefResultType[]>;
    /**
     * 查找引用，并且做一些 修改前的准备工作，
     * 有引用有的话，就返回集合
     * @param node 当前重命名的节点
     * @param newValue 传递过来的新值，给MemberExpression用的比较特殊
     * 而且，这个新值不一定会用到，MemberExpression在批量更新的时候，可以取到新的value， 这里需要位置信息防止 a.a.a.a 中的一个a发生修改
     * @returns 找到的引用
     */
    _renamePrepare(__nd: BaseNode, refsList: utils.GetPromise<ReturnType<NaslServer['_isHaveRef']>>, newValue: string): RenameResult[];
    _addParamsEffect(refsList: utils.GetPromise<ReturnType<NaslServer['_isHaveRef']>>, nd: Param): void;
    _addParamsPrepare(nd: BaseNode, refsList: any[], needAdd?: boolean): BaseNode;
    nodeFindRefNodes(nd: SyntaxNode): Promise<BaseNode[]>;
    findReferenceAndRender: (nd: DefConcept) => Promise<Map<any, any>>;
    getFieldKeySelectCompletion(nd: BaseNode, fieldKey?: string): Promise<void> | Promise<any[]>;
    getSlotCurrentCompletion(nd: BaseNode): Promise<void> | Promise<any[]>;
    _getFieldKeySelectCompletion(args: any): Promise<void> | Promise<any[]>;
    /**
     * 获取模块下多个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(node0: BaseNode): TypeAnnotation;
    /**
     * 获取传入节点的 TypeAnnotation
     *
     * @description 生成器模式原型
     */
    private _getQuickInfoNodesTypeMapWithGenerator;
    private _getQuickInfoBindAttributeTypeWithGenerator;
    /**
     * 获取传入节点的 TypeAnnotation
     */
    getQuickInfoNodesTypeMap(nodes: QuickInfoNodes, flag?: boolean): Promise<QuickInfoMap>;
    fastGetNaslAnnotatedJSON(naslNode: App | Logic | AuthLogicForCallInterface): Promise<Partial<BaseNode>>;
    /**
     * 标注指定文件
     *
     * @description 会进行 TS 翻译，并且是全量标注
     * @param fileNodes 标注的页面节点
     */
    annotationFiles(fileNodes: SyntaxNode[]): Promise<QuickInfoMap>;
    /**
     * 根据变动的文件，找出其中的 OqlQueryComponent 节点，触发getQuickInfoNodesTypeMap，然后将结果标注到节点上
     * @param records
     */
    private _incrementalAnnotationJSONWithGenerator;
    annotationToJson(typesMap: Map<BaseNode, TypeAnnotation | {
        typeAnnotation: TypeAnnotation;
        option: any;
    }>, jsonMap: Map<BaseNode, any>): void;
    /**
     * 获取getArgument的参数位的类型
     * 如果内部表达式的，就用表达式的，如果没有就试试用默认值的
     * 获取logic的默认值和原来Arg的类型和默认值对应
     */
    getArgumentTypeAnnotationWithGenerator(node: Argument, types: Map<BaseNode, TypeAnnotation>): Generator<void, TypeAnnotation, void>;
    getCurrentTypeAnnotation(node: BaseNode): Promise<TypeAnnotation>;
    getBindAttributeType(node: BindAttribute): Promise<TypeAnnotation | {
        typeAnnotation: TypeAnnotation;
        option: any;
    }>;
    _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;
    private processAllEvents;
    private processSingleChangeEvent;
    private notifyStartWork;
    private acquireLock;
    private flushChangesForTypeChecking;
    /**
     * 根据入参准备并往 TS Server 写入需要校验的 ts 文件
     * @param chkFiles 需要校验的文件
     * @param removedNodes 需要删除的文件
     * @param oqlRemoveNodesTsPath 需要删除的文件路径
     * @returns 需要校验的文件名
     */
    private prepareAndWriteTsFilesToCheck;
    getContextVariables(node: SyntaxNode): Promise<import("@lcap/nasl-language-server-core/out/query/context-variable-query").ContextVariableInfo[]>;
    /**
     * 获取 Connector 对应 Connector 的properties
     */
    static getPropertyNames(fileNode: Connection | Connector): string[];
    private getNodeCode;
    waitOqlQueryComponentChildrenFinish(node: SyntaxNode): Promise<void>;
    /** 关闭 metadataTypes 校验 */
    disableMetadataTypesCheck(app: App): Promise<void>;
    /** 打开 metadataTypes 校验 */
    enableMetadataTypesCheck(app: App): Promise<void>;
    static toRaw<T>(nd: T): T;
    /**
     * @deprecated: 不要再用了，请调用新方法 getFileNode
     * 从 naslServer.ts 移动过来的
     *  获取
     *  当前this上下文 的Source 和 父级文件级别的节点
     */
    static getCurrentSource(node: BaseNode): {
        currentSource: Translator.Range;
        fileNode: BaseNode & {
            getEmbeddedFilePath(name?: string): string;
            toEmbeddedTSFile(): Embedded.TSFileGenerator<BaseNode>;
        } & SyntaxNode;
    } | {
        fileNode: BaseNode & {
            getEmbeddedFilePath(name?: string): string;
            toEmbeddedTSFile(): Embedded.TSFileGenerator<BaseNode>;
        } & SyntaxNode;
        currentSource?: undefined;
    };
    /**
    * 获取节点引用，不包括自己
    *
    * @param {SyntaxNode} node 查询的节点
    * @param {SyntaxNode} [fileNode] 节点所属的文件节点，外部输入可以省去计算
    */
    getDirectRefFileNodes(node: SyntaxNode): SyntaxNode[];
    /** 新语言服务初始化 */
    private languageServerInitiate;
    getProxyNode: (nd: BaseNode) => SyntaxNode;
    private _getAllElementLogicRoots;
    private _refreshTreeViews;
    private _triggerOqlQueryComponentUpdate;
    getClient(): Promise<{
        eventHandlerService: import("@lcap/nasl-language-server-core/out/services/event-handler-type-service").EventHandlerTypeService;
        bindableLogicService: import("@lcap/nasl-language-server-core/out/services/bindable-logic-service").BindableLogicService;
        contextualVariablesService: import("@lcap/nasl-language-server-core/out/services/contextual-variables-service").ContextualVariablesService;
    }>;
}
export { NaslServer };
//# sourceMappingURL=naslServer.d.ts.map