@kusto/monaco-kusto/release/esm/kustoWorker.d.ts

CSL, KQL plugin for the Monaco Editor

import * as ls from 'vscode-languageserver-types';
import type { worker } from 'monaco-editor/esm/vs/editor/editor.worker';
import type { IRange } from 'monaco-editor/esm/vs/editor/editor.api';
import * as kustoService from './languageServiceManager/kustoLanguageService';
import type { LanguageSettings } from './languageServiceManager/settings';
import { Schema, showSchema, ScalarParameter, Database, TabularParameter } from './languageServiceManager/schema';
import type { RenderInfo } from './languageServiceManager/renderInfo';
import type { ClusterReference, DatabaseReference } from './types';
import { ClassificationRange } from './syntaxHighlighting/types';
export type InterfaceFor<C> = {
    [Member in keyof C]: C[Member];
};
/**
 * We're using this interface to send messages to a worker, so using
 * `InterfaceFor` to make it not nominal is more accurate. {@link KustoWorker}
 * is the public, more limited version of this interface.
 */
export type IKustoWorkerImpl = InterfaceFor<KustoWorkerImpl>;
export declare class KustoWorkerImpl {
    private _ctx;
    private _languageService;
    private _languageId;
    private _languageSettings;
    constructor(ctx: worker.IWorkerContext, createData: ICreateData);
    setSchema(schema: Schema): Promise<void>;
    addClusterToSchema(uri: string, clusterName: string, databases: readonly {
        name: string;
        alternativeName?: string;
    }[]): Promise<void>;
    addDatabaseToSchema(uri: string, clusterName: string, databaseSchema: Database): Promise<void>;
    setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string): Promise<void>;
    normalizeSchema(schema: showSchema.Result, clusterConnectionString: string, databaseInContextName: string): Promise<import("./languageServiceManager/schema").EngineSchema>;
    getSchema(): Promise<Schema>;
    getCommandInContext(uri: string, cursorOffset: number): Promise<string | null>;
    getQueryParams(uri: string, cursorOffset: number): Promise<{
        name: string;
        type: string;
    }[]>;
    getGlobalParams(uri: string): Promise<{
        name: string;
        type: string;
    }[]>;
    getReferencedSymbols(uri: string, cursorOffset?: number): Promise<{
        name: string;
        kind: string;
        display: string;
    }[]>;
    getReferencedGlobalParams(uri: string, cursorOffset?: number): Promise<{
        name: string;
        type: string;
    }[]>;
    getRenderInfo(uri: string, cursorOffset: number): Promise<RenderInfo | null>;
    /**
     * Get command in context and the command range.
     * This method will basically convert generate microsoft language service interface to monaco interface.
     * @param uri document URI
     * @param cursorOffset offset from start of document to cursor
     */
    getCommandAndLocationInContext(uri: string, cursorOffset: number): Promise<{
        text: string;
        range: IRange;
    } | null>;
    getCommandsInDocument(uri: string): Promise<{
        absoluteStart: number;
        absoluteEnd: number;
        text: string;
    }[]>;
    doComplete(uri: string, position: ls.Position): Promise<ls.CompletionList>;
    doValidation(uri: string, intervals: {
        start: number;
        end: number;
    }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
    getResultActions(uri: string, start: number, end: number): Promise<kustoService.ResultAction[]>;
    doRangeFormat(uri: string, range: ls.Range): Promise<ls.TextEdit[]>;
    doFolding(uri: string): Promise<ls.FoldingRange[]>;
    doDocumentFormat(uri: string): Promise<ls.TextEdit[]>;
    doCurrentCommandFormat(uri: string, caretPosition: ls.Position): Promise<ls.TextEdit[]>;
    getClassifications(uri: string): Promise<ClassificationRange[]>;
    getClientDirective(text: string): Promise<{
        isClientDirective: boolean;
        directiveWithoutLeadingComments: string;
    }>;
    getAdminCommand(text: string): Promise<{
        isAdminCommand: boolean;
        adminCommandWithoutLeadingComments: string;
    }>;
    findDefinition(uri: string, position: ls.Position): Promise<ls.Location[]>;
    findReferences(uri: string, position: ls.Position): Promise<ls.Location[]>;
    doRename(uri: string, position: ls.Position, newName: string): Promise<ls.WorkspaceEdit>;
    doHover(uri: string, position: ls.Position): Promise<ls.Hover>;
    setParameters(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): Promise<void>;
    getClusterReferences(uri: string, cursorOffset: number): Promise<ClusterReference[]>;
    getDatabaseReferences(uri: string, cursorOffset: number): Promise<DatabaseReference[]>;
    private _getTextDocument;
}
export interface ICreateData {
    languageId: string;
    languageSettings: LanguageSettings;
}
/**
 * Used when monaco-editor is resolved via amd modules
 */
export declare function create(ctx: worker.IWorkerContext, createData: ICreateData): IKustoWorkerImpl;