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

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

@@ -0,0 +1,117 @@
+import { RequestHandler, RequestHandler0 } from 'vscode-jsonrpc';
+import { Range, TextDocumentIdentifier, InlayHint } from 'vscode-languageserver-types';
+import { CM, MessageDirection, ProtocolRequestType, ProtocolRequestType0 } from './messages';
+import { type StaticRegistrationOptions, type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type WorkDoneProgressParams } from './protocol';
+/**
+ * @since 3.18.0
+ */
+export type ClientInlayHintResolveOptions = {
+    /**
+     * The properties that a client can resolve lazily.
+     */
+    properties: string[];
+};
+/**
+ * Inlay hint client capabilities.
+ *
+ * @since 3.17.0
+ */
+export type InlayHintClientCapabilities = {
+    /**
+     * Whether inlay hints support dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Indicates which properties a client can resolve lazily on an inlay
+     * hint.
+     */
+    resolveSupport?: ClientInlayHintResolveOptions;
+};
+/**
+ * Client workspace capabilities specific to inlay hints.
+ *
+ * @since 3.17.0
+ */
+export type InlayHintWorkspaceClientCapabilities = {
+    /**
+     * 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
+     * inlay hints 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;
+};
+/**
+ * Inlay hint options used during static registration.
+ *
+ * @since 3.17.0
+ */
+export type InlayHintOptions = WorkDoneProgressOptions & {
+    /**
+     * The server provides support to resolve additional
+     * information for an inlay hint item.
+     */
+    resolveProvider?: boolean;
+};
+/**
+ * Inlay hint options used during static or dynamic registration.
+ *
+ * @since 3.17.0
+ */
+export type InlayHintRegistrationOptions = InlayHintOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions;
+/**
+ * A parameter literal used in inlay hint requests.
+ *
+ * @since 3.17.0
+ */
+export type InlayHintParams = WorkDoneProgressParams & {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The document range for which inlay hints should be computed.
+     */
+    range: Range;
+};
+/**
+ * A request to provide inlay hints in a document. The request's parameter is of
+ * type {@link InlayHintsParams}, the response is of type
+ * {@link InlayHint InlayHint[]} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+export declare namespace InlayHintRequest {
+    const method: 'textDocument/inlayHint';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<InlayHintParams, InlayHint[] | null, InlayHint[], void, InlayHintRegistrationOptions>;
+    type HandlerSignature = RequestHandler<InlayHintParams, InlayHint[] | null, void>;
+    const capabilities: CM<"textDocument.inlayHint", "inlayHintProvider">;
+}
+/**
+ * A request to resolve additional properties for an inlay hint.
+ * The request's parameter is of type {@link InlayHint}, the response is
+ * of type {@link InlayHint} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+export declare namespace InlayHintResolveRequest {
+    const method: 'inlayHint/resolve';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<InlayHint, InlayHint, never, void, void>;
+    type HandlerSignature = RequestHandler<InlayHint, InlayHint, void>;
+    const capabilities: CM<"textDocument.inlayHint.resolveSupport", "inlayHintProvider.resolveProvider">;
+}
+/**
+ * @since 3.17.0
+ */
+export declare namespace InlayHintRefreshRequest {
+    const method: `workspace/inlayHint/refresh`;
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType0<void, void, void, void>;
+    type HandlerSignature = RequestHandler0<void, void>;
+    const capabilities: CM<"workspace.inlayHint.refreshSupport", undefined>;
+}

package/lib/common/protocol.inlayHint.js

@@ -0,0 +1,46 @@
+"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.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide inlay hints in a document. The request's parameter is of
+ * type {@link InlayHintsParams}, the response is of type
+ * {@link InlayHint InlayHint[]} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+var InlayHintRequest;
+(function (InlayHintRequest) {
+    InlayHintRequest.method = 'textDocument/inlayHint';
+    InlayHintRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    InlayHintRequest.type = new messages_1.ProtocolRequestType(InlayHintRequest.method);
+    InlayHintRequest.capabilities = messages_1.CM.create('textDocument.inlayHint', 'inlayHintProvider');
+})(InlayHintRequest || (exports.InlayHintRequest = InlayHintRequest = {}));
+/**
+ * A request to resolve additional properties for an inlay hint.
+ * The request's parameter is of type {@link InlayHint}, the response is
+ * of type {@link InlayHint} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+var InlayHintResolveRequest;
+(function (InlayHintResolveRequest) {
+    InlayHintResolveRequest.method = 'inlayHint/resolve';
+    InlayHintResolveRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    InlayHintResolveRequest.type = new messages_1.ProtocolRequestType(InlayHintResolveRequest.method);
+    InlayHintResolveRequest.capabilities = messages_1.CM.create('textDocument.inlayHint.resolveSupport', 'inlayHintProvider.resolveProvider');
+})(InlayHintResolveRequest || (exports.InlayHintResolveRequest = InlayHintResolveRequest = {}));
+/**
+ * @since 3.17.0
+ */
+var InlayHintRefreshRequest;
+(function (InlayHintRefreshRequest) {
+    InlayHintRefreshRequest.method = `workspace/inlayHint/refresh`;
+    InlayHintRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    InlayHintRefreshRequest.type = new messages_1.ProtocolRequestType0(InlayHintRefreshRequest.method);
+    InlayHintRefreshRequest.capabilities = messages_1.CM.create('workspace.inlayHint.refreshSupport', undefined);
+})(InlayHintRefreshRequest || (exports.InlayHintRefreshRequest = InlayHintRefreshRequest = {}));

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

@@ -0,0 +1,53 @@
+import { InlineCompletionItem, InlineCompletionContext, InlineCompletionList } from 'vscode-languageserver-types';
+import { RequestHandler } from 'vscode-jsonrpc';
+import { CM, MessageDirection, ProtocolRequestType } from './messages';
+import { type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type StaticRegistrationOptions, type WorkDoneProgressParams, type TextDocumentPositionParams } from './protocol';
+/**
+ * Client capabilities specific to inline completions.
+ *
+ * @since 3.18.0
+ */
+export type InlineCompletionClientCapabilities = {
+    /**
+     * Whether implementation supports dynamic registration for inline completion providers.
+     */
+    dynamicRegistration?: boolean;
+};
+/**
+ * Inline completion options used during static registration.
+ *
+ * @since 3.18.0
+ */
+export type InlineCompletionOptions = WorkDoneProgressOptions;
+/**
+ * Inline completion options used during static or dynamic registration.
+ *
+ * @since 3.18.0
+ */
+export type InlineCompletionRegistrationOptions = InlineCompletionOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions;
+/**
+ * A parameter literal used in inline completion requests.
+ *
+ * @since 3.18.0
+ */
+export type InlineCompletionParams = WorkDoneProgressParams & TextDocumentPositionParams & {
+    /**
+     * Additional information about the context in which inline completions were
+     * requested.
+     */
+    context: InlineCompletionContext;
+};
+/**
+ * A request to provide inline completions in a document. The request's parameter is of
+ * type {@link InlineCompletionParams}, the response is of type
+ * {@link InlineCompletion InlineCompletion[]} or a Thenable that resolves to such.
+ *
+ * @since 3.18.0
+ */
+export declare namespace InlineCompletionRequest {
+    const method: 'textDocument/inlineCompletion';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<InlineCompletionParams, InlineCompletionList | InlineCompletionItem[] | null, InlineCompletionItem[], void, InlineCompletionRegistrationOptions>;
+    type HandlerSignature = RequestHandler<InlineCompletionParams, InlineCompletionList | InlineCompletionItem[] | null, void>;
+    const capabilities: CM<"textDocument.inlineCompletion", "inlineCompletionProvider">;
+}

package/lib/common/protocol.inlineCompletion.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.InlineCompletionRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide inline completions in a document. The request's parameter is of
+ * type {@link InlineCompletionParams}, the response is of type
+ * {@link InlineCompletion InlineCompletion[]} or a Thenable that resolves to such.
+ *
+ * @since 3.18.0
+ */
+var InlineCompletionRequest;
+(function (InlineCompletionRequest) {
+    InlineCompletionRequest.method = 'textDocument/inlineCompletion';
+    InlineCompletionRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    InlineCompletionRequest.type = new messages_1.ProtocolRequestType(InlineCompletionRequest.method);
+    InlineCompletionRequest.capabilities = messages_1.CM.create('textDocument.inlineCompletion', 'inlineCompletionProvider');
+})(InlineCompletionRequest || (exports.InlineCompletionRequest = InlineCompletionRequest = {}));

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

@@ -0,0 +1,88 @@
+import { TextDocumentIdentifier, Range, InlineValue, InlineValueContext } from 'vscode-languageserver-types';
+import { RequestHandler, RequestHandler0 } from 'vscode-jsonrpc';
+import { CM, MessageDirection, ProtocolRequestType, ProtocolRequestType0 } from './messages';
+import { type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type StaticRegistrationOptions, type WorkDoneProgressParams } from './protocol';
+/**
+ * Client capabilities specific to inline values.
+ *
+ * @since 3.17.0
+ */
+export type InlineValueClientCapabilities = {
+    /**
+     * Whether implementation supports dynamic registration for inline value providers.
+     */
+    dynamicRegistration?: boolean;
+};
+/**
+ * Client workspace capabilities specific to inline values.
+ *
+ * @since 3.17.0
+ */
+export type InlineValueWorkspaceClientCapabilities = {
+    /**
+     * 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 detects a project wide
+     * change that requires such a calculation.
+     */
+    refreshSupport?: boolean;
+};
+/**
+ * Inline value options used during static registration.
+ *
+ * @since 3.17.0
+ */
+export type InlineValueOptions = WorkDoneProgressOptions;
+/**
+ * Inline value options used during static or dynamic registration.
+ *
+ * @since 3.17.0
+ */
+export type InlineValueRegistrationOptions = InlineValueOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions;
+/**
+ * A parameter literal used in inline value requests.
+ *
+ * @since 3.17.0
+ */
+export type InlineValueParams = WorkDoneProgressParams & {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The document range for which inline values information will be returned.
+     */
+    range: Range;
+    /**
+     * Additional information about the context in which inline values information was
+     * requested.
+     */
+    context: InlineValueContext;
+};
+/**
+ * A request to provide inline values in a document. The request's parameter is of
+ * type {@link InlineValueParams}, the response is of type
+ * {@link InlineValue InlineValue[]} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+export declare namespace InlineValueRequest {
+    const method: 'textDocument/inlineValue';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<InlineValueParams, InlineValue[] | null, InlineValue[], void, InlineValueRegistrationOptions>;
+    type HandlerSignature = RequestHandler<InlineValueParams, InlineValue[] | null, void>;
+    const capabilities: CM<"textDocument.inlineValue", "inlineValueProvider">;
+}
+/**
+ * @since 3.17.0
+ */
+export declare namespace InlineValueRefreshRequest {
+    const method: `workspace/inlineValue/refresh`;
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType0<void, void, void, void>;
+    type HandlerSignature = RequestHandler0<void, void>;
+    const capabilities: CM<"workspace.inlineValue.refreshSupport", undefined>;
+}

package/lib/common/protocol.inlineValue.js

@@ -0,0 +1,32 @@
+"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.InlineValueRefreshRequest = exports.InlineValueRequest = void 0;
+const messages_1 = require("./messages");
+/**
+ * A request to provide inline values in a document. The request's parameter is of
+ * type {@link InlineValueParams}, the response is of type
+ * {@link InlineValue InlineValue[]} or a Thenable that resolves to such.
+ *
+ * @since 3.17.0
+ */
+var InlineValueRequest;
+(function (InlineValueRequest) {
+    InlineValueRequest.method = 'textDocument/inlineValue';
+    InlineValueRequest.messageDirection = messages_1.MessageDirection.clientToServer;
+    InlineValueRequest.type = new messages_1.ProtocolRequestType(InlineValueRequest.method);
+    InlineValueRequest.capabilities = messages_1.CM.create('textDocument.inlineValue', 'inlineValueProvider');
+})(InlineValueRequest || (exports.InlineValueRequest = InlineValueRequest = {}));
+/**
+ * @since 3.17.0
+ */
+var InlineValueRefreshRequest;
+(function (InlineValueRefreshRequest) {
+    InlineValueRefreshRequest.method = `workspace/inlineValue/refresh`;
+    InlineValueRefreshRequest.messageDirection = messages_1.MessageDirection.serverToClient;
+    InlineValueRefreshRequest.type = new messages_1.ProtocolRequestType0(InlineValueRefreshRequest.method);
+    InlineValueRefreshRequest.capabilities = messages_1.CM.create('workspace.inlineValue.refreshSupport', undefined);
+})(InlineValueRefreshRequest || (exports.InlineValueRefreshRequest = InlineValueRefreshRequest = {}));