@depup/vscode-languageserver-protocol 3.18.3-depup.0

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

@@ -0,0 +1,241 @@
+import { TextDocumentIdentifier, Range, uinteger, SemanticTokensEdit, SemanticTokensLegend, SemanticTokens, SemanticTokensDelta } from 'vscode-languageserver-types';
+import { RequestHandler0, RequestHandler } from 'vscode-jsonrpc';
+import { MessageDirection, ProtocolRequestType, ProtocolRequestType0, RegistrationType, CM } from './messages';
+import { type PartialResultParams, type WorkDoneProgressParams, type WorkDoneProgressOptions, type TextDocumentRegistrationOptions, type 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.18.0
+ */
+export type ClientSemanticTokensRequestFullDelta = {
+    /**
+     * The client will send the `textDocument/semanticTokens/full/delta` request if
+     * the server provides a corresponding handler.
+     */
+    delta?: boolean;
+};
+/**
+ * @since 3.18.0
+ */
+export type ClientSemanticTokensRequestOptions = {
+    /**
+     * 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 | ClientSemanticTokensRequestFullDelta;
+};
+/**
+ * @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: ClientSemanticTokensRequestOptions;
+    /**
+     * 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;
+}
+/**
+ * Semantic tokens options to support deltas for full documents
+ *
+ * @since 3.18.0
+ */
+export type SemanticTokensFullDelta = {
+    /**
+     * The server supports deltas for full documents.
+     */
+    delta?: 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 | SemanticTokensFullDelta;
+}
+/**
+ * @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>;
+    const capabilities: CM<"textDocument.semanticTokens", "semanticTokensProvider">;
+}
+/**
+ * @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>;
+    const capabilities: CM<"textDocument.semanticTokens.requests.full.delta", "semanticTokensProvider.full.delta">;
+}
+/**
+ * @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>;
+    const capabilities: CM<"textDocument.semanticTokens.requests.range", "semanticTokensProvider.range">;
+}
+/**
+ * @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>;
+    const capabilities: CM<"workspace.semanticTokens.refreshSupport", undefined>;
+}

package/lib/common/protocol.semanticTokens.js

@@ -0,0 +1,61 @@
+"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.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = void 0;
+const messages_1 = require("./messages");
+//------- 'textDocument/semanticTokens' -----
+var TokenFormat;
+(function (TokenFormat) {
+    TokenFormat.Relative = 'relative';
+})(TokenFormat || (exports.TokenFormat = TokenFormat = {}));
+var SemanticTokensRegistrationType;
+(function (SemanticTokensRegistrationType) {
+    SemanticTokensRegistrationType.method = 'textDocument/semanticTokens';
+    SemanticTokensRegistrationType.type = new messages_1.RegistrationType(SemanticTokensRegistrationType.method);
+})(SemanticTokensRegistrationType || (exports.SemanticTokensRegistrationType = SemanticTokensRegistrationType = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensRequest;
+(function (SemanticTokensRequest) {
+    SemanticTokensRequest.method = 'textDocument/semanticTokens/full';
+    SemanticTokensRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method);
+    SemanticTokensRequest.registrationMethod = SemanticTokensRegistrationType.method;
+    SemanticTokensRequest.capabilities = messages_1.CM.create('textDocument.semanticTokens', 'semanticTokensProvider');
+})(SemanticTokensRequest || (exports.SemanticTokensRequest = SemanticTokensRequest = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensDeltaRequest;
+(function (SemanticTokensDeltaRequest) {
+    SemanticTokensDeltaRequest.method = 'textDocument/semanticTokens/full/delta';
+    SemanticTokensDeltaRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    SemanticTokensDeltaRequest.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest.method);
+    SemanticTokensDeltaRequest.registrationMethod = SemanticTokensRegistrationType.method;
+    SemanticTokensDeltaRequest.capabilities = messages_1.CM.create('textDocument.semanticTokens.requests.full.delta', 'semanticTokensProvider.full.delta');
+})(SemanticTokensDeltaRequest || (exports.SemanticTokensDeltaRequest = SemanticTokensDeltaRequest = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensRangeRequest;
+(function (SemanticTokensRangeRequest) {
+    SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range';
+    SemanticTokensRangeRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method);
+    SemanticTokensRangeRequest.registrationMethod = SemanticTokensRegistrationType.method;
+    SemanticTokensRangeRequest.capabilities = messages_1.CM.create('textDocument.semanticTokens.requests.range', 'semanticTokensProvider.range');
+})(SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = SemanticTokensRangeRequest = {}));
+/**
+ * @since 3.16.0
+ */
+var SemanticTokensRefreshRequest;
+(function (SemanticTokensRefreshRequest) {
+    SemanticTokensRefreshRequest.method = `workspace/semanticTokens/refresh`;
+    SemanticTokensRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    SemanticTokensRefreshRequest.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest.method);
+    SemanticTokensRefreshRequest.capabilities = messages_1.CM.create('workspace.semanticTokens.refreshSupport', undefined);
+})(SemanticTokensRefreshRequest || (exports.SemanticTokensRefreshRequest = SemanticTokensRefreshRequest = {}));

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

@@ -0,0 +1,73 @@
+import { CancellationToken, HandlerResult, RequestHandler } from 'vscode-jsonrpc';
+import { Range, URI } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType, CM } from './messages';
+/**
+ * Client capabilities for the showDocument request.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentClientCapabilities {
+    /**
+     * The client has support for the showDocument
+     * request.
+     */
+    support: boolean;
+}
+/**
+ * Params to show a resource in the UI.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentParams {
+    /**
+     * The uri to show.
+     */
+    uri: URI;
+    /**
+     * Indicates to show the resource in an external program.
+     * To show, for example, `https://code.visualstudio.com/`
+     * in the default WEB browser set `external` to `true`.
+     */
+    external?: boolean;
+    /**
+     * An optional property to indicate whether the editor
+     * showing the document should take focus or not.
+     * Clients might ignore this property if an external
+     * program is started.
+     */
+    takeFocus?: boolean;
+    /**
+     * An optional selection range if the document is a text
+     * document. Clients might ignore the property if an
+     * external program is started or the file is not a text
+     * file.
+     */
+    selection?: Range;
+}
+/**
+ * The result of a showDocument request.
+ *
+ * @since 3.16.0
+ */
+export interface ShowDocumentResult {
+    /**
+     * A boolean indicating if the show was successful.
+     */
+    success: boolean;
+}
+/**
+ * A request to show a document. This request might open an
+ * external program depending on the value of the URI to open.
+ * For example a request to open `https://code.visualstudio.com/`
+ * will very likely open the URI in a WEB browser.
+ *
+ * @since 3.16.0
+*/
+export declare namespace ShowDocumentRequest {
+    const method: 'window/showDocument';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ShowDocumentParams, ShowDocumentResult, void, void, void>;
+    type HandlerSignature = RequestHandler<ShowDocumentParams, ShowDocumentResult, void>;
+    type MiddlewareSignature = (params: ShowDocumentParams, token: CancellationToken, next: HandlerSignature) => HandlerResult<ShowDocumentResult, void>;
+    const capabilities: CM<"window.showDocument.support", undefined>;
+}

package/lib/common/protocol.showDocument.js

@@ -0,0 +1,23 @@
+"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.ShowDocumentRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to show a document. This request might open an
+ * external program depending on the value of the URI to open.
+ * For example a request to open `https://code.visualstudio.com/`
+ * will very likely open the URI in a WEB browser.
+ *
+ * @since 3.16.0
+*/
+var ShowDocumentRequest;
+(function (ShowDocumentRequest) {
+    ShowDocumentRequest.method = 'window/showDocument';
+    ShowDocumentRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    ShowDocumentRequest.type = new messages_1.ProtocolRequestType(ShowDocumentRequest.method);
+    ShowDocumentRequest.capabilities = messages_1.CM.create('window.showDocument.support', undefined);
+})(ShowDocumentRequest || (exports.ShowDocumentRequest = ShowDocumentRequest = {}));

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

@@ -0,0 +1,93 @@
+import type { DocumentUri } from 'vscode-languageserver-types';
+import type { RequestHandler } from 'vscode-jsonrpc';
+import { MessageDirection, ProtocolRequestType, CM } from './messages';
+import { type StaticRegistrationOptions } from './protocol';
+/**
+ * Client capabilities for a text document content provider.
+ *
+ * @since 3.18.0
+ */
+export type TextDocumentContentClientCapabilities = {
+    /**
+     * Text document content provider supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+};
+/**
+ * Text document content provider options.
+ *
+ * @since 3.18.0
+ */
+export type TextDocumentContentOptions = {
+    /**
+     * The schemes for which the server provides content.
+     */
+    schemes: string[];
+};
+/**
+ * Text document content provider registration options.
+ *
+ * @since 3.18.0
+ */
+export type TextDocumentContentRegistrationOptions = TextDocumentContentOptions & StaticRegistrationOptions;
+/**
+ * Parameters for the `workspace/textDocumentContent` request.
+ *
+ * @since 3.18.0
+ */
+export interface TextDocumentContentParams {
+    /**
+     * The uri of the text document.
+     */
+    uri: DocumentUri;
+}
+/**
+ * Result of the `workspace/textDocumentContent` request.
+ *
+ * @since 3.18.0
+ */
+export interface TextDocumentContentResult {
+    /**
+     * The text content of the text document. Please note, that the content of
+     * any subsequent open notifications for the text document might differ
+     * from the returned content due to whitespace and line ending
+     * normalizations done on the client
+     */
+    text: string;
+}
+/**
+ * The `workspace/textDocumentContent` request is sent from the client to the
+ * server to request the content of a text document.
+ *
+ * @since 3.18.0
+ */
+export declare namespace TextDocumentContentRequest {
+    const method: 'workspace/textDocumentContent';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<TextDocumentContentParams, TextDocumentContentResult, void, void, TextDocumentContentRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TextDocumentContentParams, TextDocumentContentResult, void>;
+    const capabilities: CM<"workspace.textDocumentContent", "workspace.textDocumentContent">;
+}
+/**
+ * Parameters for the `workspace/textDocumentContent/refresh` request.
+ *
+ * @since 3.18.0
+ */
+export interface TextDocumentContentRefreshParams {
+    /**
+     * The uri of the text document to refresh.
+     */
+    uri: DocumentUri;
+}
+/**
+ * The `workspace/textDocumentContent` request is sent from the server to the client to refresh
+ * the content of a specific text document.
+ *
+ * @since 3.18.0
+ */
+export declare namespace TextDocumentContentRefreshRequest {
+    const method: `workspace/textDocumentContent/refresh`;
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<TextDocumentContentRefreshParams, void, void, void, void>;
+    type HandlerSignature = RequestHandler<TextDocumentContentRefreshParams, void, void>;
+}

package/lib/common/protocol.textDocumentContent.js

@@ -0,0 +1,33 @@
+"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.TextDocumentContentRefreshRequest = exports.TextDocumentContentRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * The `workspace/textDocumentContent` request is sent from the client to the
+ * server to request the content of a text document.
+ *
+ * @since 3.18.0
+ */
+var TextDocumentContentRequest;
+(function (TextDocumentContentRequest) {
+    TextDocumentContentRequest.method = 'workspace/textDocumentContent';
+    TextDocumentContentRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    TextDocumentContentRequest.type = new messages_1.ProtocolRequestType(TextDocumentContentRequest.method);
+    TextDocumentContentRequest.capabilities = messages_1.CM.create('workspace.textDocumentContent', 'workspace.textDocumentContent');
+})(TextDocumentContentRequest || (exports.TextDocumentContentRequest = TextDocumentContentRequest = {}));
+/**
+ * The `workspace/textDocumentContent` request is sent from the server to the client to refresh
+ * the content of a specific text document.
+ *
+ * @since 3.18.0
+ */
+var TextDocumentContentRefreshRequest;
+(function (TextDocumentContentRefreshRequest) {
+    TextDocumentContentRefreshRequest.method = `workspace/textDocumentContent/refresh`;
+    TextDocumentContentRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    TextDocumentContentRefreshRequest.type = new messages_1.ProtocolRequestType(TextDocumentContentRefreshRequest.method);
+})(TextDocumentContentRefreshRequest || (exports.TextDocumentContentRefreshRequest = TextDocumentContentRefreshRequest = {}));

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

@@ -0,0 +1,39 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { Definition, DefinitionLink, LocationLink, Location } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType, CM } from './messages';
+import { type TextDocumentRegistrationOptions, type StaticRegistrationOptions, type TextDocumentPositionParams, type PartialResultParams, type WorkDoneProgressParams, type WorkDoneProgressOptions } from './protocol';
+/**
+ * Since 3.6.0
+ */
+export interface TypeDefinitionClientCapabilities {
+    /**
+     * Whether implementation supports dynamic registration. If this is set to `true`
+     * the client supports the new `TypeDefinitionRegistrationOptions` return value
+     * for the corresponding server capability as well.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports additional metadata in the form of definition links.
+     *
+     * Since 3.14.0
+     */
+    linkSupport?: boolean;
+}
+export interface TypeDefinitionOptions extends WorkDoneProgressOptions {
+}
+export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions {
+}
+export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPositionParams}
+ * the response is of type {@link Definition} or a Thenable that resolves to such.
+ */
+export declare namespace TypeDefinitionRequest {
+    const method: 'textDocument/typeDefinition';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<TypeDefinitionParams, Definition | LocationLink[] | null, Location[] | LocationLink[], void, TypeDefinitionRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TypeDefinitionParams, Definition | DefinitionLink[] | null, void>;
+    const capabilities: CM<"textDocument.typeDefinition", "typeDefinitionProvider">;
+}

package/lib/common/protocol.typeDefinition.js

@@ -0,0 +1,22 @@
+"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.TypeDefinitionRequest = void 0;
+const messages_1 = require("./messages");
+// @ts-ignore: to avoid inlining LocationLink as dynamic import
+let __noDynamicImport;
+/**
+ * A request to resolve the type definition locations of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPositionParams}
+ * the response is of type {@link Definition} or a Thenable that resolves to such.
+ */
+var TypeDefinitionRequest;
+(function (TypeDefinitionRequest) {
+    TypeDefinitionRequest.method = 'textDocument/typeDefinition';
+    TypeDefinitionRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    TypeDefinitionRequest.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest.method);
+    TypeDefinitionRequest.capabilities = messages_1.CM.create('textDocument.typeDefinition', 'typeDefinitionProvider');
+})(TypeDefinitionRequest || (exports.TypeDefinitionRequest = TypeDefinitionRequest = {}));

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

@@ -0,0 +1,84 @@
+import { RequestHandler } from 'vscode-jsonrpc';
+import { TypeHierarchyItem } from 'vscode-languageserver-types';
+import { MessageDirection, ProtocolRequestType, CM } from './messages';
+import { type TextDocumentRegistrationOptions, type StaticRegistrationOptions, type TextDocumentPositionParams, type PartialResultParams, type WorkDoneProgressParams, type WorkDoneProgressOptions } from './protocol';
+/**
+ * @since 3.17.0
+ */
+export type 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
+ */
+export type TypeHierarchyOptions = WorkDoneProgressOptions;
+/**
+ * Type hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.17.0
+ */
+export type TypeHierarchyRegistrationOptions = TextDocumentRegistrationOptions & TypeHierarchyOptions & StaticRegistrationOptions;
+/**
+ * The parameter of a `textDocument/prepareTypeHierarchy` request.
+ *
+ * @since 3.17.0
+ */
+export type TypeHierarchyPrepareParams = 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
+ */
+export declare namespace TypeHierarchyPrepareRequest {
+    const method: 'textDocument/prepareTypeHierarchy';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<TypeHierarchyPrepareParams, TypeHierarchyItem[] | null, never, void, TypeHierarchyRegistrationOptions>;
+    type HandlerSignature = RequestHandler<TypeHierarchyPrepareParams, TypeHierarchyItem[] | null, void>;
+    const capabilities: CM<"textDocument.typeHierarchy", "typeHierarchyProvider">;
+}
+/**
+ * The parameter of a `typeHierarchy/supertypes` request.
+ *
+ * @since 3.17.0
+ */
+export type TypeHierarchySupertypesParams = WorkDoneProgressParams & PartialResultParams & {
+    item: TypeHierarchyItem;
+};
+/**
+ * A request to resolve the supertypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0
+ */
+export declare namespace TypeHierarchySupertypesRequest {
+    const method: 'typeHierarchy/supertypes';
+    const messageDirection: MessageDirection;
+    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
+ */
+export type TypeHierarchySubtypesParams = WorkDoneProgressParams & PartialResultParams & {
+    item: TypeHierarchyItem;
+};
+/**
+ * A request to resolve the subtypes for a given `TypeHierarchyItem`.
+ *
+ * @since 3.17.0
+ */
+export declare namespace TypeHierarchySubtypesRequest {
+    const method: 'typeHierarchy/subtypes';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, TypeHierarchyItem[], void, void>;
+    type HandlerSignature = RequestHandler<TypeHierarchySubtypesParams, TypeHierarchyItem[] | null, void>;
+}