vscode-languageserver-protocol 3.17.0-next.9

package/lib/common/protocol.linkedEditingRange.d.ts

@@ -0,0 +1,51 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Range } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { StaticRegistrationOptions, TextDocumentPositionParams, TextDocumentRegistrationOptions, WorkDoneProgressOptions, WorkDoneProgressParams } from './protocol';
+/**
+ * Client capabilities for the linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRangeClientCapabilities {
+    /**
+     * 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;
+}
+export interface LinkedEditingRangeParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+export interface LinkedEditingRangeOptions extends WorkDoneProgressOptions {
+}
+export interface LinkedEditingRangeRegistrationOptions extends TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions {
+}
+/**
+ * The result of a linked editing range request.
+ *
+ * @since 3.16.0
+ */
+export interface LinkedEditingRanges {
+    /**
+     * A list of ranges that can be edited together. The ranges must have
+     * identical length and contain identical text content. The ranges cannot overlap.
+     */
+    ranges: Range[];
+    /**
+     * An optional word pattern (regular expression) that describes valid contents for
+     * the given ranges. If no pattern is provided, the client configuration's word
+     * pattern will be used.
+     */
+    wordPattern?: string;
+}
+/**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+export declare namespace LinkedEditingRangeRequest {
+    const method: 'textDocument/linkedEditingRange';
+    const type: ProtocolRequestType<LinkedEditingRangeParams, LinkedEditingRanges | null, void, any, LinkedEditingRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<LinkedEditingRangeParams, LinkedEditingRanges | null, void>;
+}

package/lib/common/protocol.linkedEditingRange.js

@@ -0,0 +1,19 @@
+"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.LinkedEditingRangeRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide ranges that can be edited together.
+ *
+ * @since 3.16.0
+ */
+var LinkedEditingRangeRequest;
+(function (LinkedEditingRangeRequest) {
+    LinkedEditingRangeRequest.method = 'textDocument/linkedEditingRange';
+    LinkedEditingRangeRequest.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest.method);
+})(LinkedEditingRangeRequest = exports.LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = {}));
+//# sourceMappingURL=protocol.linkedEditingRange.js.map

package/lib/common/protocol.moniker.d.ts

@@ -0,0 +1,103 @@
+import { ProtocolRequestType } from './messages';
+import { WorkDoneProgressOptions, WorkDoneProgressParams, PartialResultParams, TextDocumentRegistrationOptions, TextDocumentPositionParams } from './protocol';
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+export declare enum UniquenessLevel {
+    /**
+     * The moniker is only unique inside a document
+     */
+    document = "document",
+    /**
+     * The moniker is unique inside a project for which a dump got created
+     */
+    project = "project",
+    /**
+     * The moniker is unique inside the group to which a project belongs
+     */
+    group = "group",
+    /**
+     * The moniker is unique inside the moniker scheme.
+     */
+    scheme = "scheme",
+    /**
+     * The moniker is globally unique
+     */
+    global = "global"
+}
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+export declare enum MonikerKind {
+    /**
+     * The moniker represent a symbol that is imported into a project
+     */
+    import = "import",
+    /**
+     * The moniker represents a symbol that is exported from a project
+     */
+    export = "export",
+    /**
+     * The moniker represents a symbol that is local to a project (e.g. a local
+     * variable of a function, a class not visible outside the project, ...)
+     */
+    local = "local"
+}
+/**
+ * Moniker definition to match LSIF 0.5 moniker definition.
+ *
+ * @since 3.16.0
+ */
+export interface Moniker {
+    /**
+     * The scheme of the moniker. For example tsc or .Net
+     */
+    scheme: string;
+    /**
+     * The identifier of the moniker. The value is opaque in LSIF however
+     * schema owners are allowed to define the structure if they want.
+     */
+    identifier: string;
+    /**
+     * The scope in which the moniker is unique
+     */
+    unique: UniquenessLevel;
+    /**
+     * The moniker kind if known.
+     */
+    kind?: MonikerKind;
+}
+/**
+ * Client capabilities specific to the moniker request.
+ *
+ * @since 3.16.0
+ */
+export interface MonikerClientCapabilities {
+    /**
+     * Whether moniker supports dynamic registration. If this is set to `true`
+     * the client supports the new `MonikerRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+}
+export interface MonikerServerCapabilities {
+}
+export interface MonikerOptions extends WorkDoneProgressOptions {
+}
+export interface MonikerRegistrationOptions extends TextDocumentRegistrationOptions, MonikerOptions {
+}
+export interface MonikerParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type [TextDocumentPositionParams](#TextDocumentPositionParams).
+ * The response is of type [Moniker[]](#Moniker[]) or `null`.
+ */
+export declare namespace MonikerRequest {
+    const method: 'textDocument/moniker';
+    const type: ProtocolRequestType<MonikerParams, Moniker[] | null, Moniker[], void, MonikerRegistrationOptions>;
+}

package/lib/common/protocol.moniker.js

@@ -0,0 +1,68 @@
+"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.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
+const messages_1 = require("./messages");
+/**
+ * Moniker uniqueness level to define scope of the moniker.
+ *
+ * @since 3.16.0
+ */
+var UniquenessLevel;
+(function (UniquenessLevel) {
+    /**
+     * The moniker is only unique inside a document
+     */
+    UniquenessLevel["document"] = "document";
+    /**
+     * The moniker is unique inside a project for which a dump got created
+     */
+    UniquenessLevel["project"] = "project";
+    /**
+     * The moniker is unique inside the group to which a project belongs
+     */
+    UniquenessLevel["group"] = "group";
+    /**
+     * The moniker is unique inside the moniker scheme.
+     */
+    UniquenessLevel["scheme"] = "scheme";
+    /**
+     * The moniker is globally unique
+     */
+    UniquenessLevel["global"] = "global";
+})(UniquenessLevel = exports.UniquenessLevel || (exports.UniquenessLevel = {}));
+/**
+ * The moniker kind.
+ *
+ * @since 3.16.0
+ */
+var MonikerKind;
+(function (MonikerKind) {
+    /**
+     * The moniker represent a symbol that is imported into a project
+     */
+    MonikerKind["import"] = "import";
+    /**
+     * The moniker represents a symbol that is exported from a project
+     */
+    MonikerKind["export"] = "export";
+    /**
+     * The moniker represents a symbol that is local to a project (e.g. a local
+     * variable of a function, a class not visible outside the project, ...)
+     */
+    MonikerKind["local"] = "local";
+})(MonikerKind = exports.MonikerKind || (exports.MonikerKind = {}));
+/**
+ * A request to get the moniker of a symbol at a given text document position.
+ * The request parameter is of type [TextDocumentPositionParams](#TextDocumentPositionParams).
+ * The response is of type [Moniker[]](#Moniker[]) or `null`.
+ */
+var MonikerRequest;
+(function (MonikerRequest) {
+    MonikerRequest.method = 'textDocument/moniker';
+    MonikerRequest.type = new messages_1.ProtocolRequestType(MonikerRequest.method);
+})(MonikerRequest = exports.MonikerRequest || (exports.MonikerRequest = {}));
+//# sourceMappingURL=protocol.moniker.js.map

package/lib/common/protocol.progress.d.ts

@@ -0,0 +1,117 @@
+import { NotificationHandler, RequestHandler, ProgressType, ProgressToken } from 'vscode-jsonrpc';
+import { uinteger } from 'vscode-languageserver-types';
+import { ProtocolRequestType, ProtocolNotificationType } from './messages';
+export interface WorkDoneProgressClientCapabilities {
+    /**
+     * Window specific client capabilities.
+     */
+    window?: {
+        /**
+         * Whether client supports server initiated progress using the
+         * `window/workDoneProgress/create` request.
+         *
+         * Since 3.15.0
+         */
+        workDoneProgress?: boolean;
+    };
+}
+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 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 type: ProtocolNotificationType<WorkDoneProgressCancelParams, void>;
+    type HandlerSignature = NotificationHandler<WorkDoneProgressCancelParams>;
+}

package/lib/common/protocol.progress.js

@@ -0,0 +1,34 @@
+"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 || (exports.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.type = new messages_1.ProtocolRequestType('window/workDoneProgress/create');
+})(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.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.type = new messages_1.ProtocolNotificationType('window/workDoneProgress/cancel');
+})(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {}));
+//# sourceMappingURL=protocol.progress.js.map

package/lib/common/protocol.selectionRange.d.ts

@@ -0,0 +1,40 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TextDocumentIdentifier, Position, SelectionRange } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { 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 [SelectionRangeParams](#SelectionRangeParams), the
+ * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable
+ * that resolves to such.
+ */
+export declare namespace SelectionRangeRequest {
+    const method: 'textDocument/selectionRange';
+    const type: ProtocolRequestType<SelectionRangeParams, SelectionRange[] | null, SelectionRange[], any, SelectionRangeRegistrationOptions>;
+    type HandlerSignature = RequestHandler<SelectionRangeParams, SelectionRange[] | null, void>;
+}

package/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 [SelectionRangeParams](#SelectionRangeParams), the
+ * response is of type [SelectionRange[]](#SelectionRange[]) or a Thenable
+ * that resolves to such.
+ */
+var SelectionRangeRequest;
+(function (SelectionRangeRequest) {
+    SelectionRangeRequest.method = 'textDocument/selectionRange';
+    SelectionRangeRequest.type = new messages_1.ProtocolRequestType(SelectionRangeRequest.method);
+})(SelectionRangeRequest = exports.SelectionRangeRequest || (exports.SelectionRangeRequest = {}));
+//# sourceMappingURL=protocol.selectionRange.js.map

package/lib/common/protocol.semanticTokens.d.ts

@@ -0,0 +1,194 @@
+import { TextDocumentIdentifier, Range, uinteger, SemanticTokensEdit, SemanticTokensLegend, SemanticTokens, SemanticTokensDelta } from 'vscode-languageserver-types';
+import { RequestHandler0, RequestHandler } from 'vscode-jsonrpc';
+import { ProtocolRequestType, ProtocolRequestType0, RegistrationType } from './messages';
+import { 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 declare 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;
+}
+/**
+ * @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 type: ProtocolRequestType<SemanticTokensParams, SemanticTokens | null, SemanticTokensPartialResult, void, SemanticTokensRegistrationOptions>;
+    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 type: ProtocolRequestType<SemanticTokensDeltaParams, SemanticTokens | SemanticTokensDelta | null, SemanticTokensPartialResult | SemanticTokensDeltaPartialResult, void, SemanticTokensRegistrationOptions>;
+    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 type: ProtocolRequestType<SemanticTokensRangeParams, SemanticTokens | null, SemanticTokensPartialResult, void, void>;
+    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 type: ProtocolRequestType0<void, void, void, void>;
+    type HandlerSignature = RequestHandler0<void, void>;
+}