vscode-languageserver-protocol 3.15.1 → 3.15.2

package/lib/main.d.ts

@@ -4,6 +4,7 @@ export * from 'vscode-languageserver-types';
 export * from './protocol';
 export { FoldingRangeParams as FoldingRangeRequestParam } from './protocol';
 import * as callHierarchy from './protocol.callHierarchy.proposed';
+import * as st from './protocol.sematicTokens.proposed';
 export declare namespace Proposed {
     type CallHierarchyClientCapabilities = callHierarchy.CallHierarchyClientCapabilities;
     type CallHierarchyItem = callHierarchy.CallHierarchyItem;
@@ -21,17 +22,43 @@ export declare namespace Proposed {
     type CallHierarchyIncomingCallsParams = callHierarchy.CallHierarchyIncomingCallsParams;
     namespace CallHierarchyIncomingCallsRequest {
         const method: "callHierarchy/incomingCalls";
-        const type: typeof callHierarchy.CallHierarchyIncomingCallsRequest;
-        const resultType: ProgressType<callHierarchy.CallHierarchyIncomingCall[]>;
+        const type: import("./messages").ProtocolRequestType<callHierarchy.CallHierarchyIncomingCallsParams, callHierarchy.CallHierarchyIncomingCall[] | null, callHierarchy.CallHierarchyIncomingCall[], void, void>;
         type HandlerSignature = callHierarchy.CallHierarchyIncomingCallsRequest.HandlerSignature;
     }
     type CallHierarchyOutgoingCallsParams = callHierarchy.CallHierarchyOutgoingCallsParams;
     namespace CallHierarchyOutgoingCallsRequest {
         const method: "callHierarchy/outgoingCalls";
-        const type: typeof callHierarchy.CallHierarchyOutgoingCallsRequest;
-        const resultType: ProgressType<callHierarchy.CallHierarchyOutgoingCall[]>;
+        const type: import("./messages").ProtocolRequestType<callHierarchy.CallHierarchyOutgoingCallsParams, callHierarchy.CallHierarchyOutgoingCall[] | null, callHierarchy.CallHierarchyOutgoingCall[], void, void>;
         type HandlerSignature = callHierarchy.CallHierarchyOutgoingCallsRequest.HandlerSignature;
     }
+    const SemanticTokenTypes: typeof st.SemanticTokenTypes;
+    const SemanticTokenModifiers: typeof st.SemanticTokenModifiers;
+    type SemanticTokensLegend = st.SemanticTokensLegend;
+    type SemanticTokens = st.SemanticTokens;
+    const SemanticTokens: typeof st.SemanticTokens;
+    type SemanticTokensPartialResult = st.SemanticTokensPartialResult;
+    type SemanticTokensEdit = st.SemanticTokensEdit;
+    type SemanticTokensEdits = st.SemanticTokensEdits;
+    type SemanticTokensEditsPartialResult = st.SemanticTokensEditsPartialResult;
+    type SemanticTokensClientCapabilities = st.SemanticTokensClientCapabilities;
+    type SemanticTokensOptions = st.SemanticTokensOptions;
+    type SemanticTokensRegistrationOptions = st.SemanticTokensRegistrationOptions;
+    type SemanticTokensServerCapabilities = st.SemanticTokensServerCapabilities;
+    type SemanticTokensParams = st.SemanticTokensParams;
+    namespace SemanticTokensRequest {
+        const method: "textDocument/semanticTokens";
+        const type: import("./messages").ProtocolRequestType<st.SemanticTokensParams, st.SemanticTokens | null, st.SemanticTokensPartialResult, void, st.SemanticTokensRegistrationOptions>;
+    }
+    type SemanticTokensEditsParams = st.SemanticTokensEditsParams;
+    namespace SemanticTokensEditsRequest {
+        const method: "textDocument/semanticTokens/edits";
+        const type: import("./messages").ProtocolRequestType<st.SemanticTokensEditsParams, st.SemanticTokens | st.SemanticTokensEdits | null, st.SemanticTokensPartialResult | st.SemanticTokensEditsPartialResult, void, st.SemanticTokensRegistrationOptions>;
+    }
+    type SemanticTokensRangeParams = st.SemanticTokensRangeParams;
+    namespace SemanticTokensRangeRequest {
+        const method: "textDocument/semanticTokens/range";
+        const type: import("./messages").ProtocolRequestType<st.SemanticTokensRangeParams, st.SemanticTokens | null, st.SemanticTokensPartialResult, void, void>;
+    }
 }
 export interface ProtocolConnection {
     /**

package/lib/main.js

@@ -39,6 +39,7 @@ exports.ProgressType = vscode_jsonrpc_1.ProgressType;
 __export(require("vscode-languageserver-types"));
 __export(require("./protocol"));
 const callHierarchy = require("./protocol.callHierarchy.proposed");
+const st = require("./protocol.sematicTokens.proposed");
 var Proposed;
 (function (Proposed) {
     let CallHierarchyPrepareRequest;
@@ -49,15 +50,31 @@ var Proposed;
     let CallHierarchyIncomingCallsRequest;
     (function (CallHierarchyIncomingCallsRequest) {
         CallHierarchyIncomingCallsRequest.method = callHierarchy.CallHierarchyIncomingCallsRequest.method;
-        CallHierarchyIncomingCallsRequest.type = callHierarchy.CallHierarchyIncomingCallsRequest;
-        CallHierarchyIncomingCallsRequest.resultType = callHierarchy.CallHierarchyIncomingCallsRequest.resultType;
+        CallHierarchyIncomingCallsRequest.type = callHierarchy.CallHierarchyIncomingCallsRequest.type;
     })(CallHierarchyIncomingCallsRequest = Proposed.CallHierarchyIncomingCallsRequest || (Proposed.CallHierarchyIncomingCallsRequest = {}));
     let CallHierarchyOutgoingCallsRequest;
     (function (CallHierarchyOutgoingCallsRequest) {
         CallHierarchyOutgoingCallsRequest.method = callHierarchy.CallHierarchyOutgoingCallsRequest.method;
-        CallHierarchyOutgoingCallsRequest.type = callHierarchy.CallHierarchyOutgoingCallsRequest;
-        CallHierarchyOutgoingCallsRequest.resultType = callHierarchy.CallHierarchyOutgoingCallsRequest.resultType;
+        CallHierarchyOutgoingCallsRequest.type = callHierarchy.CallHierarchyOutgoingCallsRequest.type;
     })(CallHierarchyOutgoingCallsRequest = Proposed.CallHierarchyOutgoingCallsRequest || (Proposed.CallHierarchyOutgoingCallsRequest = {}));
+    Proposed.SemanticTokenTypes = st.SemanticTokenTypes;
+    Proposed.SemanticTokenModifiers = st.SemanticTokenModifiers;
+    Proposed.SemanticTokens = st.SemanticTokens;
+    let SemanticTokensRequest;
+    (function (SemanticTokensRequest) {
+        SemanticTokensRequest.method = st.SemanticTokensRequest.method;
+        SemanticTokensRequest.type = st.SemanticTokensRequest.type;
+    })(SemanticTokensRequest = Proposed.SemanticTokensRequest || (Proposed.SemanticTokensRequest = {}));
+    let SemanticTokensEditsRequest;
+    (function (SemanticTokensEditsRequest) {
+        SemanticTokensEditsRequest.method = st.SemanticTokensEditsRequest.method;
+        SemanticTokensEditsRequest.type = st.SemanticTokensEditsRequest.type;
+    })(SemanticTokensEditsRequest = Proposed.SemanticTokensEditsRequest || (Proposed.SemanticTokensEditsRequest = {}));
+    let SemanticTokensRangeRequest;
+    (function (SemanticTokensRangeRequest) {
+        SemanticTokensRangeRequest.method = st.SemanticTokensRangeRequest.method;
+        SemanticTokensRangeRequest.type = st.SemanticTokensRangeRequest.type;
+    })(SemanticTokensRangeRequest = Proposed.SemanticTokensRangeRequest || (Proposed.SemanticTokensRangeRequest = {}));
 })(Proposed = exports.Proposed || (exports.Proposed = {}));
 function createProtocolConnection(reader, writer, logger, strategy) {
     return vscode_jsonrpc_1.createMessageConnection(reader, writer, logger, strategy);

package/lib/protocol.callHierarchy.proposed.d.ts

@@ -1,7 +1,13 @@
-import { RequestHandler, ProgressType } from 'vscode-jsonrpc';
+import { RequestHandler } from 'vscode-jsonrpc';
 import { SymbolKind, SymbolTag, Range, DocumentUri } from 'vscode-languageserver-types';
 import { ProtocolRequestType } from './messages';
 import { TextDocumentRegistrationOptions, StaticRegistrationOptions, TextDocumentPositionParams, PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions } from './protocol';
+/**
+ * Represents programming constructs like functions or constructors in the context
+ * of call hierarchy.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyItem {
     /**
      * The name of this item.
@@ -35,6 +41,8 @@ export interface CallHierarchyItem {
 }
 /**
  * Represents an incoming call, e.g. a caller of a method or constructor.
+ *
+ * @since 3.16.0 - Proposed state
  */
 export interface CallHierarchyIncomingCall {
     /**
@@ -49,6 +57,8 @@ export interface CallHierarchyIncomingCall {
 }
 /**
  * Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc.
+ *
+ * @since 3.16.0 - Proposed state
  */
 export interface CallHierarchyOutgoingCall {
     /**
@@ -62,13 +72,18 @@ export interface CallHierarchyOutgoingCall {
      */
     fromRanges: Range[];
 }
+/**
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyClientCapabilities {
     /**
      * The text document client capabilities
      */
     textDocument?: {
         /**
-         * Capabilities specific to the `textDocument/callHierarchy`
+         * Capabilities specific to the `textDocument/callHierarchy`.
+         *
+         * @since 3.16.0 - Proposed state
          */
         callHierarchy?: {
             /**
@@ -80,10 +95,25 @@ export interface CallHierarchyClientCapabilities {
         };
     };
 }
+/**
+ * Call hierarchy options used during static registration.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyOptions extends WorkDoneProgressOptions {
 }
+/**
+ * Call hierarchy options used during static or dynamic registration.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, CallHierarchyOptions {
 }
+/**
+ * The call hierarchy server capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyServerCapabilities {
     /**
      * The server provides Call Hierarchy support.
@@ -92,31 +122,55 @@ export interface CallHierarchyServerCapabilities {
 }
 /**
  * The parameter of a `textDocument/prepareCallHierarchy` request.
+ *
+ * @since 3.16.0 - Proposed state
  */
 export interface CallHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams {
 }
+/**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to a incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export declare namespace CallHierarchyPrepareRequest {
     const method: 'textDocument/prepareCallHierarchy';
     const type: ProtocolRequestType<CallHierarchyPrepareParams, CallHierarchyItem[] | null, never, void, CallHierarchyRegistrationOptions>;
     type HandlerSignature = RequestHandler<CallHierarchyPrepareParams, CallHierarchyItem[] | null, void>;
 }
+/**
+ * The parameter of a `callHierarchy/incomingCalls` request.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyIncomingCallsParams extends WorkDoneProgressParams, PartialResultParams {
     item: CallHierarchyItem;
 }
+/**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export declare namespace CallHierarchyIncomingCallsRequest {
     const method: 'callHierarchy/incomingCalls';
     const type: ProtocolRequestType<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, CallHierarchyIncomingCall[], void, void>;
-    /** @deprecated Use CallHierarchyIncomingCallsRequest.type */
-    const resultType: ProgressType<CallHierarchyIncomingCall[]>;
     type HandlerSignature = RequestHandler<CallHierarchyIncomingCallsParams, CallHierarchyIncomingCall[] | null, void>;
 }
+/**
+ * The parameter of a `callHierarchy/outgoingCalls` request.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export interface CallHierarchyOutgoingCallsParams extends WorkDoneProgressParams, PartialResultParams {
     item: CallHierarchyItem;
 }
+/**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 export declare namespace CallHierarchyOutgoingCallsRequest {
     const method: 'callHierarchy/outgoingCalls';
     const type: ProtocolRequestType<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, CallHierarchyOutgoingCall[], void, void>;
-    /** @deprecated Use CallHierarchyOutgoingCallsRequest.type */
-    const resultType: ProgressType<CallHierarchyOutgoingCall[]>;
     type HandlerSignature = RequestHandler<CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCall[] | null, void>;
 }

package/lib/protocol.callHierarchy.proposed.js

@@ -4,24 +4,35 @@
  * ------------------------------------------------------------------------------------------ */
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-const vscode_jsonrpc_1 = require("vscode-jsonrpc");
 const messages_1 = require("./messages");
+/**
+ * A request to result a `CallHierarchyItem` in a document at a given position.
+ * Can be used as an input to a incoming or outgoing call hierarchy.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 var CallHierarchyPrepareRequest;
 (function (CallHierarchyPrepareRequest) {
     CallHierarchyPrepareRequest.method = 'textDocument/prepareCallHierarchy';
     CallHierarchyPrepareRequest.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest.method);
 })(CallHierarchyPrepareRequest = exports.CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = {}));
+/**
+ * A request to resolve the incoming calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 var CallHierarchyIncomingCallsRequest;
 (function (CallHierarchyIncomingCallsRequest) {
     CallHierarchyIncomingCallsRequest.method = 'callHierarchy/incomingCalls';
     CallHierarchyIncomingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest.method);
-    /** @deprecated Use CallHierarchyIncomingCallsRequest.type */
-    CallHierarchyIncomingCallsRequest.resultType = new vscode_jsonrpc_1.ProgressType();
 })(CallHierarchyIncomingCallsRequest = exports.CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = {}));
+/**
+ * A request to resolve the outgoing calls for a given `CallHierarchyItem`.
+ *
+ * @since 3.16.0 - Proposed state
+ */
 var CallHierarchyOutgoingCallsRequest;
 (function (CallHierarchyOutgoingCallsRequest) {
     CallHierarchyOutgoingCallsRequest.method = 'callHierarchy/outgoingCalls';
     CallHierarchyOutgoingCallsRequest.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest.method);
-    /** @deprecated Use CallHierarchyOutgoingCallsRequest.type */
-    CallHierarchyOutgoingCallsRequest.resultType = new vscode_jsonrpc_1.ProgressType();
 })(CallHierarchyOutgoingCallsRequest = exports.CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = {}));

package/lib/protocol.sematicTokens.proposed.d.ts

@@ -0,0 +1,240 @@
+import { TextDocumentIdentifier, Range } from 'vscode-languageserver-types';
+import { PartialResultParams, WorkDoneProgressParams, WorkDoneProgressOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions } from './protocol';
+import { ProtocolRequestType } from './messages';
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+export declare enum SemanticTokenTypes {
+    comment = "comment",
+    keyword = "keyword",
+    string = "string",
+    number = "number",
+    regexp = "regexp",
+    operator = "operator",
+    namespace = "namespace",
+    type = "type",
+    struct = "struct",
+    class = "class",
+    interface = "interface",
+    enum = "enum",
+    typeParameter = "typeParameter",
+    function = "function",
+    member = "member",
+    property = "property",
+    marco = "marco",
+    variable = "variable",
+    parameter = "parameter",
+    label = "label"
+}
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+export declare enum SemanticTokenModifiers {
+    documentation = "documentation",
+    declaration = "declaration",
+    definition = "definition",
+    reference = "reference",
+    static = "static",
+    abstract = "abstract",
+    deprecated = "deprected",
+    async = "async",
+    volatile = "volatile",
+    final = "final"
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensLegend {
+    /**
+     * The token types a server uses.
+     */
+    tokenTypes: string[];
+    /**
+     * The token modifiers a server uses.
+     */
+    tokenModifiers: string[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokens {
+    /**
+     * An optional result id. If provided and clients support delta updating
+     * the client will include the result id in the next semantic token request.
+     * A server can then instead of computing all sematic tokens again simply
+     * send a delta.
+     */
+    resultId?: string;
+    /**
+     * The actual tokens. For a detailed description about how the data is
+     * structured pls see
+     * https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71
+     */
+    data: number[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokens {
+    function is(value: any): value is SemanticTokens;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensPartialResult {
+    data: number[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEdit {
+    start: number;
+    deleteCount: number;
+    data?: number[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEdits {
+    readonly resultId?: string;
+    /**
+     * For a detailed description how these edits are structured pls see
+     * https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L131
+     */
+    edits: SemanticTokensEdit[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEditsPartialResult {
+    edits: SemanticTokensEdit[];
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to the `textDocument/semanticTokens`
+         *
+         * @since 3.16.0 - Proposed state
+         */
+        semanticTokens?: {
+            /**
+             * 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 token types know by the client.
+             */
+            tokenTypes: string[];
+            /**
+             * The token modifiers know by the client.
+             */
+            tokenModifiers: string[];
+        };
+    };
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensOptions extends WorkDoneProgressOptions {
+    /**
+     * The legend used by the server
+     */
+    legend: SemanticTokensLegend;
+    /**
+     * Server supports providing semantic tokens for a sepcific range
+     * of a document.
+     */
+    rangeProvider?: boolean;
+    /**
+     * Server supports providing semantic tokens for a full document.
+     */
+    documentProvider?: boolean | {
+        /**
+         * The server supports deltas for full documents.
+         */
+        edits?: boolean;
+    };
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions {
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensServerCapabilities {
+    semanticTokensProvider: SemanticTokensOptions | SemanticTokensRegistrationOptions;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokensRequest {
+    const method: 'textDocument/semanticTokens';
+    const type: ProtocolRequestType<SemanticTokensParams, SemanticTokens | null, SemanticTokensPartialResult, void, SemanticTokensRegistrationOptions>;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export interface SemanticTokensEditsParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The previous result id.
+     */
+    previousResultId: string;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+export declare namespace SemanticTokensEditsRequest {
+    const method: 'textDocument/semanticTokens/edits';
+    const type: ProtocolRequestType<SemanticTokensEditsParams, SemanticTokens | SemanticTokensEdits | null, SemanticTokensPartialResult | SemanticTokensEditsPartialResult, void, SemanticTokensRegistrationOptions>;
+}
+/**
+ * @since 3.16.0 - Proposed state
+ */
+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 - Proposed state
+ */
+export declare namespace SemanticTokensRangeRequest {
+    const method: 'textDocument/semanticTokens/range';
+    const type: ProtocolRequestType<SemanticTokensRangeParams, SemanticTokens | null, SemanticTokensPartialResult, void, void>;
+}

package/lib/protocol.sematicTokens.proposed.js

@@ -0,0 +1,93 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_1 = require("./messages");
+/**
+ * A set of predefined token types. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokenTypes;
+(function (SemanticTokenTypes) {
+    SemanticTokenTypes["comment"] = "comment";
+    SemanticTokenTypes["keyword"] = "keyword";
+    SemanticTokenTypes["string"] = "string";
+    SemanticTokenTypes["number"] = "number";
+    SemanticTokenTypes["regexp"] = "regexp";
+    SemanticTokenTypes["operator"] = "operator";
+    SemanticTokenTypes["namespace"] = "namespace";
+    SemanticTokenTypes["type"] = "type";
+    SemanticTokenTypes["struct"] = "struct";
+    SemanticTokenTypes["class"] = "class";
+    SemanticTokenTypes["interface"] = "interface";
+    SemanticTokenTypes["enum"] = "enum";
+    SemanticTokenTypes["typeParameter"] = "typeParameter";
+    SemanticTokenTypes["function"] = "function";
+    SemanticTokenTypes["member"] = "member";
+    SemanticTokenTypes["property"] = "property";
+    SemanticTokenTypes["marco"] = "marco";
+    SemanticTokenTypes["variable"] = "variable";
+    SemanticTokenTypes["parameter"] = "parameter";
+    SemanticTokenTypes["label"] = "label";
+})(SemanticTokenTypes = exports.SemanticTokenTypes || (exports.SemanticTokenTypes = {}));
+/**
+ * A set of predefined token modifiers. This set is not fixed
+ * an clients can specify additional token types via the
+ * corresponding client capabilities.
+ *
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokenModifiers;
+(function (SemanticTokenModifiers) {
+    SemanticTokenModifiers["documentation"] = "documentation";
+    SemanticTokenModifiers["declaration"] = "declaration";
+    SemanticTokenModifiers["definition"] = "definition";
+    SemanticTokenModifiers["reference"] = "reference";
+    SemanticTokenModifiers["static"] = "static";
+    SemanticTokenModifiers["abstract"] = "abstract";
+    SemanticTokenModifiers["deprecated"] = "deprected";
+    SemanticTokenModifiers["async"] = "async";
+    SemanticTokenModifiers["volatile"] = "volatile";
+    SemanticTokenModifiers["final"] = "final";
+})(SemanticTokenModifiers = exports.SemanticTokenModifiers || (exports.SemanticTokenModifiers = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokens;
+(function (SemanticTokens) {
+    function is(value) {
+        const candidate = value;
+        return candidate !== undefined && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&
+            Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');
+    }
+    SemanticTokens.is = is;
+})(SemanticTokens = exports.SemanticTokens || (exports.SemanticTokens = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokensRequest;
+(function (SemanticTokensRequest) {
+    SemanticTokensRequest.method = 'textDocument/semanticTokens';
+    SemanticTokensRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRequest.method);
+})(SemanticTokensRequest = exports.SemanticTokensRequest || (exports.SemanticTokensRequest = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokensEditsRequest;
+(function (SemanticTokensEditsRequest) {
+    SemanticTokensEditsRequest.method = 'textDocument/semanticTokens/edits';
+    SemanticTokensEditsRequest.type = new messages_1.ProtocolRequestType(SemanticTokensEditsRequest.method);
+})(SemanticTokensEditsRequest = exports.SemanticTokensEditsRequest || (exports.SemanticTokensEditsRequest = {}));
+/**
+ * @since 3.16.0 - Proposed state
+ */
+var SemanticTokensRangeRequest;
+(function (SemanticTokensRangeRequest) {
+    SemanticTokensRangeRequest.method = 'textDocument/semanticTokens/range';
+    SemanticTokensRangeRequest.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest.method);
+})(SemanticTokensRangeRequest = exports.SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = {}));

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "vscode-languageserver-protocol",
 	"description": "VSCode Language Server Protocol implementation",
-	"version": "3.15.1",
+	"version": "3.15.2",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
 	"repository": {
@@ -16,7 +16,7 @@
 	"typings": "./lib/main",
 	"dependencies": {
 		"vscode-jsonrpc": "^5.0.1",
-		"vscode-languageserver-types": "3.15.0"
+		"vscode-languageserver-types": "3.15.1"
 	},
 	"scripts": {
 		"prepublishOnly": "npm run clean && npm run compile && npm test",