vscode-languageserver-protocol 3.16.0 → 3.17.0-next.12

package/lib/common/proposed.diagnostic.js

@@ -0,0 +1,72 @@
+"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.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const Is = require("./utils/is");
+const messages_1 = require("./messages");
+/**
+ * @since 3.17.0 - proposed state
+ */
+var DiagnosticServerCancellationData;
+(function (DiagnosticServerCancellationData) {
+    function is(value) {
+        const candidate = value;
+        return candidate && Is.boolean(candidate.retriggerRequest);
+    }
+    DiagnosticServerCancellationData.is = is;
+})(DiagnosticServerCancellationData = exports.DiagnosticServerCancellationData || (exports.DiagnosticServerCancellationData = {}));
+/**
+ * The document diagnostic report kinds.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var DocumentDiagnosticReportKind;
+(function (DocumentDiagnosticReportKind) {
+    /**
+     * A diagnostic report with a full
+     * set of problems.
+     */
+    DocumentDiagnosticReportKind["full"] = "full";
+    /**
+     * A report indicating that the last
+     * returned report is still accurate.
+     */
+    DocumentDiagnosticReportKind["unChanged"] = "unChanged";
+})(DocumentDiagnosticReportKind = exports.DocumentDiagnosticReportKind || (exports.DocumentDiagnosticReportKind = {}));
+/**
+ * The document diagnostic request definition.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var DocumentDiagnosticRequest;
+(function (DocumentDiagnosticRequest) {
+    DocumentDiagnosticRequest.method = 'textDocument/diagnostic';
+    DocumentDiagnosticRequest.type = new messages_1.ProtocolRequestType(DocumentDiagnosticRequest.method);
+    DocumentDiagnosticRequest.partialResult = new vscode_jsonrpc_1.ProgressType();
+})(DocumentDiagnosticRequest = exports.DocumentDiagnosticRequest || (exports.DocumentDiagnosticRequest = {}));
+/**
+ * The workspace diagnostic request definition.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var WorkspaceDiagnosticRequest;
+(function (WorkspaceDiagnosticRequest) {
+    WorkspaceDiagnosticRequest.method = 'workspace/diagnostic';
+    WorkspaceDiagnosticRequest.type = new messages_1.ProtocolRequestType(WorkspaceDiagnosticRequest.method);
+    WorkspaceDiagnosticRequest.partialResult = new vscode_jsonrpc_1.ProgressType();
+})(WorkspaceDiagnosticRequest = exports.WorkspaceDiagnosticRequest || (exports.WorkspaceDiagnosticRequest = {}));
+/**
+ * The diagnostic refresh request definition.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var DiagnosticRefreshRequest;
+(function (DiagnosticRefreshRequest) {
+    DiagnosticRefreshRequest.method = `workspace/diagnostic/refresh`;
+    DiagnosticRefreshRequest.type = new messages_1.ProtocolRequestType0(DiagnosticRefreshRequest.method);
+})(DiagnosticRefreshRequest = exports.DiagnosticRefreshRequest || (exports.DiagnosticRefreshRequest = {}));
+//# sourceMappingURL=proposed.diagnostic.js.map

package/lib/common/proposed.inlineValue.d.ts

@@ -0,0 +1,86 @@
+import { TextDocumentIdentifier, Range, InlineValue, InlineValuesContext } from 'vscode-languageserver-types';
+import { RequestHandler, RequestHandler0 } from 'vscode-jsonrpc';
+import { ProtocolRequestType, ProtocolRequestType0 } from './messages';
+import { TextDocumentRegistrationOptions, WorkDoneProgressOptions, StaticRegistrationOptions, WorkDoneProgressParams } from './protocol';
+/**
+ * Client capabilities specific to inline values.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface InlineValuesClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration for inline value providers.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * Client workspace capabilities specific to inline values.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface InlineValuesWorkspaceClientCapabilities {
+    /**
+     * 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
+     * inline values currently shown. It should be used with absolute care and is
+     * useful for situation where a server for example detect a project wide
+     * change that requires such a calculation.
+     */
+    refreshSupport?: boolean;
+}
+/**
+ * Inline values options used during static registration.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface InlineValuesOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Inline value options used during static or dynamic registration.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface InlineValuesRegistrationOptions extends InlineValuesOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+}
+/**
+ * A parameter literal used in inline values requests.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface InlineValuesParams extends WorkDoneProgressParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The visible document range for which inline values should be computed.
+     */
+    viewPort: Range;
+    /**
+     * Additional information about the context in which inline values were
+     * requested.
+     */
+    context: InlineValuesContext;
+}
+/**
+ * A request to provide inline values in a document. The request's parameter is of
+ * type [InlineValuesParams](#InlineValuesParams), the response is of type
+ * [InlineValue[]](#InlineValue[]) or a Thenable that resolves to such.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace InlineValuesRequest {
+    const method: 'textDocument/inlineValues';
+    const type: ProtocolRequestType<InlineValuesParams, InlineValue[] | null, InlineValue[], any, InlineValuesRegistrationOptions>;
+    type HandlerSignature = RequestHandler<InlineValuesParams, InlineValue[] | null, void>;
+}
+/**
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace InlineValuesRefreshRequest {
+    const method: `workspace/inlineValues/refresh`;
+    const type: ProtocolRequestType0<void, void, void, void>;
+    type HandlerSignature = RequestHandler0<void, void>;
+}

package/lib/common/proposed.inlineValue.js

@@ -0,0 +1,29 @@
+"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.InlineValuesRefreshRequest = exports.InlineValuesRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide inline values in a document. The request's parameter is of
+ * type [InlineValuesParams](#InlineValuesParams), the response is of type
+ * [InlineValue[]](#InlineValue[]) or a Thenable that resolves to such.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var InlineValuesRequest;
+(function (InlineValuesRequest) {
+    InlineValuesRequest.method = 'textDocument/inlineValues';
+    InlineValuesRequest.type = new messages_1.ProtocolRequestType(InlineValuesRequest.method);
+})(InlineValuesRequest = exports.InlineValuesRequest || (exports.InlineValuesRequest = {}));
+/**
+ * @since 3.17.0 - proposed state
+ */
+var InlineValuesRefreshRequest;
+(function (InlineValuesRefreshRequest) {
+    InlineValuesRefreshRequest.method = `workspace/inlineValues/refresh`;
+    InlineValuesRefreshRequest.type = new messages_1.ProtocolRequestType0(InlineValuesRefreshRequest.method);
+})(InlineValuesRefreshRequest = exports.InlineValuesRefreshRequest || (exports.InlineValuesRefreshRequest = {}));
+//# sourceMappingURL=proposed.inlineValue.js.map

package/lib/common/proposed.notebooks.d.ts

@@ -0,0 +1,254 @@
+import { URI, integer, DocumentUri, uinteger } from 'vscode-languageserver-types';
+import { ProtocolNotificationType, RegistrationType } from './messages';
+import { StaticRegistrationOptions, NotebookDocumentFilter } from './protocol';
+/**
+ * Notebook specific client capabilities.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface 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;
+}
+export interface $NotebookDocumentClientCapabilities {
+    notebookDocument?: {
+        synchronization: NotebookDocumentSyncClientCapabilities;
+    };
+}
+/**
+ * A notebook cell kind.
+ *
+ * @since 3.17.0 - proposed state
+ */
+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;
+/**
+ * A notebook cell.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface NotebookCell {
+    /**
+     * The cell's kind
+     */
+    kind: NotebookCellKind;
+    /**
+     * The cell's text represented as a text document.
+     * The document's content is synced using the
+     * existing text document sync notifications.
+     */
+    document: DocumentUri;
+}
+export declare namespace NotebookCell {
+    function create(kind: NotebookCellKind, document: DocumentUri): NotebookCell;
+    function is(value: any): value is NotebookCell;
+    function equal(one: NotebookCell, two: NotebookCell): boolean;
+}
+/**
+ * A change describing how to move a `NotebookCell`
+ * array from state S' to S''.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface NotebookCellChange {
+    /**
+     * 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 NotebookCellChange {
+    function is(value: any): value is NotebookCellChange;
+    function create(start: uinteger, deleteCount: uinteger, cells?: NotebookCell[]): NotebookCellChange;
+}
+/**
+ * A notebook document.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface 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;
+    /**
+     * 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 - proposed state
+ */
+export interface NotebookDocumentIdentifier {
+    /**
+     * The notebook document's uri.
+     */
+    uri: URI;
+}
+/**
+ * A versioned notebook document identifier.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface 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 provider 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 - proposed state
+ */
+export declare type NotebookDocumentOptions = {
+    notebookDocumentSelector?: ({
+        /** The notebook documents to be synced */
+        notebookDocumentFilter: NotebookDocumentFilter;
+        /** The cells of the matching notebook to be synced */
+        cellSelector?: {
+            language: string;
+        }[];
+    } | {
+        /** The notebook documents to be synced */
+        notebookDocumentFilter?: NotebookDocumentFilter;
+        /** The cells of the matching notebook to be synced */
+        cellSelector: {
+            language: string;
+        }[];
+    })[];
+};
+export interface $NotebookDocumentServerCapabilities {
+    notebookDocumentSync?: NotebookDocumentOptions | NotebookDocumentRegistrationOptions;
+}
+/**
+ * Registration options specific to a notebook.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare type NotebookDocumentRegistrationOptions = NotebookDocumentOptions & StaticRegistrationOptions;
+export declare namespace NotebookDocumentSyncRegistrationType {
+    const method: 'notebookDocument/sync';
+    const type: RegistrationType<NotebookDocumentRegistrationOptions>;
+}
+/**
+ * The params sent in a open notebook document notification.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface DidOpenNotebookDocumentParams {
+    /**
+     * The notebook document that got opened.
+     */
+    notebookDocument: NotebookDocument;
+}
+/**
+ * A notification sent when a notebook opens.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace DidOpenNotebookDocumentNotification {
+    const method: 'notebookDocument/didOpen';
+    const type: ProtocolNotificationType<DidOpenNotebookDocumentParams, void>;
+}
+export interface NotebookDocumentChangeEvent {
+    cells: NotebookCellChange;
+}
+export interface DidChangeNotebookDocumentParams {
+    /**
+     * The notebook document that did change. The version number points
+     * to the version after all provided changes have been applied.
+     */
+    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.
+     */
+    changes: NotebookDocumentChangeEvent[];
+}
+export declare namespace DidChangeNotebookDocumentNotification {
+    const method: 'notebookDocument/didChange';
+    const type: ProtocolNotificationType<DidChangeNotebookDocumentParams, void>;
+}
+/**
+ * The params sent in a close notebook document notification.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface DidCloseNotebookDocumentParams {
+    /**
+     * The notebook document that got opened.
+     */
+    notebookDocument: NotebookDocumentIdentifier;
+}
+/**
+ * A notification sent when a notebook closes.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace DidCloseNotebookDocumentNotification {
+    const method: 'notebookDocument/didClose';
+    const type: ProtocolNotificationType<DidCloseNotebookDocumentParams, void>;
+}

package/lib/common/proposed.notebooks.js

@@ -0,0 +1,105 @@
+"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.DidChangeNotebookDocumentNotification = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCellChange = exports.NotebookCell = 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 - proposed state
+ */
+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 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);
+    }
+    NotebookCell.is = is;
+    function equal(one, two) {
+        return one.kind === two.kind && one.document === two.document;
+    }
+    NotebookCell.equal = equal;
+})(NotebookCell = exports.NotebookCell || (exports.NotebookCell = {}));
+var NotebookCellChange;
+(function (NotebookCellChange) {
+    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));
+    }
+    NotebookCellChange.is = is;
+    function create(start, deleteCount, cells) {
+        const result = { start, deleteCount };
+        if (cells !== undefined) {
+            result.cells = cells;
+        }
+        return result;
+    }
+    NotebookCellChange.create = create;
+})(NotebookCellChange = exports.NotebookCellChange || (exports.NotebookCellChange = {}));
+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 - proposed state
+ */
+var DidOpenNotebookDocumentNotification;
+(function (DidOpenNotebookDocumentNotification) {
+    DidOpenNotebookDocumentNotification.method = 'notebookDocument/didOpen';
+    DidOpenNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification.method);
+})(DidOpenNotebookDocumentNotification = exports.DidOpenNotebookDocumentNotification || (exports.DidOpenNotebookDocumentNotification = {}));
+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 closes.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var DidCloseNotebookDocumentNotification;
+(function (DidCloseNotebookDocumentNotification) {
+    DidCloseNotebookDocumentNotification.method = 'notebookDocument/didClose';
+    DidCloseNotebookDocumentNotification.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification.method);
+})(DidCloseNotebookDocumentNotification = exports.DidCloseNotebookDocumentNotification || (exports.DidCloseNotebookDocumentNotification = {}));
+//# sourceMappingURL=proposed.notebooks.js.map

package/lib/common/proposed.typeHierarchy.d.ts

@@ -0,0 +1,83 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TypeHierarchyItem } from 'vscode-languageserver-types';
+import { ProtocolRequestType } from './messages';
+import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * @since 3.17.0 - proposed state
+ */
+export interface TypeHierarchyClientCapabilities {
+    /**
+     * 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;
+}
+/**
+ * Type hierarchy options used during static registration.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface TypeHierarchyOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Type hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface TypeHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, TypeHierarchyOptions, StaticRegistrationOptions {
+}
+/**
+ * The parameter of a `textDocument/prepareTypeHierarchy` request.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface TypeHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+/**
+ * A request to result a `TypeHierarchyItem` in a document at a given position.
+ * Can be used as an input to a subtypes or supertypes type hierarchy.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace TypeHierarchyPrepareRequest {
+    const method: 'textDocument/prepareTypeHierarchy';
+    const type: ProtocolRequestType<TypeHierarchyPrepareParams, TypeHierarchyItem[] | null, never, void, TypeHierarchyRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TypeHierarchyPrepareParams, TypeHierarchyItem[] | null, void>;
+}
+/**
+ * The parameter of a `typeHierarchy/supertypes` request.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface TypeHierarchySupertypesParams extends WorkDoneProgressParams, PartialResultParams {
+    item: TypeHierarchyItem;
+}
+/**
+ * A request to resolve the supertypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace TypeHierarchySupertypesRequest {
+    const method: 'typeHierarchy/supertypes';
+    const type: ProtocolRequestType<TypeHierarchySupertypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void, void>;
+    type HandlerSignature = RequestHandler<TypeHierarchySupertypesParams, TypeHierarchyItem[] | null, void>;
+}
+/**
+ * The parameter of a `typeHierarchy/subtypes` request.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export interface TypeHierarchySubtypesParams extends WorkDoneProgressParams, PartialResultParams {
+    item: TypeHierarchyItem;
+}
+/**
+ * A request to resolve the subtypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0 - proposed state
+ */
+export declare namespace TypeHierarchySubtypesRequest {
+    const method: 'typeHierarchy/subtypes';
+    const type: ProtocolRequestType<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void, void>;
+    type HandlerSignature = RequestHandler<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, void>;
+}

package/lib/common/proposed.typeHierarchy.js

@@ -0,0 +1,40 @@
+"use strict";
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) TypeFox, Microsoft and others. 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.TypeHierarchySubtypesRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchyPrepareRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to result a `TypeHierarchyItem` in a document at a given position.
+ * Can be used as an input to a subtypes or supertypes type hierarchy.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var TypeHierarchyPrepareRequest;
+(function (TypeHierarchyPrepareRequest) {
+    TypeHierarchyPrepareRequest.method = 'textDocument/prepareTypeHierarchy';
+    TypeHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(TypeHierarchyPrepareRequest.method);
+})(TypeHierarchyPrepareRequest = exports.TypeHierarchyPrepareRequest || (exports.TypeHierarchyPrepareRequest = {}));
+/**
+ * A request to resolve the supertypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var TypeHierarchySupertypesRequest;
+(function (TypeHierarchySupertypesRequest) {
+    TypeHierarchySupertypesRequest.method = 'typeHierarchy/supertypes';
+    TypeHierarchySupertypesRequest.type = new messages_1.ProtocolRequestType(TypeHierarchySupertypesRequest.method);
+})(TypeHierarchySupertypesRequest = exports.TypeHierarchySupertypesRequest || (exports.TypeHierarchySupertypesRequest = {}));
+/**
+ * A request to resolve the subtypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0 - proposed state
+ */
+var TypeHierarchySubtypesRequest;
+(function (TypeHierarchySubtypesRequest) {
+    TypeHierarchySubtypesRequest.method = 'typeHierarchy/subtypes';
+    TypeHierarchySubtypesRequest.type = new messages_1.ProtocolRequestType(TypeHierarchySubtypesRequest.method);
+})(TypeHierarchySubtypesRequest = exports.TypeHierarchySubtypesRequest || (exports.TypeHierarchySubtypesRequest = {}));
+//# sourceMappingURL=proposed.typeHierarchy.js.map

package/lib/common/protocol.callHierarchy.js

@@ -1,6 +1,6 @@
 "use strict";
 /* --------------------------------------------------------------------------------------------
- * Copyright (c) TypeFox and others. All rights reserved.
+ * Copyright (c) TypeFox, Microsoft and others. All rights reserved.
  * Licensed under the MIT License. See License.txt in the project root for license information.
  * ------------------------------------------------------------------------------------------ */
 Object.defineProperty(exports, "__esModule", { value: true });