naider 1.7.0

package/vscode-naide/node_modules/vscode-languageclient/lib/common/progress.d.ts

@@ -0,0 +1,11 @@
+import { ClientCapabilities } from 'vscode-languageserver-protocol';
+import { FeatureClient, FeatureState, StaticFeature } from './features';
+export declare class ProgressFeature implements StaticFeature {
+    private _client;
+    private readonly activeParts;
+    constructor(_client: FeatureClient<object>);
+    getState(): FeatureState;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(): void;
+    clear(): void;
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/progress.js

@@ -0,0 +1,44 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressFeature = void 0;
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const progressPart_1 = require("./progressPart");
+function ensure(target, key) {
+    if (target[key] === void 0) {
+        target[key] = Object.create(null);
+    }
+    return target[key];
+}
+class ProgressFeature {
+    constructor(_client) {
+        this._client = _client;
+        this.activeParts = new Set();
+    }
+    getState() {
+        return { kind: 'window', id: vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.method, registrations: this.activeParts.size > 0 };
+    }
+    fillClientCapabilities(capabilities) {
+        ensure(capabilities, 'window').workDoneProgress = true;
+    }
+    initialize() {
+        const client = this._client;
+        const deleteHandler = (part) => {
+            this.activeParts.delete(part);
+        };
+        const createHandler = (params) => {
+            this.activeParts.add(new progressPart_1.ProgressPart(this._client, params.token, deleteHandler));
+        };
+        client.onRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, createHandler);
+    }
+    clear() {
+        for (const part of this.activeParts) {
+            part.done();
+        }
+        this.activeParts.clear();
+    }
+}
+exports.ProgressFeature = ProgressFeature;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/progressPart.d.ts

@@ -0,0 +1,24 @@
+import { Disposable } from 'vscode';
+import { ProgressToken, ProgressType, NotificationHandler, ProtocolNotificationType } from 'vscode-languageserver-protocol';
+export interface ProgressContext {
+    onProgress<P>(type: ProgressType<P>, token: string | number, handler: NotificationHandler<P>): Disposable;
+    sendNotification<P, RO>(type: ProtocolNotificationType<P, RO>, params?: P): void;
+}
+export declare class ProgressPart {
+    private _client;
+    private _token;
+    private _infinite;
+    private _reported;
+    private _lspProgressDisposable;
+    private _progress;
+    private _cancellationToken;
+    private _tokenDisposable;
+    private _resolve;
+    private _reject;
+    constructor(_client: ProgressContext, _token: ProgressToken, done?: (part: ProgressPart) => void);
+    private begin;
+    private report;
+    cancel(): void;
+    done(): void;
+    private cleanup;
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/progressPart.js

@@ -0,0 +1,96 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressPart = void 0;
+const vscode_1 = require("vscode");
+const vscode_languageserver_protocol_1 = require("vscode-languageserver-protocol");
+const Is = require("./utils/is");
+class ProgressPart {
+    constructor(_client, _token, done) {
+        this._client = _client;
+        this._token = _token;
+        this._reported = 0;
+        this._infinite = false;
+        this._lspProgressDisposable = this._client.onProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, (value) => {
+            switch (value.kind) {
+                case 'begin':
+                    this.begin(value);
+                    break;
+                case 'report':
+                    this.report(value);
+                    break;
+                case 'end':
+                    this.done();
+                    done && done(this);
+                    break;
+            }
+        });
+    }
+    begin(params) {
+        this._infinite = params.percentage === undefined;
+        // the progress as already been marked as done / canceled. Ignore begin call
+        if (this._lspProgressDisposable === undefined) {
+            return;
+        }
+        // Since we don't use commands this will be a silent window progress with a hidden notification.
+        void vscode_1.window.withProgress({ location: vscode_1.ProgressLocation.Window, cancellable: params.cancellable, title: params.title }, async (progress, cancellationToken) => {
+            // the progress as already been marked as done / canceled. Ignore begin call
+            if (this._lspProgressDisposable === undefined) {
+                return;
+            }
+            this._progress = progress;
+            this._cancellationToken = cancellationToken;
+            this._tokenDisposable = this._cancellationToken.onCancellationRequested(() => {
+                this._client.sendNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, { token: this._token });
+            });
+            this.report(params);
+            return new Promise((resolve, reject) => {
+                this._resolve = resolve;
+                this._reject = reject;
+            });
+        });
+    }
+    report(params) {
+        if (this._infinite && Is.string(params.message)) {
+            this._progress !== undefined && this._progress.report({ message: params.message });
+        }
+        else if (Is.number(params.percentage)) {
+            const percentage = Math.max(0, Math.min(params.percentage, 100));
+            const delta = Math.max(0, percentage - this._reported);
+            this._reported += delta;
+            this._progress !== undefined && this._progress.report({ message: params.message, increment: delta });
+        }
+    }
+    cancel() {
+        this.cleanup();
+        if (this._reject !== undefined) {
+            this._reject();
+            this._resolve = undefined;
+            this._reject = undefined;
+        }
+    }
+    done() {
+        this.cleanup();
+        if (this._resolve !== undefined) {
+            this._resolve();
+            this._resolve = undefined;
+            this._reject = undefined;
+        }
+    }
+    cleanup() {
+        if (this._lspProgressDisposable !== undefined) {
+            this._lspProgressDisposable.dispose();
+            this._lspProgressDisposable = undefined;
+        }
+        if (this._tokenDisposable !== undefined) {
+            this._tokenDisposable.dispose();
+            this._tokenDisposable = undefined;
+        }
+        this._progress = undefined;
+        this._cancellationToken = undefined;
+    }
+}
+exports.ProgressPart = ProgressPart;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.d.ts

@@ -0,0 +1,6 @@
+import * as code from 'vscode';
+import { LSPAny } from 'vscode-languageserver-protocol';
+export default class ProtocolCallHierarchyItem extends code.CallHierarchyItem {
+    data?: LSPAny;
+    constructor(kind: code.SymbolKind, name: string, detail: string, uri: code.Uri, range: code.Range, selectionRange: code.Range, data?: LSPAny);
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCallHierarchyItem.js

@@ -0,0 +1,16 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const code = require("vscode");
+class ProtocolCallHierarchyItem extends code.CallHierarchyItem {
+    constructor(kind, name, detail, uri, range, selectionRange, data) {
+        super(kind, name, detail, uri, range, selectionRange);
+        if (data !== undefined) {
+            this.data = data;
+        }
+    }
+}
+exports.default = ProtocolCallHierarchyItem;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCodeAction.d.ts

@@ -0,0 +1,6 @@
+import * as vscode from 'vscode';
+import { LSPAny } from 'vscode-languageserver-protocol';
+export default class ProtocolCodeAction extends vscode.CodeAction {
+    readonly data: LSPAny | undefined;
+    constructor(title: string, data: LSPAny | undefined);
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCodeAction.js

@@ -0,0 +1,14 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode = require("vscode");
+class ProtocolCodeAction extends vscode.CodeAction {
+    constructor(title, data) {
+        super(title);
+        this.data = data;
+    }
+}
+exports.default = ProtocolCodeAction;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCodeLens.d.ts

@@ -0,0 +1,5 @@
+import * as code from 'vscode';
+export default class ProtocolCodeLens extends code.CodeLens {
+    data: any;
+    constructor(range: code.Range);
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCodeLens.js

@@ -0,0 +1,13 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const code = require("vscode");
+class ProtocolCodeLens extends code.CodeLens {
+    constructor(range) {
+        super(range);
+    }
+}
+exports.default = ProtocolCodeLens;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCompletionItem.d.ts

@@ -0,0 +1,11 @@
+import * as code from 'vscode';
+import * as proto from 'vscode-languageserver-protocol';
+export default class ProtocolCompletionItem extends code.CompletionItem {
+    data: any;
+    fromEdit: boolean | undefined;
+    documentationFormat: string | undefined;
+    originalItemKind: proto.CompletionItemKind | undefined;
+    deprecated: boolean | undefined;
+    insertTextMode: proto.InsertTextMode | undefined;
+    constructor(label: string | code.CompletionItemLabel);
+}

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolCompletionItem.js

@@ -0,0 +1,13 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const code = require("vscode");
+class ProtocolCompletionItem extends code.CompletionItem {
+    constructor(label) {
+        super(label);
+    }
+}
+exports.default = ProtocolCompletionItem;

package/vscode-naide/node_modules/vscode-languageclient/lib/common/protocolConverter.d.ts

@@ -0,0 +1,167 @@
+import * as code from 'vscode';
+import * as ls from 'vscode-languageserver-protocol';
+import ProtocolCompletionItem from './protocolCompletionItem';
+export interface Converter {
+    asUri(value: string): code.Uri;
+    asDocumentSelector(value: ls.DocumentSelector): code.DocumentSelector;
+    asPosition(value: undefined | null): undefined;
+    asPosition(value: ls.Position): code.Position;
+    asPosition(value: ls.Position | undefined | null): code.Position | undefined;
+    asRange(value: undefined | null): undefined;
+    asRange(value: ls.Range): code.Range;
+    asRange(value: ls.Range | undefined | null): code.Range | undefined;
+    asRanges(items: ReadonlyArray<ls.Range>, token?: code.CancellationToken): Promise<code.Range[]>;
+    asDiagnostic(diagnostic: ls.Diagnostic): code.Diagnostic;
+    asDiagnostics(diagnostics: ls.Diagnostic[], token?: code.CancellationToken): Promise<code.Diagnostic[]>;
+    asDiagnosticSeverity(value: number | undefined | null): code.DiagnosticSeverity;
+    asDiagnosticTag(tag: ls.DiagnosticTag): code.DiagnosticTag | undefined;
+    asHover(hover: undefined | null): undefined;
+    asHover(hover: ls.Hover): code.Hover;
+    asHover(hover: ls.Hover | undefined | null): code.Hover | undefined;
+    asCompletionResult(value: undefined | null, allCommitCharacters?: string[], token?: code.CancellationToken): Promise<undefined>;
+    asCompletionResult(value: ls.CompletionList, allCommitCharacters?: string[], token?: code.CancellationToken): Promise<code.CompletionList>;
+    asCompletionResult(value: ls.CompletionItem[], allCommitCharacters?: string[], token?: code.CancellationToken): Promise<code.CompletionItem[]>;
+    asCompletionResult(value: ls.CompletionItem[] | ls.CompletionList | undefined | null, allCommitCharacters?: string[], token?: code.CancellationToken): Promise<code.CompletionItem[] | code.CompletionList | undefined>;
+    asCompletionItem(item: ls.CompletionItem, defaultCommitCharacters?: string[]): ProtocolCompletionItem;
+    asTextEdit(edit: undefined | null): undefined;
+    asTextEdit(edit: ls.TextEdit): code.TextEdit;
+    asTextEdit(edit: ls.TextEdit | undefined | null): code.TextEdit | undefined;
+    asTextEdits(items: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asTextEdits(items: ls.TextEdit[], token?: code.CancellationToken): Promise<code.TextEdit[]>;
+    asTextEdits(items: ls.TextEdit[] | undefined | null, token?: code.CancellationToken): Promise<code.TextEdit[] | undefined>;
+    asSignatureHelp(item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asSignatureHelp(item: ls.SignatureHelp, token?: code.CancellationToken): Promise<code.SignatureHelp>;
+    asSignatureHelp(item: ls.SignatureHelp | undefined | null, token?: code.CancellationToken): Promise<code.SignatureHelp | undefined>;
+    asSignatureInformation(item: ls.SignatureInformation, token?: code.CancellationToken): Promise<code.SignatureInformation>;
+    asSignatureInformations(items: ls.SignatureInformation[], token?: code.CancellationToken): Promise<code.SignatureInformation[]>;
+    asParameterInformation(item: ls.ParameterInformation): code.ParameterInformation;
+    asParameterInformations(item: ls.ParameterInformation[], token?: code.CancellationToken): Promise<code.ParameterInformation[]>;
+    asLocation(item: ls.Location): code.Location;
+    asLocation(item: undefined | null): undefined;
+    asLocation(item: ls.Location | undefined | null): code.Location | undefined;
+    asDeclarationResult(item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asDeclarationResult(item: ls.Declaration, token?: code.CancellationToken): Promise<code.Location | code.Location[]>;
+    asDeclarationResult(item: ls.DeclarationLink[], token?: code.CancellationToken): Promise<code.LocationLink[]>;
+    asDeclarationResult(item: ls.Declaration | ls.DeclarationLink[] | undefined | null, token?: code.CancellationToken): Promise<code.Declaration | undefined>;
+    asDefinitionResult(item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asDefinitionResult(item: ls.Definition, token?: code.CancellationToken): Promise<code.Definition>;
+    asDefinitionResult(item: ls.DefinitionLink[], token?: code.CancellationToken): Promise<code.DefinitionLink[]>;
+    asDefinitionResult(item: ls.Definition | ls.DefinitionLink[] | undefined | null, token?: code.CancellationToken): Promise<code.Definition | code.DefinitionLink[] | undefined>;
+    asReferences(values: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asReferences(values: ls.Location[], token?: code.CancellationToken): Promise<code.Location[]>;
+    asReferences(values: ls.Location[] | undefined | null, token?: code.CancellationToken): Promise<code.Location[] | undefined>;
+    asDocumentHighlightKind(item: number): code.DocumentHighlightKind;
+    asDocumentHighlight(item: ls.DocumentHighlight): code.DocumentHighlight;
+    asDocumentHighlights(values: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asDocumentHighlights(values: ls.DocumentHighlight[], token?: code.CancellationToken): Promise<code.DocumentHighlight[]>;
+    asDocumentHighlights(values: ls.DocumentHighlight[] | undefined | null, token?: code.CancellationToken): Promise<code.DocumentHighlight[] | undefined>;
+    asSymbolKind(item: ls.SymbolKind): code.SymbolKind;
+    asSymbolTag(item: ls.SymbolTag): code.SymbolTag | undefined;
+    asSymbolTags(items: undefined | null): undefined;
+    asSymbolTags(items: ReadonlyArray<ls.SymbolTag>): code.SymbolTag[];
+    asSymbolTags(items: ReadonlyArray<ls.SymbolTag> | undefined | null): code.SymbolTag[] | undefined;
+    asSymbolInformation(item: ls.SymbolInformation | ls.WorkspaceSymbol): code.SymbolInformation;
+    asSymbolInformations(values: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asSymbolInformations(values: ls.SymbolInformation[] | ls.WorkspaceSymbol[], token?: code.CancellationToken): Promise<code.SymbolInformation[]>;
+    asSymbolInformations(values: ls.SymbolInformation[] | ls.WorkspaceSymbol[] | undefined | null, token?: code.CancellationToken): Promise<code.SymbolInformation[] | undefined>;
+    asDocumentSymbol(value: ls.DocumentSymbol, token?: code.CancellationToken): code.DocumentSymbol;
+    asDocumentSymbols(value: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asDocumentSymbols(value: ls.DocumentSymbol[], token?: code.CancellationToken): Promise<code.DocumentSymbol[]>;
+    asDocumentSymbols(value: ls.DocumentSymbol[] | undefined | null, token?: code.CancellationToken): Promise<code.DocumentSymbol[] | undefined>;
+    asCommand(item: ls.Command): code.Command;
+    asCommands(items: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asCommands(items: ls.Command[], token?: code.CancellationToken): Promise<code.Command[]>;
+    asCommands(items: ls.Command[] | undefined | null, token?: code.CancellationToken): Promise<code.Command[] | undefined>;
+    asCodeAction(item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asCodeAction(item: ls.CodeAction, token?: code.CancellationToken): Promise<code.CodeAction>;
+    asCodeAction(item: ls.CodeAction | undefined | null, token?: code.CancellationToken): Promise<code.CodeAction | undefined>;
+    asCodeActionKind(item: null | undefined): undefined;
+    asCodeActionKind(item: ls.CodeActionKind): code.CodeActionKind;
+    asCodeActionKind(item: ls.CodeActionKind | null | undefined): code.CodeActionKind | undefined;
+    asCodeActionKinds(item: null | undefined): undefined;
+    asCodeActionKinds(items: ls.CodeActionKind[]): code.CodeActionKind[];
+    asCodeActionKinds(item: ls.CodeActionKind[] | null | undefined): code.CodeActionKind[] | undefined;
+    asCodeActionResult(items: (ls.Command | ls.CodeAction)[], token?: code.CancellationToken): Promise<(code.Command | code.CodeAction)[]>;
+    asCodeLens(item: ls.CodeLens): code.CodeLens;
+    asCodeLens(item: undefined | null): undefined;
+    asCodeLens(item: ls.CodeLens | undefined | null): code.CodeLens | undefined;
+    asCodeLenses(items: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asCodeLenses(items: ls.CodeLens[], token?: code.CancellationToken): Promise<code.CodeLens[]>;
+    asCodeLenses(items: ls.CodeLens[] | undefined | null, token?: code.CancellationToken): Promise<code.CodeLens[] | undefined>;
+    asWorkspaceEdit(item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asWorkspaceEdit(item: ls.WorkspaceEdit, token?: code.CancellationToken): Promise<code.WorkspaceEdit>;
+    asWorkspaceEdit(item: ls.WorkspaceEdit | undefined | null, token?: code.CancellationToken): Promise<code.WorkspaceEdit | undefined>;
+    asDocumentLink(item: ls.DocumentLink): code.DocumentLink;
+    asDocumentLinks(items: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asDocumentLinks(items: ls.DocumentLink[], token?: code.CancellationToken): Promise<code.DocumentLink[]>;
+    asDocumentLinks(items: ls.DocumentLink[] | undefined | null, token?: code.CancellationToken): Promise<code.DocumentLink[] | undefined>;
+    asColor(color: ls.Color): code.Color;
+    asColorInformation(ci: ls.ColorInformation): code.ColorInformation;
+    asColorInformations(colorPresentations: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asColorInformations(colorPresentations: ls.ColorInformation[], token?: code.CancellationToken): Promise<code.ColorInformation[]>;
+    asColorInformations(colorInformation: ls.ColorInformation[] | undefined | null, token?: code.CancellationToken): Promise<code.ColorInformation[]>;
+    asColorPresentation(cp: ls.ColorPresentation): code.ColorPresentation;
+    asColorPresentations(colorPresentations: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asColorPresentations(colorPresentations: ls.ColorPresentation[], token?: code.CancellationToken): Promise<code.ColorPresentation[]>;
+    asColorPresentations(colorPresentations: ls.ColorPresentation[] | undefined | null, token?: code.CancellationToken): Promise<code.ColorPresentation[] | undefined>;
+    asFoldingRangeKind(kind: string | undefined): code.FoldingRangeKind | undefined;
+    asFoldingRange(r: ls.FoldingRange): code.FoldingRange;
+    asFoldingRanges(foldingRanges: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asFoldingRanges(foldingRanges: ls.FoldingRange[], token?: code.CancellationToken): Promise<code.FoldingRange[]>;
+    asFoldingRanges(foldingRanges: ls.FoldingRange[] | undefined | null, token?: code.CancellationToken): Promise<code.FoldingRange[] | undefined>;
+    asSelectionRange(selectionRange: ls.SelectionRange): code.SelectionRange;
+    asSelectionRanges(selectionRanges: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asSelectionRanges(selectionRanges: ls.SelectionRange[], token?: code.CancellationToken): Promise<code.SelectionRange[]>;
+    asSelectionRanges(selectionRanges: ls.SelectionRange[] | undefined | null, token?: code.CancellationToken): Promise<code.SelectionRange[] | undefined>;
+    asInlineValue(value: ls.InlineValue): code.InlineValue;
+    asInlineValues(values: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asInlineValues(values: ls.InlineValue[], token?: code.CancellationToken): Promise<code.InlineValue[]>;
+    asInlineValues(values: ls.InlineValue[] | undefined | null, token?: code.CancellationToken): Promise<code.InlineValue[] | undefined>;
+    asInlayHint(value: ls.InlayHint, token?: code.CancellationToken): Promise<code.InlayHint>;
+    asInlayHints(values: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asInlayHints(values: ls.InlayHint[], token?: code.CancellationToken): Promise<code.InlayHint[]>;
+    asInlayHints(values: ls.InlayHint[] | undefined | null, token?: code.CancellationToken): Promise<code.InlayHint[] | undefined>;
+    asSemanticTokensLegend(value: ls.SemanticTokensLegend): code.SemanticTokensLegend;
+    asSemanticTokens(value: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asSemanticTokens(value: ls.SemanticTokens, token?: code.CancellationToken): Promise<code.SemanticTokens>;
+    asSemanticTokens(value: ls.SemanticTokens | undefined | null, token?: code.CancellationToken): Promise<code.SemanticTokens | undefined>;
+    asSemanticTokensEdit(value: ls.SemanticTokensEdit): code.SemanticTokensEdit;
+    asSemanticTokensEdits(value: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asSemanticTokensEdits(value: ls.SemanticTokensDelta, token?: code.CancellationToken): Promise<code.SemanticTokensEdits>;
+    asSemanticTokensEdits(value: ls.SemanticTokensDelta | undefined | null, token?: code.CancellationToken): Promise<code.SemanticTokensEdits | undefined>;
+    asCallHierarchyItem(item: null): undefined;
+    asCallHierarchyItem(item: ls.CallHierarchyItem): code.CallHierarchyItem;
+    asCallHierarchyItem(item: ls.CallHierarchyItem | null): code.CallHierarchyItem | undefined;
+    asCallHierarchyItems(items: null, token?: code.CancellationToken): Promise<undefined>;
+    asCallHierarchyItems(items: ls.CallHierarchyItem[], token?: code.CancellationToken): Promise<code.CallHierarchyItem[]>;
+    asCallHierarchyItems(items: ls.CallHierarchyItem[] | null, token?: code.CancellationToken): Promise<code.CallHierarchyItem[] | undefined>;
+    asCallHierarchyIncomingCall(item: ls.CallHierarchyIncomingCall, token?: code.CancellationToken): Promise<code.CallHierarchyIncomingCall>;
+    asCallHierarchyIncomingCalls(items: null, token?: code.CancellationToken): Promise<undefined>;
+    asCallHierarchyIncomingCalls(items: ReadonlyArray<ls.CallHierarchyIncomingCall>, token?: code.CancellationToken): Promise<code.CallHierarchyIncomingCall[]>;
+    asCallHierarchyIncomingCalls(items: ReadonlyArray<ls.CallHierarchyIncomingCall> | null, token?: code.CancellationToken): Promise<code.CallHierarchyIncomingCall[] | undefined>;
+    asCallHierarchyOutgoingCall(item: ls.CallHierarchyOutgoingCall, token?: code.CancellationToken): Promise<code.CallHierarchyOutgoingCall>;
+    asCallHierarchyOutgoingCalls(items: null, token?: code.CancellationToken): Promise<undefined>;
+    asCallHierarchyOutgoingCalls(items: ReadonlyArray<ls.CallHierarchyOutgoingCall>, token?: code.CancellationToken): Promise<code.CallHierarchyOutgoingCall[]>;
+    asCallHierarchyOutgoingCalls(items: ReadonlyArray<ls.CallHierarchyOutgoingCall> | null, token?: code.CancellationToken): Promise<code.CallHierarchyOutgoingCall[] | undefined>;
+    asLinkedEditingRanges(value: null | undefined, token?: code.CancellationToken): Promise<undefined>;
+    asLinkedEditingRanges(value: ls.LinkedEditingRanges, token?: code.CancellationToken): Promise<code.LinkedEditingRanges>;
+    asLinkedEditingRanges(value: ls.LinkedEditingRanges | null | undefined, token?: code.CancellationToken): Promise<code.LinkedEditingRanges | undefined>;
+    asTypeHierarchyItem(item: null): undefined;
+    asTypeHierarchyItem(item: ls.TypeHierarchyItem): code.TypeHierarchyItem;
+    asTypeHierarchyItem(item: ls.TypeHierarchyItem | null): code.TypeHierarchyItem | undefined;
+    asTypeHierarchyItems(items: null, token?: code.CancellationToken): Promise<undefined>;
+    asTypeHierarchyItems(items: ls.TypeHierarchyItem[], token?: code.CancellationToken): Promise<code.TypeHierarchyItem[]>;
+    asTypeHierarchyItems(items: ls.TypeHierarchyItem[] | null, token?: code.CancellationToken): Promise<code.TypeHierarchyItem[] | undefined>;
+    asGlobPattern(pattern: ls.GlobPattern): code.GlobPattern | undefined;
+    asInlineCompletionResult(value: undefined | null, token?: code.CancellationToken): Promise<undefined>;
+    asInlineCompletionResult(value: ls.InlineCompletionList, token?: code.CancellationToken): Promise<code.InlineCompletionList>;
+    asInlineCompletionResult(value: ls.InlineCompletionItem[], token?: code.CancellationToken): Promise<code.InlineCompletionItem[]>;
+    asInlineCompletionResult(value: ls.InlineCompletionItem[] | ls.InlineCompletionList | undefined | null, token?: code.CancellationToken): Promise<code.InlineCompletionItem[] | code.InlineCompletionList | undefined>;
+    asInlineCompletionItem(item: ls.InlineCompletionItem): code.InlineCompletionItem;
+}
+export interface URIConverter {
+    (value: string): code.Uri;
+}
+export declare function createConverter(uriConverter: URIConverter | undefined, trustMarkdown: boolean | {
+    readonly enabledCommands: readonly string[];
+}, supportHtml: boolean): Converter;