@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js

@@ -0,0 +1,214 @@
+"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.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = void 0;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const Is = require("./utils/is");
+const messages_1 = require("./messages");
+/**
+ * A notebook cell kind.
+ *
+ * @since 3.17.0
+ */
+var NotebookCellKind;
+(function (NotebookCellKind) {
+    /**
+     * A markup-cell is formatted source that is used for display.
+     */
+    NotebookCellKind.Markup = 1;
+    /**
+     * A code-cell is source code.
+     */
+    NotebookCellKind.Code = 2;
+    function is(value) {
+        return value === 1 || value === 2;
+    }
+    NotebookCellKind.is = is;
+})(NotebookCellKind || (exports.NotebookCellKind = NotebookCellKind = {}));
+var ExecutionSummary;
+(function (ExecutionSummary) {
+    function create(executionOrder, success) {
+        const result = { executionOrder };
+        if (success === true || success === false) {
+            result.success = success;
+        }
+        return result;
+    }
+    ExecutionSummary.create = create;
+    function is(value) {
+        const candidate = value;
+        return Is.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.executionOrder) && (candidate.success === undefined || Is.boolean(candidate.success));
+    }
+    ExecutionSummary.is = is;
+    function equals(one, other) {
+        if (one === other) {
+            return true;
+        }
+        if (one === null || one === undefined || other === null || other === undefined) {
+            return false;
+        }
+        return one.executionOrder === other.executionOrder && one.success === other.success;
+    }
+    ExecutionSummary.equals = equals;
+})(ExecutionSummary || (exports.ExecutionSummary = ExecutionSummary = {}));
+var NotebookCell;
+(function (NotebookCell) {
+    function create(kind, document) {
+        return { kind, document };
+    }
+    NotebookCell.create = create;
+    function is(value) {
+        const candidate = value;
+        return Is.objectLiteral(candidate) && NotebookCellKind.is(candidate.kind) && vscode_languageserver_types_1.DocumentUri.is(candidate.document) &&
+            (candidate.metadata === undefined || Is.objectLiteral(candidate.metadata));
+    }
+    NotebookCell.is = is;
+    function diff(one, two) {
+        const result = new Set();
+        if (one.document !== two.document) {
+            result.add('document');
+        }
+        if (one.kind !== two.kind) {
+            result.add('kind');
+        }
+        if (one.executionSummary !== two.executionSummary) {
+            result.add('executionSummary');
+        }
+        if ((one.metadata !== undefined || two.metadata !== undefined) && !equalsMetadata(one.metadata, two.metadata)) {
+            result.add('metadata');
+        }
+        if ((one.executionSummary !== undefined || two.executionSummary !== undefined) && !ExecutionSummary.equals(one.executionSummary, two.executionSummary)) {
+            result.add('executionSummary');
+        }
+        return result;
+    }
+    NotebookCell.diff = diff;
+    function equalsMetadata(one, other) {
+        if (one === other) {
+            return true;
+        }
+        if (one === null || one === undefined || other === null || other === undefined) {
+            return false;
+        }
+        if (typeof one !== typeof other) {
+            return false;
+        }
+        if (typeof one !== 'object') {
+            return false;
+        }
+        const oneArray = Array.isArray(one);
+        const otherArray = Array.isArray(other);
+        if (oneArray !== otherArray) {
+            return false;
+        }
+        if (oneArray && otherArray) {
+            if (one.length !== other.length) {
+                return false;
+            }
+            for (let i = 0; i < one.length; i++) {
+                if (!equalsMetadata(one[i], other[i])) {
+                    return false;
+                }
+            }
+        }
+        if (Is.objectLiteral(one) && Is.objectLiteral(other)) {
+            const oneKeys = Object.keys(one);
+            const otherKeys = Object.keys(other);
+            if (oneKeys.length !== otherKeys.length) {
+                return false;
+            }
+            oneKeys.sort();
+            otherKeys.sort();
+            if (!equalsMetadata(oneKeys, otherKeys)) {
+                return false;
+            }
+            for (let i = 0; i < oneKeys.length; i++) {
+                const prop = oneKeys[i];
+                if (!equalsMetadata(one[prop], other[prop])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+})(NotebookCell || (exports.NotebookCell = NotebookCell = {}));
+var NotebookDocument;
+(function (NotebookDocument) {
+    function create(uri, notebookType, version, cells) {
+        return { uri, notebookType, version, cells };
+    }
+    NotebookDocument.create = create;
+    function is(value) {
+        const candidate = value;
+        return Is.objectLiteral(candidate) && Is.string(candidate.uri) && vscode_languageserver_types_1.integer.is(candidate.version) && Is.typedArray(candidate.cells, NotebookCell.is);
+    }
+    NotebookDocument.is = is;
+})(NotebookDocument || (exports.NotebookDocument = NotebookDocument = {}));
+var NotebookDocumentSyncRegistrationType;
+(function (NotebookDocumentSyncRegistrationType) {
+    NotebookDocumentSyncRegistrationType.method = 'notebookDocument/sync';
+    NotebookDocumentSyncRegistrationType.messageDirection = messages_1.MessageDirection.clientToServer;
+    NotebookDocumentSyncRegistrationType.type = new messages_1.RegistrationType(NotebookDocumentSyncRegistrationType.method);
+})(NotebookDocumentSyncRegistrationType || (exports.NotebookDocumentSyncRegistrationType = NotebookDocumentSyncRegistrationType = {}));
+/**
+ * A notification sent when a notebook opens.
+ *
+ * @since 3.17.0
+ */
+var DidOpenNotebookDocumentNotification;
+(function (DidOpenNotebookDocumentNotification) {
+    DidOpenNotebookDocumentNotification.method = 'notebookDocument/didOpen';
+    DidOpenNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
+    DidOpenNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification.method);
+    DidOpenNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
+})(DidOpenNotebookDocumentNotification || (exports.DidOpenNotebookDocumentNotification = DidOpenNotebookDocumentNotification = {}));
+var NotebookCellArrayChange;
+(function (NotebookCellArrayChange) {
+    function is(value) {
+        const candidate = value;
+        return Is.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.start) && vscode_languageserver_types_1.uinteger.is(candidate.deleteCount) && (candidate.cells === undefined || Is.typedArray(candidate.cells, NotebookCell.is));
+    }
+    NotebookCellArrayChange.is = is;
+    function create(start, deleteCount, cells) {
+        const result = { start, deleteCount };
+        if (cells !== undefined) {
+            result.cells = cells;
+        }
+        return result;
+    }
+    NotebookCellArrayChange.create = create;
+})(NotebookCellArrayChange || (exports.NotebookCellArrayChange = NotebookCellArrayChange = {}));
+var DidChangeNotebookDocumentNotification;
+(function (DidChangeNotebookDocumentNotification) {
+    DidChangeNotebookDocumentNotification.method = 'notebookDocument/didChange';
+    DidChangeNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
+    DidChangeNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeNotebookDocumentNotification.method);
+    DidChangeNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
+})(DidChangeNotebookDocumentNotification || (exports.DidChangeNotebookDocumentNotification = DidChangeNotebookDocumentNotification = {}));
+/**
+ * A notification sent when a notebook document is saved.
+ *
+ * @since 3.17.0
+ */
+var DidSaveNotebookDocumentNotification;
+(function (DidSaveNotebookDocumentNotification) {
+    DidSaveNotebookDocumentNotification.method = 'notebookDocument/didSave';
+    DidSaveNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
+    DidSaveNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveNotebookDocumentNotification.method);
+    DidSaveNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
+})(DidSaveNotebookDocumentNotification || (exports.DidSaveNotebookDocumentNotification = DidSaveNotebookDocumentNotification = {}));
+/**
+ * A notification sent when a notebook closes.
+ *
+ * @since 3.17.0
+ */
+var DidCloseNotebookDocumentNotification;
+(function (DidCloseNotebookDocumentNotification) {
+    DidCloseNotebookDocumentNotification.method = 'notebookDocument/didClose';
+    DidCloseNotebookDocumentNotification.messageDirection = messages_1.MessageDirection.clientToServer;
+    DidCloseNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification.method);
+    DidCloseNotebookDocumentNotification.registrationMethod = NotebookDocumentSyncRegistrationType.method;
+})(DidCloseNotebookDocumentNotification || (exports.DidCloseNotebookDocumentNotification = DidCloseNotebookDocumentNotification = {}));

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.d.ts

@@ -0,0 +1,107 @@
+import { NotificationHandler, RequestHandler, ProgressType, ProgressToken } from 'vscode-jsonrpc';
+import { uinteger } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType, ProtocolNotificationType } from './messages';
+export interface WorkDoneProgressBegin {
+    kind: 'begin';
+    /**
+     * Mandatory title of the progress operation. Used to briefly inform about
+     * the kind of operation being performed.
+     *
+     * Examples: "Indexing" or "Linking dependencies".
+     */
+    title: string;
+    /**
+     * Controls if a cancel button should show to allow the user to cancel the
+     * long running operation. Clients that don't support cancellation are allowed
+     * to ignore the setting.
+     */
+    cancellable?: boolean;
+    /**
+     * Optional, more detailed associated progress message. Contains
+     * complementary information to the `title`.
+     *
+     * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+     * If unset, the previous progress message (if any) is still valid.
+     */
+    message?: string;
+    /**
+     * Optional progress percentage to display (value 100 is considered 100%).
+     * If not provided infinite progress is assumed and clients are allowed
+     * to ignore the `percentage` value in subsequent in report notifications.
+     *
+     * The value should be steadily rising. Clients are free to ignore values
+     * that are not following this rule. The value range is [0, 100].
+     */
+    percentage?: uinteger;
+}
+export interface WorkDoneProgressReport {
+    kind: 'report';
+    /**
+     * Controls enablement state of a cancel button.
+     *
+     * Clients that don't support cancellation or don't support controlling the button's
+     * enablement state are allowed to ignore the property.
+     */
+    cancellable?: boolean;
+    /**
+     * Optional, more detailed associated progress message. Contains
+     * complementary information to the `title`.
+     *
+     * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+     * If unset, the previous progress message (if any) is still valid.
+     */
+    message?: string;
+    /**
+     * Optional progress percentage to display (value 100 is considered 100%).
+     * If not provided infinite progress is assumed and clients are allowed
+     * to ignore the `percentage` value in subsequent in report notifications.
+     *
+     * The value should be steadily rising. Clients are free to ignore values
+     * that are not following this rule. The value range is [0, 100]
+     */
+    percentage?: uinteger;
+}
+export interface WorkDoneProgressEnd {
+    kind: 'end';
+    /**
+     * Optional, a final message indicating to for example indicate the outcome
+     * of the operation.
+     */
+    message?: string;
+}
+export declare namespace WorkDoneProgress {
+    const type: ProgressType<WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd>;
+    function is(value: ProgressType<any>): value is typeof type;
+}
+export interface WorkDoneProgressCreateParams {
+    /**
+     * The token to be used to report progress.
+     */
+    token: ProgressToken;
+}
+/**
+ * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
+ * reporting from the server.
+ */
+export declare namespace WorkDoneProgressCreateRequest {
+    const method: 'window/workDoneProgress/create';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<WorkDoneProgressCreateParams, void, never, void, void>;
+    type HandlerSignature = RequestHandler<WorkDoneProgressCreateParams, void, void>;
+}
+export interface WorkDoneProgressCancelParams {
+    /**
+     * The token to be used to report progress.
+     */
+    token: ProgressToken;
+}
+/**
+ * The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress
+ * initiated on the server side.
+ */
+export declare namespace WorkDoneProgressCancelNotification {
+    const method: 'window/workDoneProgress/cancel';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<WorkDoneProgressCancelParams, void>;
+    type HandlerSignature = NotificationHandler<WorkDoneProgressCancelParams>;
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js

@@ -0,0 +1,37 @@
+"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.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const messages_1 = require("./messages");
+var WorkDoneProgress;
+(function (WorkDoneProgress) {
+    WorkDoneProgress.type = new vscode_jsonrpc_1.ProgressType();
+    function is(value) {
+        return value === WorkDoneProgress.type;
+    }
+    WorkDoneProgress.is = is;
+})(WorkDoneProgress || (exports.WorkDoneProgress = WorkDoneProgress = {}));
+/**
+ * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
+ * reporting from the server.
+ */
+var WorkDoneProgressCreateRequest;
+(function (WorkDoneProgressCreateRequest) {
+    WorkDoneProgressCreateRequest.method = 'window/workDoneProgress/create';
+    WorkDoneProgressCreateRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType(WorkDoneProgressCreateRequest.method);
+})(WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = WorkDoneProgressCreateRequest = {}));
+/**
+ * The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress
+ * initiated on the server side.
+ */
+var WorkDoneProgressCancelNotification;
+(function (WorkDoneProgressCancelNotification) {
+    WorkDoneProgressCancelNotification.method = 'window/workDoneProgress/cancel';
+    WorkDoneProgressCancelNotification.messageDirection = messages_1.MessageDirection.clientToServer;
+    WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType(WorkDoneProgressCancelNotification.method);
+})(WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = WorkDoneProgressCancelNotification = {}));

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.d.ts

@@ -0,0 +1,41 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier, Position, SelectionRange } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType } from './messages';
+import type { TextDocumentRegistrationOptions, WorkDoneProgressOptions, StaticRegistrationOptions, WorkDoneProgressParams, PartialResultParams } from './protocol';
+export interface SelectionRangeClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
+     * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server
+     * capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface SelectionRangeOptions extends WorkDoneProgressOptions {
+}
+export interface SelectionRangeRegistrationOptions extends SelectionRangeOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+/**
+ * A parameter literal used in selection range requests.
+ */
+export interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The positions inside the text document.
+     */
+    positions: Position[];
+}
+/**
+ * A request to provide selection ranges in a document. The request's
+ * parameter is of type {@link SelectionRangeParams}, the
+ * response is of type {@link SelectionRange SelectionRange[]} or a Thenable
+ * that resolves to such.
+ */
+export declare namespace SelectionRangeRequest {
+    const method: 'textDocument/selectionRange';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<SelectionRangeParams, SelectionRange[] | null, SelectionRange[], void, SelectionRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<SelectionRangeParams, SelectionRange[] | null, void>;
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js

@@ -0,0 +1,20 @@
+"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.SelectionRangeRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide selection ranges in a document. The request's
+ * parameter is of type {@link SelectionRangeParams}, the
+ * response is of type {@link SelectionRange SelectionRange[]} or a Thenable
+ * that resolves to such.
+ */
+var SelectionRangeRequest;
+(function (SelectionRangeRequest) {
+    SelectionRangeRequest.method = 'textDocument/selectionRange';
+    SelectionRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method);
+})(SelectionRangeRequest || (exports.SelectionRangeRequest = SelectionRangeRequest = {}));

package/node_modules/@mrclrchtr/supi-lsp/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.d.ts

@@ -0,0 +1,223 @@
+import { TextDocumentIdentifier, Range, uinteger, SemanticTokensEdit, SemanticTokensLegend, SemanticTokens, SemanticTokensDelta } from 'vscode-languageserver-types';
+import { RequestHandler0, RequestHandler } from 'vscode-jsonrpc';
+import { MessageDirection, ProtocolRequestType, ProtocolRequestType0, RegistrationType } from './messages';
+import type { PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions } from './protocol';
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensPartialResult {
+    data: uinteger[];
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDeltaPartialResult {
+    edits: SemanticTokensEdit[];
+}
+export declare namespace TokenFormat {
+    const Relative: 'relative';
+}
+export type TokenFormat = 'relative';
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+     * return value for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Which requests the client supports and might send to the server
+     * depending on the server's capability. Please note that clients might not
+     * show semantic tokens or degrade some of the user experience if a range
+     * or full request is advertised by the client but not provided by the
+     * server. If for example the client capability `requests.full` and
+     * `request.range` are both set to true but the server only provides a
+     * range provider the client might not render a minimap correctly or might
+     * even decide to not show any semantic tokens at all.
+     */
+    requests: {
+        /**
+         * The client will send the `textDocument/semanticTokens/range` request if
+         * the server provides a corresponding handler.
+         */
+        range?: boolean | {};
+        /**
+         * The client will send the `textDocument/semanticTokens/full` request if
+         * the server provides a corresponding handler.
+         */
+        full?: boolean | {
+            /**
+             * The client will send the `textDocument/semanticTokens/full/delta` request if
+             * the server provides a corresponding handler.
+             */
+            delta?: boolean;
+        };
+    };
+    /**
+     * The token types that the client supports.
+     */
+    tokenTypes: string[];
+    /**
+     * The token modifiers that the client supports.
+     */
+    tokenModifiers: string[];
+    /**
+     * The token formats the clients supports.
+     */
+    formats: TokenFormat[];
+    /**
+     * Whether the client supports tokens that can overlap each other.
+     */
+    overlappingTokenSupport?: boolean;
+    /**
+     * Whether the client supports tokens that can span multiple lines.
+     */
+    multilineTokenSupport?: boolean;
+    /**
+     * Whether the client allows the server to actively cancel a
+     * semantic token request, e.g. supports returning
+     * LSPErrorCodes.ServerCancelled. If a server does the client
+     * needs to retrigger the request.
+     *
+     * @since 3.17.0
+     */
+    serverCancelSupport?: boolean;
+    /**
+     * Whether the client uses semantic tokens to augment existing
+     * syntax tokens. If set to `true` client side created syntax
+     * tokens and semantic tokens are both used for colorization. If
+     * set to `false` the client only uses the returned semantic tokens
+     * for colorization.
+     *
+     * If the value is `undefined` then the client behavior is not
+     * specified.
+     *
+     * @since 3.17.0
+     */
+    augmentsSyntaxTokens?: boolean;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensOptions extends WorkDoneProgressOptions {
+    /**
+     * The legend used by the server
+     */
+    legend: SemanticTokensLegend;
+    /**
+     * Server supports providing semantic tokens for a specific range
+     * of a document.
+     */
+    range?: boolean | {};
+    /**
+     * Server supports providing semantic tokens for a full document.
+     */
+    full?: boolean | {
+        /**
+         * The server supports deltas for full documents.
+         */
+        delta?: boolean;
+    };
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions {
+}
+export declare namespace SemanticTokensRegistrationType {
+    const method: 'textDocument/semanticTokens';
+    const type: RegistrationType<SemanticTokensRegistrationOptions>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensRequest {
+    const method: 'textDocument/semanticTokens/full';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<SemanticTokensParams, SemanticTokens | null, SemanticTokensPartialResult, void, SemanticTokensRegistrationOptions>;
+    const registrationMethod: typeof SemanticTokensRegistrationType.method;
+    type HandlerSignature = RequestHandler<SemanticTokensDeltaParams, SemanticTokens | null, void>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensDeltaParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The result id of a previous response. The result Id can either point to a full response
+     * or a delta response depending on what was received last.
+     */
+    previousResultId: string;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensDeltaRequest {
+    const method: 'textDocument/semanticTokens/full/delta';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<SemanticTokensDeltaParams, SemanticTokens | SemanticTokensDelta | null, SemanticTokensPartialResult | SemanticTokensDeltaPartialResult, void, SemanticTokensRegistrationOptions>;
+    const registrationMethod: typeof SemanticTokensRegistrationType.method;
+    type HandlerSignature = RequestHandler<SemanticTokensDeltaParams, SemanticTokens | SemanticTokensDelta | null, void>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensRangeParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The range the semantic tokens are requested for.
+     */
+    range: Range;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensRangeRequest {
+    const method: 'textDocument/semanticTokens/range';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<SemanticTokensRangeParams, SemanticTokens | null, SemanticTokensPartialResult, void, void>;
+    const registrationMethod: typeof SemanticTokensRegistrationType.method;
+    type HandlerSignature = RequestHandler<SemanticTokensRangeParams, SemanticTokens | null, void>;
+}
+/**
+ * @since 3.16.0
+ */
+export interface SemanticTokensWorkspaceClientCapabilities {
+    /**
+     * Whether the client implementation supports a refresh request sent from
+     * the server to the client.
+     *
+     * Note that this event is global and will force the client to refresh all
+     * semantic tokens currently shown. It should be used with absolute care
+     * and is useful for situation where a server for example detects a project
+     * wide change that requires such a calculation.
+     */
+    refreshSupport?: boolean;
+}
+/**
+ * @since 3.16.0
+ */
+export declare namespace SemanticTokensRefreshRequest {
+    const method: `workspace/semanticTokens/refresh`;
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType0<void, void, void, void>;
+    type HandlerSignature = RequestHandler0<void, void>;
+}