vscode-languageserver-protocol 3.17.0-next.7 → 3.17.0

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

@@ -0,0 +1,391 @@
+import { URI, integer, DocumentUri, uinteger, TextDocumentItem, TextDocumentIdentifier, VersionedTextDocumentIdentifier, LSPObject } from 'vscode-languageserver-types';
+import { ProtocolNotificationType, RegistrationType } from './messages';
+import type { StaticRegistrationOptions, NotebookDocumentFilter, TextDocumentContentChangeEvent } from './protocol';
+/**
+ * Notebook specific client capabilities.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookDocumentSyncClientCapabilities = {
+    /**
+     * 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;
+    /**
+     * The client supports sending execution summary data per cell.
+     */
+    executionSummarySupport?: boolean;
+};
+/**
+ * A notebook cell kind.
+ *
+ * @since 3.17.0
+ */
+export declare namespace NotebookCellKind {
+    /**
+     * A markup-cell is formatted source that is used for display.
+     */
+    const Markup: 1;
+    /**
+     * A code-cell is source code.
+     */
+    const Code: 2;
+    function is(value: any): value is NotebookCellKind;
+}
+export declare type NotebookCellKind = 1 | 2;
+export declare type ExecutionSummary = {
+    /**
+     * A strict monotonically increasing value
+     * indicating the execution order of a cell
+     * inside a notebook.
+     */
+    executionOrder: uinteger;
+    /**
+     * Whether the execution was successful or
+     * not if known by the client.
+     */
+    success?: boolean;
+};
+export declare namespace ExecutionSummary {
+    function create(executionOrder: number, success?: boolean): ExecutionSummary;
+    function is(value: any): value is ExecutionSummary;
+    function equals(one: ExecutionSummary | undefined, other: ExecutionSummary | undefined): boolean;
+}
+/**
+ * A notebook cell.
+ *
+ * A cell's document URI must be unique across ALL notebook
+ * cells and can therefore be used to uniquely identify a
+ * notebook cell or the cell's text document.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookCell = {
+    /**
+     * The cell's kind
+     */
+    kind: NotebookCellKind;
+    /**
+     * The URI of the cell's text document
+     * content.
+     */
+    document: DocumentUri;
+    /**
+     * Additional metadata stored with the cell.
+     *
+     * Note: should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: LSPObject;
+    /**
+     * Additional execution summary information
+     * if supported by the client.
+     */
+    executionSummary?: ExecutionSummary;
+};
+export declare namespace NotebookCell {
+    function create(kind: NotebookCellKind, document: DocumentUri): NotebookCell;
+    function is(value: any): value is NotebookCell;
+    function diff(one: NotebookCell, two: NotebookCell): Set<keyof NotebookCell>;
+}
+/**
+ * A notebook document.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookDocument = {
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+    /**
+     * The type of the notebook.
+     */
+    notebookType: string;
+    /**
+     * The version number of this document (it will increase after each
+     * change, including undo/redo).
+     */
+    version: integer;
+    /**
+     * Additional metadata stored with the notebook
+     * document.
+     *
+     * Note: should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: LSPObject;
+    /**
+     * The cells of a notebook.
+     */
+    cells: NotebookCell[];
+};
+export declare namespace NotebookDocument {
+    function create(uri: URI, notebookType: string, version: integer, cells: NotebookCell[]): NotebookDocument;
+    function is(value: any): value is NotebookDocument;
+}
+/**
+ * A literal to identify a notebook document in the client.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookDocumentIdentifier = {
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+};
+/**
+ * A versioned notebook document identifier.
+ *
+ * @since 3.17.0
+ */
+export declare type VersionedNotebookDocumentIdentifier = {
+    /**
+     * The version number of this notebook document.
+     */
+    version: integer;
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+};
+/**
+ * Options specific to a notebook plus its cells
+ * to be synced to the server.
+ *
+ * If a selector provide a notebook document
+ * filter but no cell selector all cells of a
+ * matching notebook document will be synced.
+ *
+ * If a selector provides no notebook document
+ * filter but only a cell selector all notebook
+ * document that contain at least one matching
+ * cell will be synced.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookDocumentSyncOptions = {
+    /**
+     * The notebooks to be synced
+     */
+    notebookSelector: ({
+        /**
+         * The notebook to be synced If a string
+         * value is provided it matches against the
+         * notebook type. '*' matches every notebook.
+         */
+        notebook: string | NotebookDocumentFilter;
+        /**
+         * The cells of the matching notebook to be synced.
+         */
+        cells?: {
+            language: string;
+        }[];
+    } | {
+        /**
+         * The notebook to be synced If a string
+         * value is provided it matches against the
+         * notebook type. '*' matches every notebook.
+         */
+        notebook?: string | NotebookDocumentFilter;
+        /**
+         * The cells of the matching notebook to be synced.
+         */
+        cells: {
+            language: string;
+        }[];
+    })[];
+    /**
+     * Whether save notification should be forwarded to
+     * the server. Will only be honored if mode === `notebook`.
+     */
+    save?: boolean;
+};
+/**
+ * Registration options specific to a notebook.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookDocumentSyncRegistrationOptions = NotebookDocumentSyncOptions & StaticRegistrationOptions;
+export declare namespace NotebookDocumentSyncRegistrationType {
+    const method: 'notebookDocument/sync';
+    const type: RegistrationType<NotebookDocumentSyncRegistrationOptions>;
+}
+/**
+ * The params sent in a open notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export declare type DidOpenNotebookDocumentParams = {
+    /**
+     * The notebook document that got opened.
+     */
+    notebookDocument: NotebookDocument;
+    /**
+     * The text documents that represent the content
+     * of a notebook cell.
+     */
+    cellTextDocuments: TextDocumentItem[];
+};
+/**
+ * A notification sent when a notebook opens.
+ *
+ * @since 3.17.0
+ */
+export declare namespace DidOpenNotebookDocumentNotification {
+    const method: 'notebookDocument/didOpen';
+    const type: ProtocolNotificationType<DidOpenNotebookDocumentParams, void>;
+}
+/**
+ * A change describing how to move a `NotebookCell`
+ * array from state S to S'.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookCellArrayChange = {
+    /**
+     * The start oftest of the cell that changed.
+     */
+    start: uinteger;
+    /**
+     * The deleted cells
+     */
+    deleteCount: uinteger;
+    /**
+     * The new cells, if any
+     */
+    cells?: NotebookCell[];
+};
+export declare namespace NotebookCellArrayChange {
+    function is(value: any): value is NotebookCellArrayChange;
+    function create(start: uinteger, deleteCount: uinteger, cells?: NotebookCell[]): NotebookCellArrayChange;
+}
+/**
+ * A change event for a notebook document.
+ *
+ * @since 3.17.0
+ */
+export declare type NotebookDocumentChangeEvent = {
+    /**
+     * The changed meta data if any.
+     *
+     * Note: should always be an object literal (e.g. LSPObject)
+     */
+    metadata?: LSPObject;
+    /**
+     * Changes to cells
+     */
+    cells?: {
+        /**
+         * Changes to the cell structure to add or
+         * remove cells.
+         */
+        structure?: {
+            /**
+             * The change to the cell array.
+             */
+            array: NotebookCellArrayChange;
+            /**
+             * Additional opened cell text documents.
+             */
+            didOpen?: TextDocumentItem[];
+            /**
+             * Additional closed cell text documents.
+             */
+            didClose?: TextDocumentIdentifier[];
+        };
+        /**
+         * Changes to notebook cells properties like its
+         * kind, execution summary or metadata.
+         */
+        data?: NotebookCell[];
+        /**
+         * Changes to the text content of notebook cells.
+         */
+        textContent?: {
+            document: VersionedTextDocumentIdentifier;
+            changes: TextDocumentContentChangeEvent[];
+        }[];
+    };
+};
+/**
+ * The params sent in a change notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export declare type DidChangeNotebookDocumentParams = {
+    /**
+     * The notebook document that did change. The version number points
+     * to the version after all provided changes have been applied. If
+     * only the text document content of a cell changes the notebook version
+     * doesn't necessarily have to change.
+     */
+    notebookDocument: VersionedNotebookDocumentIdentifier;
+    /**
+     * The actual changes to the notebook document.
+     *
+     * The changes describe single state changes to the notebook document.
+     * So if there are two changes c1 (at array index 0) and c2 (at array
+     * index 1) for a notebook in state S then c1 moves the notebook from
+     * S to S' and c2 from S' to S''. So c1 is computed on the state S and
+     * c2 is computed on the state S'.
+     *
+     * To mirror the content of a notebook using change events use the following approach:
+     * - start with the same initial content
+     * - apply the 'notebookDocument/didChange' notifications in the order you receive them.
+     * - apply the `NotebookChangeEvent`s in a single notification in the order
+     *   you receive them.
+     */
+    change: NotebookDocumentChangeEvent;
+};
+export declare namespace DidChangeNotebookDocumentNotification {
+    const method: 'notebookDocument/didChange';
+    const type: ProtocolNotificationType<DidChangeNotebookDocumentParams, void>;
+}
+/**
+ * The params sent in a save notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export declare type DidSaveNotebookDocumentParams = {
+    /**
+     * The notebook document that got saved.
+     */
+    notebookDocument: NotebookDocumentIdentifier;
+};
+/**
+ * A notification sent when a notebook document is saved.
+ *
+ * @since 3.17.0
+ */
+export declare namespace DidSaveNotebookDocumentNotification {
+    const method: 'notebookDocument/didSave';
+    const type: ProtocolNotificationType<DidSaveNotebookDocumentParams, void>;
+}
+/**
+ * The params sent in a close notebook document notification.
+ *
+ * @since 3.17.0
+ */
+export declare type DidCloseNotebookDocumentParams = {
+    /**
+     * The notebook document that got closed.
+     */
+    notebookDocument: NotebookDocumentIdentifier;
+    /**
+     * The text documents that represent the content
+     * of a notebook cell that got closed.
+     */
+    cellTextDocuments: TextDocumentIdentifier[];
+};
+/**
+ * A notification sent when a notebook closes.
+ *
+ * @since 3.17.0
+ */
+export declare namespace DidCloseNotebookDocumentNotification {
+    const method: 'notebookDocument/didClose';
+    const type: ProtocolNotificationType<DidCloseNotebookDocumentParams, void>;
+}

package/lib/common/protocol.notebook.js

@@ -0,0 +1,206 @@
+"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 || (exports.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 || (exports.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 || (exports.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 || (exports.NotebookDocument = {}));
+var NotebookDocumentSyncRegistrationType;
+(function (NotebookDocumentSyncRegistrationType) {
+    NotebookDocumentSyncRegistrationType.method = 'notebookDocument/sync';
+    NotebookDocumentSyncRegistrationType.type = new messages_1.RegistrationType(NotebookDocumentSyncRegistrationType.method);
+})(NotebookDocumentSyncRegistrationType = exports.NotebookDocumentSyncRegistrationType || (exports.NotebookDocumentSyncRegistrationType = {}));
+/**
+ * A notification sent when a notebook opens.
+ *
+ * @since 3.17.0
+ */
+var DidOpenNotebookDocumentNotification;
+(function (DidOpenNotebookDocumentNotification) {
+    DidOpenNotebookDocumentNotification.method = 'notebookDocument/didOpen';
+    DidOpenNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification.method);
+})(DidOpenNotebookDocumentNotification = exports.DidOpenNotebookDocumentNotification || (exports.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 || (exports.NotebookCellArrayChange = {}));
+var DidChangeNotebookDocumentNotification;
+(function (DidChangeNotebookDocumentNotification) {
+    DidChangeNotebookDocumentNotification.method = 'notebookDocument/didChange';
+    DidChangeNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidChangeNotebookDocumentNotification.method);
+})(DidChangeNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification || (exports.DidChangeNotebookDocumentNotification = {}));
+/**
+ * A notification sent when a notebook document is saved.
+ *
+ * @since 3.17.0
+ */
+var DidSaveNotebookDocumentNotification;
+(function (DidSaveNotebookDocumentNotification) {
+    DidSaveNotebookDocumentNotification.method = 'notebookDocument/didSave';
+    DidSaveNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidSaveNotebookDocumentNotification.method);
+})(DidSaveNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification || (exports.DidSaveNotebookDocumentNotification = {}));
+/**
+ * A notification sent when a notebook closes.
+ *
+ * @since 3.17.0
+ */
+var DidCloseNotebookDocumentNotification;
+(function (DidCloseNotebookDocumentNotification) {
+    DidCloseNotebookDocumentNotification.method = 'notebookDocument/didClose';
+    DidCloseNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification.method);
+})(DidCloseNotebookDocumentNotification = exports.DidCloseNotebookDocumentNotification || (exports.DidCloseNotebookDocumentNotification = {}));
+//# sourceMappingURL=protocol.notebook.js.map

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

@@ -1,20 +1,6 @@
 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';
     /**
@@ -98,6 +84,7 @@ export interface WorkDoneProgressCreateParams {
  * reporting from the server.
  */
 export declare namespace WorkDoneProgressCreateRequest {
+    const method: 'window/workDoneProgress/create';
     const type: ProtocolRequestType<WorkDoneProgressCreateParams, void, never, void, void>;
     type HandlerSignature = RequestHandler<WorkDoneProgressCreateParams, void, void>;
 }
@@ -112,6 +99,7 @@ export interface WorkDoneProgressCancelParams {
  * initiated on the server side.
  */
 export declare namespace WorkDoneProgressCancelNotification {
+    const method: 'window/workDoneProgress/cancel';
     const type: ProtocolNotificationType<WorkDoneProgressCancelParams, void>;
     type HandlerSignature = NotificationHandler<WorkDoneProgressCancelParams>;
 }

package/lib/common/protocol.progress.js

@@ -21,7 +21,8 @@ var WorkDoneProgress;
  */
 var WorkDoneProgressCreateRequest;
 (function (WorkDoneProgressCreateRequest) {
-    WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType('window/workDoneProgress/create');
+    WorkDoneProgressCreateRequest.method = 'window/workDoneProgress/create';
+    WorkDoneProgressCreateRequest.type = new messages_1.ProtocolRequestType(WorkDoneProgressCreateRequest.method);
 })(WorkDoneProgressCreateRequest = exports.WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = {}));
 /**
  * The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress
@@ -29,6 +30,7 @@ var WorkDoneProgressCreateRequest;
  */
 var WorkDoneProgressCancelNotification;
 (function (WorkDoneProgressCancelNotification) {
-    WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType('window/workDoneProgress/cancel');
+    WorkDoneProgressCancelNotification.method = 'window/workDoneProgress/cancel';
+    WorkDoneProgressCancelNotification.type = new messages_1.ProtocolNotificationType(WorkDoneProgressCancelNotification.method);
 })(WorkDoneProgressCancelNotification = exports.WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = {}));
 //# sourceMappingURL=protocol.progress.js.map

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

@@ -1,7 +1,7 @@
 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';
+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`
@@ -35,6 +35,6 @@ export interface SelectionRangeParams extends WorkDoneProgressParams, PartialRes
  */
 export declare namespace SelectionRangeRequest {
     const method: 'textDocument/selectionRange';
-    const type: ProtocolRequestType<SelectionRangeParams, SelectionRange[] | null, SelectionRange[], any, SelectionRangeRegistrationOptions>;
+    const type: ProtocolRequestType<SelectionRangeParams, SelectionRange[] | null, SelectionRange[], void, SelectionRangeRegistrationOptions>;
     type HandlerSignature = RequestHandler<SelectionRangeParams, SelectionRange[] | null, void>;
 }