@kontor/kontor-sdk 1.0.0-alpha.43 → 1.0.0-alpha.44

package/site/node_modules/@kontor/kontor-sdk/site/node_modules/vscode-languageserver-protocol/lib/common/protocol.d.ts

@@ -0,0 +1,3252 @@
+import { ProgressToken, RequestHandler, TraceValues } from 'vscode-jsonrpc';
+import { MessageDirection, ProtocolRequestType, ProtocolRequestType0, ProtocolNotificationType, ProtocolNotificationType0 } from './messages';
+import { Position, Range, Location, LocationLink, Diagnostic, Command, TextEdit, WorkspaceEdit, DocumentUri, TextDocumentIdentifier, VersionedTextDocumentIdentifier, TextDocumentItem, CompletionItem, CompletionList, Hover, SignatureHelp, Definition, ReferenceContext, DocumentHighlight, SymbolInformation, CodeLens, CodeActionContext, FormattingOptions, DocumentLink, MarkupKind, SymbolKind, CompletionItemKind, CodeAction, CodeActionKind, DocumentSymbol, CompletionItemTag, DiagnosticTag, SymbolTag, uinteger, integer, InsertTextMode, LSPAny, WorkspaceSymbol, URI, WorkspaceFolder } from 'vscode-languageserver-types';
+import { ImplementationRequest, ImplementationClientCapabilities, ImplementationOptions, ImplementationRegistrationOptions, ImplementationParams } from './protocol.implementation';
+import { TypeDefinitionRequest, TypeDefinitionClientCapabilities, TypeDefinitionOptions, TypeDefinitionRegistrationOptions, TypeDefinitionParams } from './protocol.typeDefinition';
+import { WorkspaceFoldersRequest, DidChangeWorkspaceFoldersNotification, DidChangeWorkspaceFoldersParams, WorkspaceFoldersChangeEvent, WorkspaceFoldersInitializeParams, WorkspaceFoldersServerCapabilities } from './protocol.workspaceFolder';
+import { ConfigurationRequest, ConfigurationParams, ConfigurationItem } from './protocol.configuration';
+import { DocumentColorRequest, ColorPresentationRequest, DocumentColorOptions, DocumentColorParams, ColorPresentationParams, DocumentColorClientCapabilities, DocumentColorRegistrationOptions } from './protocol.colorProvider';
+import { FoldingRangeClientCapabilities, FoldingRangeOptions, FoldingRangeRequest, FoldingRangeParams, FoldingRangeRegistrationOptions, FoldingRangeRefreshRequest, FoldingRangeWorkspaceClientCapabilities } from './protocol.foldingRange';
+import { DeclarationClientCapabilities, DeclarationRequest, DeclarationOptions, DeclarationRegistrationOptions, DeclarationParams } from './protocol.declaration';
+import { SelectionRangeClientCapabilities, SelectionRangeOptions, SelectionRangeRequest, SelectionRangeParams, SelectionRangeRegistrationOptions } from './protocol.selectionRange';
+import { WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd, WorkDoneProgress, WorkDoneProgressCreateParams, WorkDoneProgressCreateRequest, WorkDoneProgressCancelParams, WorkDoneProgressCancelNotification } from './protocol.progress';
+import { CallHierarchyClientCapabilities, CallHierarchyOptions, CallHierarchyRegistrationOptions, CallHierarchyIncomingCallsParams, CallHierarchyIncomingCallsRequest, CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCallsRequest, CallHierarchyPrepareParams, CallHierarchyPrepareRequest } from './protocol.callHierarchy';
+import { SemanticTokensPartialResult, SemanticTokensDeltaPartialResult, TokenFormat, SemanticTokensClientCapabilities, SemanticTokensOptions, SemanticTokensRegistrationOptions, SemanticTokensParams, SemanticTokensRequest, SemanticTokensDeltaParams, SemanticTokensDeltaRequest, SemanticTokensRangeParams, SemanticTokensRangeRequest, SemanticTokensRefreshRequest, SemanticTokensWorkspaceClientCapabilities, SemanticTokensRegistrationType } from './protocol.semanticTokens';
+import { ShowDocumentParams, ShowDocumentResult, ShowDocumentRequest, ShowDocumentClientCapabilities } from './protocol.showDocument';
+import { LinkedEditingRangeClientCapabilities, LinkedEditingRanges, LinkedEditingRangeOptions, LinkedEditingRangeParams, LinkedEditingRangeRegistrationOptions, LinkedEditingRangeRequest } from './protocol.linkedEditingRange';
+import { FileOperationOptions, FileOperationClientCapabilities, FileOperationRegistrationOptions, FileOperationPatternOptions, FileOperationPatternKind, DidCreateFilesNotification, CreateFilesParams, FileCreate, WillCreateFilesRequest, DidRenameFilesNotification, RenameFilesParams, FileRename, WillRenameFilesRequest, DidDeleteFilesNotification, DeleteFilesParams, FileDelete, WillDeleteFilesRequest } from './protocol.fileOperations';
+import { UniquenessLevel, MonikerKind, Moniker, MonikerClientCapabilities, MonikerOptions, MonikerRegistrationOptions, MonikerParams, MonikerRequest } from './protocol.moniker';
+import { TypeHierarchyClientCapabilities, TypeHierarchyOptions, TypeHierarchyRegistrationOptions, TypeHierarchyPrepareParams, TypeHierarchyPrepareRequest, TypeHierarchySubtypesParams, TypeHierarchySubtypesRequest, TypeHierarchySupertypesParams, TypeHierarchySupertypesRequest } from './protocol.typeHierarchy';
+import { InlineValueClientCapabilities, InlineValueOptions, InlineValueRegistrationOptions, InlineValueWorkspaceClientCapabilities, InlineValueParams, InlineValueRequest, InlineValueRefreshRequest } from './protocol.inlineValue';
+import { InlayHintClientCapabilities, InlayHintOptions, InlayHintRegistrationOptions, InlayHintWorkspaceClientCapabilities, InlayHintParams, InlayHintRequest, InlayHintResolveRequest, InlayHintRefreshRequest } from './protocol.inlayHint';
+import { DiagnosticClientCapabilities, DiagnosticOptions, DiagnosticRegistrationOptions, DiagnosticServerCancellationData, DocumentDiagnosticParams, DocumentDiagnosticReportKind, FullDocumentDiagnosticReport, RelatedFullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport, RelatedUnchangedDocumentDiagnosticReport, DocumentDiagnosticReport, DocumentDiagnosticReportPartialResult, DocumentDiagnosticRequest, PreviousResultId, WorkspaceDiagnosticParams, WorkspaceFullDocumentDiagnosticReport, WorkspaceUnchangedDocumentDiagnosticReport, WorkspaceDocumentDiagnosticReport, WorkspaceDiagnosticReport, WorkspaceDiagnosticReportPartialResult, WorkspaceDiagnosticRequest, DiagnosticRefreshRequest, DiagnosticWorkspaceClientCapabilities } from './protocol.diagnostic';
+import { NotebookDocumentSyncClientCapabilities, NotebookCellKind, ExecutionSummary, NotebookCell, NotebookDocument, NotebookDocumentIdentifier, VersionedNotebookDocumentIdentifier, NotebookDocumentSyncOptions, NotebookDocumentSyncRegistrationOptions, NotebookDocumentSyncRegistrationType, DidOpenNotebookDocumentParams, DidOpenNotebookDocumentNotification, NotebookCellArrayChange, NotebookDocumentChangeEvent, DidChangeNotebookDocumentParams, DidChangeNotebookDocumentNotification, DidSaveNotebookDocumentParams, DidSaveNotebookDocumentNotification, DidCloseNotebookDocumentParams, DidCloseNotebookDocumentNotification } from './protocol.notebook';
+import { InlineCompletionClientCapabilities, InlineCompletionOptions, InlineCompletionParams, InlineCompletionRegistrationOptions, InlineCompletionRequest } from './protocol.inlineCompletion';
+/**
+ * A document filter denotes a document by different properties like
+ * the {@link TextDocument.languageId language}, the {@link Uri.scheme scheme} of
+ * its resource, or a glob-pattern that is applied to the {@link TextDocument.fileName path}.
+ *
+ * Glob patterns can have the following syntax:
+ * - `*` to match one or more characters in a path segment
+ * - `?` to match on one character in a path segment
+ * - `**` to match any number of path segments, including none
+ * - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+ * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+ * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+ *
+ * @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }`
+ * @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }`
+ *
+ * @since 3.17.0
+ */
+export type TextDocumentFilter = {
+    /** A language id, like `typescript`. */
+    language: string;
+    /** A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. */
+    scheme?: string;
+    /** A glob pattern, like **​/*.{ts,js}. See TextDocumentFilter for examples. */
+    pattern?: string;
+} | {
+    /** A language id, like `typescript`. */
+    language?: string;
+    /** A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. */
+    scheme: string;
+    /** A glob pattern, like **​/*.{ts,js}. See TextDocumentFilter for examples. */
+    pattern?: string;
+} | {
+    /** A language id, like `typescript`. */
+    language?: string;
+    /** A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. */
+    scheme?: string;
+    /** A glob pattern, like **​/*.{ts,js}. See TextDocumentFilter for examples. */
+    pattern: string;
+};
+/**
+ * The TextDocumentFilter namespace provides helper functions to work with
+ * {@link TextDocumentFilter} literals.
+ *
+ * @since 3.17.0
+ */
+export declare namespace TextDocumentFilter {
+    function is(value: any): value is TextDocumentFilter;
+}
+/**
+ * A notebook document filter denotes a notebook document by
+ * different properties. The properties will be match
+ * against the notebook's URI (same as with documents)
+ *
+ * @since 3.17.0
+ */
+export type NotebookDocumentFilter = {
+    /** The type of the enclosing notebook. */
+    notebookType: string;
+    /** A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. */
+    scheme?: string;
+    /** A glob pattern. */
+    pattern?: string;
+} | {
+    /** The type of the enclosing notebook. */
+    notebookType?: string;
+    /** A Uri {@link Uri.scheme scheme}, like `file` or `untitled`.*/
+    scheme: string;
+    /** A glob pattern. */
+    pattern?: string;
+} | {
+    /** The type of the enclosing notebook. */
+    notebookType?: string;
+    /** A Uri {@link Uri.scheme scheme}, like `file` or `untitled`. */
+    scheme?: string;
+    /** A glob pattern. */
+    pattern: string;
+};
+/**
+ * The NotebookDocumentFilter namespace provides helper functions to work with
+ * {@link NotebookDocumentFilter} literals.
+ *
+ * @since 3.17.0
+ */
+export declare namespace NotebookDocumentFilter {
+    function is(value: any): value is NotebookDocumentFilter;
+}
+/**
+ * A notebook cell text document filter denotes a cell text
+ * document by different properties.
+ *
+ * @since 3.17.0
+ */
+export type NotebookCellTextDocumentFilter = {
+    /**
+     * A filter that matches against the notebook
+     * containing the notebook cell. If a string
+     * value is provided it matches against the
+     * notebook type. '*' matches every notebook.
+     */
+    notebook: string | NotebookDocumentFilter;
+    /**
+     * A language id like `python`.
+     *
+     * Will be matched against the language id of the
+     * notebook cell document. '*' matches every language.
+     */
+    language?: string;
+};
+/**
+ * The NotebookCellTextDocumentFilter namespace provides helper functions to work with
+ * {@link NotebookCellTextDocumentFilter} literals.
+ *
+ * @since 3.17.0
+ */
+export declare namespace NotebookCellTextDocumentFilter {
+    function is(value: any): value is NotebookCellTextDocumentFilter;
+}
+/**
+ * A document filter describes a top level text document or
+ * a notebook cell document.
+ *
+ * @since 3.17.0 - proposed support for NotebookCellTextDocumentFilter.
+ */
+export type DocumentFilter = TextDocumentFilter | NotebookCellTextDocumentFilter;
+/**
+ * A document selector is the combination of one or many document filters.
+ *
+ * @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`;
+ *
+ * The use of a string as a document filter is deprecated @since 3.16.0.
+ */
+export type DocumentSelector = (string | DocumentFilter)[];
+/**
+ * The DocumentSelector namespace provides helper functions to work with
+ * {@link DocumentSelector}s.
+ */
+export declare namespace DocumentSelector {
+    function is(value: any[] | undefined | null): value is DocumentSelector;
+}
+/**
+ * General parameters to register for a notification or to register a provider.
+ */
+export interface Registration {
+    /**
+     * The id used to register the request. The id can be used to deregister
+     * the request again.
+     */
+    id: string;
+    /**
+     * The method / capability to register for.
+     */
+    method: string;
+    /**
+     * Options necessary for the registration.
+     */
+    registerOptions?: LSPAny;
+}
+export interface RegistrationParams {
+    registrations: Registration[];
+}
+/**
+ * The `client/registerCapability` request is sent from the server to the client to register a new capability
+ * handler on the client side.
+ */
+export declare namespace RegistrationRequest {
+    const method: 'client/registerCapability';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<RegistrationParams, void, never, void, void>;
+    type HandlerSignature = RequestHandler<RegistrationParams, void, void>;
+}
+/**
+ * General parameters to unregister a request or notification.
+ */
+export interface Unregistration {
+    /**
+     * The id used to unregister the request or notification. Usually an id
+     * provided during the register request.
+     */
+    id: string;
+    /**
+     * The method to unregister for.
+     */
+    method: string;
+}
+export interface UnregistrationParams {
+    unregisterations: Unregistration[];
+}
+/**
+ * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
+ * handler on the client side.
+ */
+export declare namespace UnregistrationRequest {
+    const method: 'client/unregisterCapability';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<UnregistrationParams, void, never, void, void>;
+    type HandlerSignature = RequestHandler<UnregistrationParams, void, void>;
+}
+export interface WorkDoneProgressParams {
+    /**
+     * An optional token that a server can use to report work done progress.
+     */
+    workDoneToken?: ProgressToken;
+}
+export interface PartialResultParams {
+    /**
+     * An optional token that a server can use to report partial results (e.g. streaming) to
+     * the client.
+     */
+    partialResultToken?: ProgressToken;
+}
+/**
+ * A parameter literal used in requests to pass a text document and a position inside that
+ * document.
+ */
+export interface TextDocumentPositionParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The position inside the text document.
+     */
+    position: Position;
+}
+/**
+ * The kind of resource operations supported by the client.
+ */
+export type ResourceOperationKind = 'create' | 'rename' | 'delete';
+export declare namespace ResourceOperationKind {
+    /**
+     * Supports creating new files and folders.
+     */
+    const Create: ResourceOperationKind;
+    /**
+     * Supports renaming existing files and folders.
+     */
+    const Rename: ResourceOperationKind;
+    /**
+     * Supports deleting existing files and folders.
+     */
+    const Delete: ResourceOperationKind;
+}
+export type FailureHandlingKind = 'abort' | 'transactional' | 'undo' | 'textOnlyTransactional';
+export declare namespace FailureHandlingKind {
+    /**
+     * Applying the workspace change is simply aborted if one of the changes provided
+     * fails. All operations executed before the failing operation stay executed.
+     */
+    const Abort: FailureHandlingKind;
+    /**
+     * All operations are executed transactional. That means they either all
+     * succeed or no changes at all are applied to the workspace.
+     */
+    const Transactional: FailureHandlingKind;
+    /**
+     * If the workspace edit contains only textual file changes they are executed transactional.
+     * If resource changes (create, rename or delete file) are part of the change the failure
+     * handling strategy is abort.
+     */
+    const TextOnlyTransactional: FailureHandlingKind;
+    /**
+     * The client tries to undo the operations already executed. But there is no
+     * guarantee that this is succeeding.
+     */
+    const Undo: FailureHandlingKind;
+}
+/**
+ * Workspace specific client capabilities.
+ */
+export interface WorkspaceClientCapabilities {
+    /**
+     * The client supports applying batch edits
+     * to the workspace by supporting the request
+     * 'workspace/applyEdit'
+     */
+    applyEdit?: boolean;
+    /**
+     * Capabilities specific to `WorkspaceEdit`s.
+     */
+    workspaceEdit?: WorkspaceEditClientCapabilities;
+    /**
+     * Capabilities specific to the `workspace/didChangeConfiguration` notification.
+     */
+    didChangeConfiguration?: DidChangeConfigurationClientCapabilities;
+    /**
+     * Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
+     */
+    didChangeWatchedFiles?: DidChangeWatchedFilesClientCapabilities;
+    /**
+     * Capabilities specific to the `workspace/symbol` request.
+     */
+    symbol?: WorkspaceSymbolClientCapabilities;
+    /**
+     * Capabilities specific to the `workspace/executeCommand` request.
+     */
+    executeCommand?: ExecuteCommandClientCapabilities;
+    /**
+     * The client has support for workspace folders.
+     *
+     * @since 3.6.0
+     */
+    workspaceFolders?: boolean;
+    /**
+     * The client supports `workspace/configuration` requests.
+     *
+     * @since 3.6.0
+     */
+    configuration?: boolean;
+    /**
+     * Capabilities specific to the semantic token requests scoped to the
+     * workspace.
+     *
+     * @since 3.16.0.
+     */
+    semanticTokens?: SemanticTokensWorkspaceClientCapabilities;
+    /**
+     * Capabilities specific to the code lens requests scoped to the
+     * workspace.
+     *
+     * @since 3.16.0.
+     */
+    codeLens?: CodeLensWorkspaceClientCapabilities;
+    /**
+     * The client has support for file notifications/requests for user operations on files.
+     *
+     * Since 3.16.0
+     */
+    fileOperations?: FileOperationClientCapabilities;
+    /**
+     * Capabilities specific to the inline values requests scoped to the
+     * workspace.
+     *
+     * @since 3.17.0.
+     */
+    inlineValue?: InlineValueWorkspaceClientCapabilities;
+    /**
+     * Capabilities specific to the inlay hint requests scoped to the
+     * workspace.
+     *
+     * @since 3.17.0.
+     */
+    inlayHint?: InlayHintWorkspaceClientCapabilities;
+    /**
+     * Capabilities specific to the diagnostic requests scoped to the
+     * workspace.
+     *
+     * @since 3.17.0.
+     */
+    diagnostics?: DiagnosticWorkspaceClientCapabilities;
+    /**
+     * Capabilities specific to the folding range requests scoped to the workspace.
+     *
+     * @since 3.18.0
+     * @proposed
+     */
+    foldingRange?: FoldingRangeWorkspaceClientCapabilities;
+}
+/**
+ * Text document specific client capabilities.
+ */
+export interface TextDocumentClientCapabilities {
+    /**
+     * Defines which synchronization capabilities the client supports.
+     */
+    synchronization?: TextDocumentSyncClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/completion` request.
+     */
+    completion?: CompletionClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/hover` request.
+     */
+    hover?: HoverClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/signatureHelp` request.
+     */
+    signatureHelp?: SignatureHelpClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/declaration` request.
+     *
+     * @since 3.14.0
+     */
+    declaration?: DeclarationClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/definition` request.
+     */
+    definition?: DefinitionClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/typeDefinition` request.
+     *
+     * @since 3.6.0
+     */
+    typeDefinition?: TypeDefinitionClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/implementation` request.
+     *
+     * @since 3.6.0
+     */
+    implementation?: ImplementationClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/references` request.
+     */
+    references?: ReferenceClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/documentHighlight` request.
+     */
+    documentHighlight?: DocumentHighlightClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/documentSymbol` request.
+     */
+    documentSymbol?: DocumentSymbolClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/codeAction` request.
+     */
+    codeAction?: CodeActionClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/codeLens` request.
+     */
+    codeLens?: CodeLensClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/documentLink` request.
+     */
+    documentLink?: DocumentLinkClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/documentColor` and the
+     * `textDocument/colorPresentation` request.
+     *
+     * @since 3.6.0
+     */
+    colorProvider?: DocumentColorClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/formatting` request.
+     */
+    formatting?: DocumentFormattingClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/rangeFormatting` request.
+     */
+    rangeFormatting?: DocumentRangeFormattingClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/onTypeFormatting` request.
+     */
+    onTypeFormatting?: DocumentOnTypeFormattingClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/rename` request.
+     */
+    rename?: RenameClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/foldingRange` request.
+     *
+     * @since 3.10.0
+     */
+    foldingRange?: FoldingRangeClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/selectionRange` request.
+     *
+     * @since 3.15.0
+     */
+    selectionRange?: SelectionRangeClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/publishDiagnostics` notification.
+     */
+    publishDiagnostics?: PublishDiagnosticsClientCapabilities;
+    /**
+     * Capabilities specific to the various call hierarchy requests.
+     *
+     * @since 3.16.0
+     */
+    callHierarchy?: CallHierarchyClientCapabilities;
+    /**
+     * Capabilities specific to the various semantic token request.
+     *
+     * @since 3.16.0
+     */
+    semanticTokens?: SemanticTokensClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/linkedEditingRange` request.
+     *
+     * @since 3.16.0
+     */
+    linkedEditingRange?: LinkedEditingRangeClientCapabilities;
+    /**
+     * Client capabilities specific to the `textDocument/moniker` request.
+     *
+     * @since 3.16.0
+     */
+    moniker?: MonikerClientCapabilities;
+    /**
+     * Capabilities specific to the various type hierarchy requests.
+     *
+     * @since 3.17.0
+     */
+    typeHierarchy?: TypeHierarchyClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/inlineValue` request.
+     *
+     * @since 3.17.0
+     */
+    inlineValue?: InlineValueClientCapabilities;
+    /**
+     * Capabilities specific to the `textDocument/inlayHint` request.
+     *
+     * @since 3.17.0
+     */
+    inlayHint?: InlayHintClientCapabilities;
+    /**
+     * Capabilities specific to the diagnostic pull model.
+     *
+     * @since 3.17.0
+     */
+    diagnostic?: DiagnosticClientCapabilities;
+    /**
+     * Client capabilities specific to inline completions.
+     *
+     * @since 3.18.0
+     * @proposed
+     */
+    inlineCompletion?: InlineCompletionClientCapabilities;
+}
+export interface WindowClientCapabilities {
+    /**
+     * It indicates whether the client supports server initiated
+     * progress using the `window/workDoneProgress/create` request.
+     *
+     * The capability also controls Whether client supports handling
+     * of progress notifications. If set servers are allowed to report a
+     * `workDoneProgress` property in the request specific server
+     * capabilities.
+     *
+     * @since 3.15.0
+     */
+    workDoneProgress?: boolean;
+    /**
+     * Capabilities specific to the showMessage request.
+     *
+     * @since 3.16.0
+     */
+    showMessage?: ShowMessageRequestClientCapabilities;
+    /**
+     * Capabilities specific to the showDocument request.
+     *
+     * @since 3.16.0
+     */
+    showDocument?: ShowDocumentClientCapabilities;
+}
+/**
+ * Client capabilities specific to regular expressions.
+ *
+ * @since 3.16.0
+ */
+export interface RegularExpressionsClientCapabilities {
+    /**
+     * The engine's name.
+     */
+    engine: string;
+    /**
+     * The engine's version.
+     */
+    version?: string;
+}
+/**
+ * Client capabilities specific to the used markdown parser.
+ *
+ * @since 3.16.0
+ */
+export interface MarkdownClientCapabilities {
+    /**
+     * The name of the parser.
+     */
+    parser: string;
+    /**
+     * The version of the parser.
+     */
+    version?: string;
+    /**
+     * A list of HTML tags that the client allows / supports in
+     * Markdown.
+     *
+     * @since 3.17.0
+     */
+    allowedTags?: string[];
+}
+/**
+ * A set of predefined position encoding kinds.
+ *
+ * @since 3.17.0
+ */
+export declare namespace PositionEncodingKind {
+    /**
+     * Character offsets count UTF-8 code units (e.g. bytes).
+     */
+    const UTF8: PositionEncodingKind;
+    /**
+     * Character offsets count UTF-16 code units.
+     *
+     * This is the default and must always be supported
+     * by servers
+     */
+    const UTF16: PositionEncodingKind;
+    /**
+     * Character offsets count UTF-32 code units.
+     *
+     * Implementation note: these are the same as Unicode codepoints,
+     * so this `PositionEncodingKind` may also be used for an
+     * encoding-agnostic representation of character offsets.
+     */
+    const UTF32: PositionEncodingKind;
+}
+/**
+ * A type indicating how positions are encoded,
+ * specifically what column offsets mean.
+ *
+ * @since 3.17.0
+ */
+export type PositionEncodingKind = string;
+/**
+ * General client capabilities.
+ *
+ * @since 3.16.0
+ */
+export interface GeneralClientCapabilities {
+    /**
+     * Client capability that signals how the client
+     * handles stale requests (e.g. a request
+     * for which the client will not process the response
+     * anymore since the information is outdated).
+     *
+     * @since 3.17.0
+     */
+    staleRequestSupport?: {
+        /**
+         * The client will actively cancel the request.
+         */
+        cancel: boolean;
+        /**
+         * The list of requests for which the client
+         * will retry the request if it receives a
+         * response with error code `ContentModified`
+         */
+        retryOnContentModified: string[];
+    };
+    /**
+     * Client capabilities specific to regular expressions.
+     *
+     * @since 3.16.0
+     */
+    regularExpressions?: RegularExpressionsClientCapabilities;
+    /**
+     * Client capabilities specific to the client's markdown parser.
+     *
+     * @since 3.16.0
+     */
+    markdown?: MarkdownClientCapabilities;
+    /**
+     * The position encodings supported by the client. Client and server
+     * have to agree on the same position encoding to ensure that offsets
+     * (e.g. character position in a line) are interpreted the same on both
+     * sides.
+     *
+     * To keep the protocol backwards compatible the following applies: if
+     * the value 'utf-16' is missing from the array of position encodings
+     * servers can assume that the client supports UTF-16. UTF-16 is
+     * therefore a mandatory encoding.
+     *
+     * If omitted it defaults to ['utf-16'].
+     *
+     * Implementation considerations: since the conversion from one encoding
+     * into another requires the content of the file / line the conversion
+     * is best done where the file is read which is usually on the server
+     * side.
+     *
+     * @since 3.17.0
+     */
+    positionEncodings?: PositionEncodingKind[];
+}
+/**
+ * Capabilities specific to the notebook document support.
+ *
+ * @since 3.17.0
+ */
+export interface NotebookDocumentClientCapabilities {
+    /**
+     * Capabilities specific to notebook document synchronization
+     *
+     * @since 3.17.0
+     */
+    synchronization: NotebookDocumentSyncClientCapabilities;
+}
+/**
+ * Defines the capabilities provided by the client.
+ */
+export interface ClientCapabilities {
+    /**
+     * Workspace specific client capabilities.
+     */
+    workspace?: WorkspaceClientCapabilities;
+    /**
+     * Text document specific client capabilities.
+     */
+    textDocument?: TextDocumentClientCapabilities;
+    /**
+     * Capabilities specific to the notebook document support.
+     *
+     * @since 3.17.0
+     */
+    notebookDocument?: NotebookDocumentClientCapabilities;
+    /**
+     * Window specific client capabilities.
+     */
+    window?: WindowClientCapabilities;
+    /**
+     * General client capabilities.
+     *
+     * @since 3.16.0
+     */
+    general?: GeneralClientCapabilities;
+    /**
+     * Experimental client capabilities.
+     */
+    experimental?: LSPAny;
+}
+/**
+ * Static registration options to be returned in the initialize
+ * request.
+ */
+export interface StaticRegistrationOptions {
+    /**
+     * The id used to register the request. The id can be used to deregister
+     * the request again. See also Registration#id.
+     */
+    id?: string;
+}
+/**
+ * The StaticRegistrationOptions namespace provides helper functions to work with
+ * {@link StaticRegistrationOptions} literals.
+ */
+export declare namespace StaticRegistrationOptions {
+    function hasId(value: object): value is {
+        id: string;
+    };
+}
+/**
+ * General text document registration options.
+ */
+export interface TextDocumentRegistrationOptions {
+    /**
+     * A document selector to identify the scope of the registration. If set to null
+     * the document selector provided on the client side will be used.
+     */
+    documentSelector: DocumentSelector | null;
+}
+/**
+ * The TextDocumentRegistrationOptions namespace provides helper functions to work with
+ * {@link TextDocumentRegistrationOptions} literals.
+ */
+export declare namespace TextDocumentRegistrationOptions {
+    function is(value: any): value is TextDocumentRegistrationOptions;
+}
+/**
+ * Save options.
+ */
+export interface SaveOptions {
+    /**
+     * The client is supposed to include the content on save.
+     */
+    includeText?: boolean;
+}
+export interface WorkDoneProgressOptions {
+    workDoneProgress?: boolean;
+}
+/**
+ * The WorkDoneProgressOptions namespace provides helper functions to work with
+ * {@link WorkDoneProgressOptions} literals.
+ */
+export declare namespace WorkDoneProgressOptions {
+    function is(value: any): value is WorkDoneProgressOptions;
+    function hasWorkDoneProgress(value: any): value is {
+        workDoneProgress: boolean;
+    };
+}
+/**
+ * Defines the capabilities provided by a language
+ * server.
+ */
+export interface ServerCapabilities<T = LSPAny> {
+    /**
+     * The position encoding the server picked from the encodings offered
+     * by the client via the client capability `general.positionEncodings`.
+     *
+     * If the client didn't provide any position encodings the only valid
+     * value that a server can return is 'utf-16'.
+     *
+     * If omitted it defaults to 'utf-16'.
+     *
+     * @since 3.17.0
+     */
+    positionEncoding?: PositionEncodingKind;
+    /**
+     * Defines how text documents are synced. Is either a detailed structure
+     * defining each notification or for backwards compatibility the
+     * TextDocumentSyncKind number.
+     */
+    textDocumentSync?: TextDocumentSyncOptions | TextDocumentSyncKind;
+    /**
+     * Defines how notebook documents are synced.
+     *
+     * @since 3.17.0
+     */
+    notebookDocumentSync?: NotebookDocumentSyncOptions | NotebookDocumentSyncRegistrationOptions;
+    /**
+     * The server provides completion support.
+     */
+    completionProvider?: CompletionOptions;
+    /**
+     * The server provides hover support.
+     */
+    hoverProvider?: boolean | HoverOptions;
+    /**
+     * The server provides signature help support.
+     */
+    signatureHelpProvider?: SignatureHelpOptions;
+    /**
+     * The server provides Goto Declaration support.
+     */
+    declarationProvider?: boolean | DeclarationOptions | DeclarationRegistrationOptions;
+    /**
+     * The server provides goto definition support.
+     */
+    definitionProvider?: boolean | DefinitionOptions;
+    /**
+     * The server provides Goto Type Definition support.
+     */
+    typeDefinitionProvider?: boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions;
+    /**
+     * The server provides Goto Implementation support.
+     */
+    implementationProvider?: boolean | ImplementationOptions | ImplementationRegistrationOptions;
+    /**
+     * The server provides find references support.
+     */
+    referencesProvider?: boolean | ReferenceOptions;
+    /**
+     * The server provides document highlight support.
+     */
+    documentHighlightProvider?: boolean | DocumentHighlightOptions;
+    /**
+     * The server provides document symbol support.
+     */
+    documentSymbolProvider?: boolean | DocumentSymbolOptions;
+    /**
+     * The server provides code actions. CodeActionOptions may only be
+     * specified if the client states that it supports
+     * `codeActionLiteralSupport` in its initial `initialize` request.
+     */
+    codeActionProvider?: boolean | CodeActionOptions;
+    /**
+     * The server provides code lens.
+     */
+    codeLensProvider?: CodeLensOptions;
+    /**
+     * The server provides document link support.
+     */
+    documentLinkProvider?: DocumentLinkOptions;
+    /**
+     * The server provides color provider support.
+     */
+    colorProvider?: boolean | DocumentColorOptions | DocumentColorRegistrationOptions;
+    /**
+     * The server provides workspace symbol support.
+     */
+    workspaceSymbolProvider?: boolean | WorkspaceSymbolOptions;
+    /**
+     * The server provides document formatting.
+     */
+    documentFormattingProvider?: boolean | DocumentFormattingOptions;
+    /**
+     * The server provides document range formatting.
+     */
+    documentRangeFormattingProvider?: boolean | DocumentRangeFormattingOptions;
+    /**
+     * The server provides document formatting on typing.
+     */
+    documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions;
+    /**
+     * The server provides rename support. RenameOptions may only be
+     * specified if the client states that it supports
+     * `prepareSupport` in its initial `initialize` request.
+     */
+    renameProvider?: boolean | RenameOptions;
+    /**
+     * The server provides folding provider support.
+     */
+    foldingRangeProvider?: boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions;
+    /**
+     * The server provides selection range support.
+     */
+    selectionRangeProvider?: boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions;
+    /**
+     * The server provides execute command support.
+     */
+    executeCommandProvider?: ExecuteCommandOptions;
+    /**
+     * The server provides call hierarchy support.
+     *
+     * @since 3.16.0
+     */
+    callHierarchyProvider?: boolean | CallHierarchyOptions | CallHierarchyRegistrationOptions;
+    /**
+     * The server provides linked editing range support.
+     *
+     * @since 3.16.0
+     */
+    linkedEditingRangeProvider?: boolean | LinkedEditingRangeOptions | LinkedEditingRangeRegistrationOptions;
+    /**
+     * The server provides semantic tokens support.
+     *
+     * @since 3.16.0
+     */
+    semanticTokensProvider?: SemanticTokensOptions | SemanticTokensRegistrationOptions;
+    /**
+     * The server provides moniker support.
+     *
+     * @since 3.16.0
+     */
+    monikerProvider?: boolean | MonikerOptions | MonikerRegistrationOptions;
+    /**
+     * The server provides type hierarchy support.
+     *
+     * @since 3.17.0
+     */
+    typeHierarchyProvider?: boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions;
+    /**
+     * The server provides inline values.
+     *
+     * @since 3.17.0
+     */
+    inlineValueProvider?: boolean | InlineValueOptions | InlineValueRegistrationOptions;
+    /**
+     * The server provides inlay hints.
+     *
+     * @since 3.17.0
+     */
+    inlayHintProvider?: boolean | InlayHintOptions | InlayHintRegistrationOptions;
+    /**
+     * The server has support for pull model diagnostics.
+     *
+     * @since 3.17.0
+     */
+    diagnosticProvider?: DiagnosticOptions | DiagnosticRegistrationOptions;
+    /**
+     * Inline completion options used during static registration.
+     *
+     * @since 3.18.0
+     * @proposed
+     */
+    inlineCompletionProvider?: boolean | InlineCompletionOptions;
+    /**
+     * Workspace specific server capabilities.
+     */
+    workspace?: {
+        /**
+         * The server supports workspace folder.
+         *
+         * @since 3.6.0
+         */
+        workspaceFolders?: WorkspaceFoldersServerCapabilities;
+        /**
+        * The server is interested in notifications/requests for operations on files.
+        *
+        * @since 3.16.0
+        */
+        fileOperations?: FileOperationOptions;
+    };
+    /**
+     * Experimental server capabilities.
+     */
+    experimental?: T;
+}
+/**
+ * The initialize request is sent from the client to the server.
+ * It is sent once as the request after starting up the server.
+ * The requests parameter is of type {@link InitializeParams}
+ * the response if of type {@link InitializeResult} of a Thenable that
+ * resolves to such.
+ */
+export declare namespace InitializeRequest {
+    const method: 'initialize';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<InitializeParams, InitializeResult<any>, never, InitializeError, void>;
+}
+/**
+ * The initialize parameters
+ */
+export interface _InitializeParams extends WorkDoneProgressParams {
+    /**
+     * The process Id of the parent process that started
+     * the server.
+     *
+     * Is `null` if the process has not been started by another process.
+     * If the parent process is not alive then the server should exit.
+     */
+    processId: integer | null;
+    /**
+     * Information about the client
+     *
+     * @since 3.15.0
+     */
+    clientInfo?: {
+        /**
+         * The name of the client as defined by the client.
+         */
+        name: string;
+        /**
+         * The client's version as defined by the client.
+         */
+        version?: string;
+    };
+    /**
+     * The locale the client is currently showing the user interface
+     * in. This must not necessarily be the locale of the operating
+     * system.
+     *
+     * Uses IETF language tags as the value's syntax
+     * (See https://en.wikipedia.org/wiki/IETF_language_tag)
+     *
+     * @since 3.16.0
+     */
+    locale?: string;
+    /**
+     * The rootPath of the workspace. Is null
+     * if no folder is open.
+     *
+     * @deprecated in favour of rootUri.
+     */
+    rootPath?: string | null;
+    /**
+     * The rootUri of the workspace. Is null if no
+     * folder is open. If both `rootPath` and `rootUri` are set
+     * `rootUri` wins.
+     *
+     * @deprecated in favour of workspaceFolders.
+     */
+    rootUri: DocumentUri | null;
+    /**
+     * The capabilities provided by the client (editor or tool)
+     */
+    capabilities: ClientCapabilities;
+    /**
+     * User provided initialization options.
+     */
+    initializationOptions?: LSPAny;
+    /**
+     * The initial trace setting. If omitted trace is disabled ('off').
+     */
+    trace?: TraceValues;
+}
+export type InitializeParams = _InitializeParams & WorkspaceFoldersInitializeParams;
+/**
+ * The result returned from an initialize request.
+ */
+export interface InitializeResult<T = any> {
+    /**
+     * The capabilities the language server provides.
+     */
+    capabilities: ServerCapabilities<T>;
+    /**
+     * Information about the server.
+     *
+     * @since 3.15.0
+     */
+    serverInfo?: {
+        /**
+         * The name of the server as defined by the server.
+         */
+        name: string;
+        /**
+         * The server's version as defined by the server.
+         */
+        version?: string;
+    };
+    /**
+     * Custom initialization results.
+     */
+    [custom: string]: LSPAny | ServerCapabilities<T> | undefined; /** undefined is needed since serverInfo is optional */
+}
+/**
+ * Known error codes for an `InitializeErrorCodes`;
+ */
+export declare namespace InitializeErrorCodes {
+    /**
+     * If the protocol version provided by the client can't be handled by the server.
+     *
+     * @deprecated This initialize error got replaced by client capabilities. There is
+     * no version handshake in version 3.0x
+     */
+    const unknownProtocolVersion: 1;
+}
+export type InitializeErrorCodes = 1;
+/**
+ * The data type of the ResponseError if the
+ * initialize request fails.
+ */
+export interface InitializeError {
+    /**
+     * Indicates whether the client execute the following retry logic:
+     * (1) show the message provided by the ResponseError to the user
+     * (2) user selects retry or cancel
+     * (3) if user selected retry the initialize method is sent again.
+     */
+    retry: boolean;
+}
+export interface InitializedParams {
+}
+/**
+ * The initialized notification is sent from the client to the
+ * server after the client is fully initialized and the server
+ * is allowed to send requests from the server to the client.
+ */
+export declare namespace InitializedNotification {
+    const method: 'initialized';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<InitializedParams, void>;
+}
+/**
+ * A shutdown request is sent from the client to the server.
+ * It is sent once when the client decides to shutdown the
+ * server. The only notification that is sent after a shutdown request
+ * is the exit event.
+ */
+export declare namespace ShutdownRequest {
+    const method: 'shutdown';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType0<void, never, void, void>;
+}
+/**
+ * The exit event is sent from the client to the server to
+ * ask the server to exit its process.
+ */
+export declare namespace ExitNotification {
+    const method: 'exit';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType0<void>;
+}
+export interface DidChangeConfigurationClientCapabilities {
+    /**
+     * Did change configuration notification supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * The configuration change notification is sent from the client to the server
+ * when the client's configuration has changed. The notification contains
+ * the changed configuration as defined by the language client.
+ */
+export declare namespace DidChangeConfigurationNotification {
+    const method: 'workspace/didChangeConfiguration';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidChangeConfigurationParams, DidChangeConfigurationRegistrationOptions>;
+}
+export interface DidChangeConfigurationRegistrationOptions {
+    section?: string | string[];
+}
+/**
+ * The parameters of a change configuration notification.
+ */
+export interface DidChangeConfigurationParams {
+    /**
+     * The actual changed settings
+     */
+    settings: LSPAny;
+}
+/**
+ * The message type
+ */
+export declare namespace MessageType {
+    /**
+     * An error message.
+     */
+    const Error = 1;
+    /**
+     * A warning message.
+     */
+    const Warning = 2;
+    /**
+     * An information message.
+     */
+    const Info = 3;
+    /**
+     * A log message.
+     */
+    const Log = 4;
+    /**
+     * A debug message.
+     *
+     * @since 3.18.0
+     */
+    const Debug = 5;
+}
+export type MessageType = 1 | 2 | 3 | 4 | 5;
+/**
+ * The parameters of a notification message.
+ */
+export interface ShowMessageParams {
+    /**
+     * The message type. See {@link MessageType}
+     */
+    type: MessageType;
+    /**
+     * The actual message.
+     */
+    message: string;
+}
+/**
+ * The show message notification is sent from a server to a client to ask
+ * the client to display a particular message in the user interface.
+ */
+export declare namespace ShowMessageNotification {
+    const method: 'window/showMessage';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<ShowMessageParams, void>;
+}
+/**
+ * Show message request client capabilities
+ */
+export interface ShowMessageRequestClientCapabilities {
+    /**
+     * Capabilities specific to the `MessageActionItem` type.
+     */
+    messageActionItem?: {
+        /**
+         * Whether the client supports additional attributes which
+         * are preserved and send back to the server in the
+         * request's response.
+         */
+        additionalPropertiesSupport?: boolean;
+    };
+}
+export interface MessageActionItem {
+    /**
+     * A short title like 'Retry', 'Open Log' etc.
+     */
+    title: string;
+    /**
+     * Additional attributes that the client preserves and
+     * sends back to the server. This depends on the client
+     * capability window.messageActionItem.additionalPropertiesSupport
+     */
+    [key: string]: string | boolean | integer | object;
+}
+export interface ShowMessageRequestParams {
+    /**
+     * The message type. See {@link MessageType}
+     */
+    type: MessageType;
+    /**
+     * The actual message.
+     */
+    message: string;
+    /**
+     * The message action items to present.
+     */
+    actions?: MessageActionItem[];
+}
+/**
+ * The show message request is sent from the server to the client to show a message
+ * and a set of options actions to the user.
+ */
+export declare namespace ShowMessageRequest {
+    const method: 'window/showMessageRequest';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ShowMessageRequestParams, MessageActionItem | null, never, void, void>;
+}
+/**
+ * The log message notification is sent from the server to the client to ask
+ * the client to log a particular message.
+ */
+export declare namespace LogMessageNotification {
+    const method: 'window/logMessage';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<LogMessageParams, void>;
+}
+/**
+ * The log message parameters.
+ */
+export interface LogMessageParams {
+    /**
+     * The message type. See {@link MessageType}
+     */
+    type: MessageType;
+    /**
+     * The actual message.
+     */
+    message: string;
+}
+/**
+ * The telemetry event notification is sent from the server to the client to ask
+ * the client to log telemetry data.
+ */
+export declare namespace TelemetryEventNotification {
+    const method: 'telemetry/event';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<any, void>;
+}
+export interface TextDocumentSyncClientCapabilities {
+    /**
+     * Whether text document synchronization supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports sending will save notifications.
+     */
+    willSave?: boolean;
+    /**
+     * The client supports sending a will save request and
+     * waits for a response providing text edits which will
+     * be applied to the document before it is saved.
+     */
+    willSaveWaitUntil?: boolean;
+    /**
+     * The client supports did save notifications.
+     */
+    didSave?: boolean;
+}
+/**
+ * Defines how the host (editor) should sync
+ * document changes to the language server.
+ */
+export declare namespace TextDocumentSyncKind {
+    /**
+     * Documents should not be synced at all.
+     */
+    const None = 0;
+    /**
+     * Documents are synced by always sending the full content
+     * of the document.
+     */
+    const Full = 1;
+    /**
+     * Documents are synced by sending the full content on open.
+     * After that only incremental updates to the document are
+     * send.
+     */
+    const Incremental = 2;
+}
+export type TextDocumentSyncKind = 0 | 1 | 2;
+export interface TextDocumentSyncOptions {
+    /**
+     * Open and close notifications are sent to the server. If omitted open close notification should not
+     * be sent.
+     */
+    openClose?: boolean;
+    /**
+     * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
+     * and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None.
+     */
+    change?: TextDocumentSyncKind;
+    /**
+     * If present will save notifications are sent to the server. If omitted the notification should not be
+     * sent.
+     */
+    willSave?: boolean;
+    /**
+     * If present will save wait until requests are sent to the server. If omitted the request should not be
+     * sent.
+     */
+    willSaveWaitUntil?: boolean;
+    /**
+     * If present save notifications are sent to the server. If omitted the notification should not be
+     * sent.
+     */
+    save?: boolean | SaveOptions;
+}
+/**
+ * The parameters sent in an open text document notification
+ */
+export interface DidOpenTextDocumentParams {
+    /**
+     * The document that was opened.
+     */
+    textDocument: TextDocumentItem;
+}
+/**
+ * The document open notification is sent from the client to the server to signal
+ * newly opened text documents. The document's truth is now managed by the client
+ * and the server must not try to read the document's truth using the document's
+ * uri. Open in this sense means it is managed by the client. It doesn't necessarily
+ * mean that its content is presented in an editor. An open notification must not
+ * be sent more than once without a corresponding close notification send before.
+ * This means open and close notification must be balanced and the max open count
+ * is one.
+ */
+export declare namespace DidOpenTextDocumentNotification {
+    const method: 'textDocument/didOpen';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidOpenTextDocumentParams, TextDocumentRegistrationOptions>;
+}
+/**
+ * An event describing a change to a text document. If only a text is provided
+ * it is considered to be the full content of the document.
+ */
+export type TextDocumentContentChangeEvent = {
+    /**
+     * The range of the document that changed.
+     */
+    range: Range;
+    /**
+     * The optional length of the range that got replaced.
+     *
+     * @deprecated use range instead.
+     */
+    rangeLength?: uinteger;
+    /**
+     * The new text for the provided range.
+     */
+    text: string;
+} | {
+    /**
+     * The new text of the whole document.
+     */
+    text: string;
+};
+export declare namespace TextDocumentContentChangeEvent {
+    /**
+     * Checks whether the information describes a delta event.
+     */
+    function isIncremental(event: TextDocumentContentChangeEvent): event is {
+        range: Range;
+        rangeLength?: uinteger;
+        text: string;
+    };
+    /**
+     * Checks whether the information describes a full replacement event.
+     */
+    function isFull(event: TextDocumentContentChangeEvent): event is {
+        text: string;
+    };
+}
+/**
+ * The change text document notification's parameters.
+ */
+export interface DidChangeTextDocumentParams {
+    /**
+     * The document that did change. The version number points
+     * to the version after all provided content changes have
+     * been applied.
+     */
+    textDocument: VersionedTextDocumentIdentifier;
+    /**
+     * The actual content changes. The content changes describe single state changes
+     * to the document. So if there are two content changes c1 (at array index 0) and
+     * c2 (at array index 1) for a document in state S then c1 moves the document 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 document using change events use the following approach:
+     * - start with the same initial content
+     * - apply the 'textDocument/didChange' notifications in the order you receive them.
+     * - apply the `TextDocumentContentChangeEvent`s in a single notification in the order
+     *   you receive them.
+     */
+    contentChanges: TextDocumentContentChangeEvent[];
+}
+/**
+ * Describe options to be used when registered for text document change events.
+ */
+export interface TextDocumentChangeRegistrationOptions extends TextDocumentRegistrationOptions {
+    /**
+     * How documents are synced to the server.
+     */
+    syncKind: TextDocumentSyncKind;
+}
+/**
+ * The document change notification is sent from the client to the server to signal
+ * changes to a text document.
+ */
+export declare namespace DidChangeTextDocumentNotification {
+    const method: 'textDocument/didChange';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidChangeTextDocumentParams, TextDocumentChangeRegistrationOptions>;
+}
+/**
+ * The parameters sent in a close text document notification
+ */
+export interface DidCloseTextDocumentParams {
+    /**
+     * The document that was closed.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * The document close notification is sent from the client to the server when
+ * the document got closed in the client. The document's truth now exists where
+ * the document's uri points to (e.g. if the document's uri is a file uri the
+ * truth now exists on disk). As with the open notification the close notification
+ * is about managing the document's content. Receiving a close notification
+ * doesn't mean that the document was open in an editor before. A close
+ * notification requires a previous open notification to be sent.
+ */
+export declare namespace DidCloseTextDocumentNotification {
+    const method: 'textDocument/didClose';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidCloseTextDocumentParams, TextDocumentRegistrationOptions>;
+}
+/**
+ * The parameters sent in a save text document notification
+ */
+export interface DidSaveTextDocumentParams {
+    /**
+     * The document that was saved.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * Optional the content when saved. Depends on the includeText value
+     * when the save notification was requested.
+     */
+    text?: string;
+}
+/**
+ * Save registration options.
+ */
+export interface TextDocumentSaveRegistrationOptions extends TextDocumentRegistrationOptions, SaveOptions {
+}
+/**
+ * The document save notification is sent from the client to the server when
+ * the document got saved in the client.
+ */
+export declare namespace DidSaveTextDocumentNotification {
+    const method: 'textDocument/didSave';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidSaveTextDocumentParams, TextDocumentSaveRegistrationOptions>;
+}
+/**
+ * Represents reasons why a text document is saved.
+ */
+export declare namespace TextDocumentSaveReason {
+    /**
+     * Manually triggered, e.g. by the user pressing save, by starting debugging,
+     * or by an API call.
+     */
+    const Manual: 1;
+    /**
+     * Automatic after a delay.
+     */
+    const AfterDelay: 2;
+    /**
+     * When the editor lost focus.
+     */
+    const FocusOut: 3;
+}
+export type TextDocumentSaveReason = 1 | 2 | 3;
+/**
+ * The parameters sent in a will save text document notification.
+ */
+export interface WillSaveTextDocumentParams {
+    /**
+     * The document that will be saved.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The 'TextDocumentSaveReason'.
+     */
+    reason: TextDocumentSaveReason;
+}
+/**
+ * A document will save notification is sent from the client to the server before
+ * the document is actually saved.
+ */
+export declare namespace WillSaveTextDocumentNotification {
+    const method: 'textDocument/willSave';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<WillSaveTextDocumentParams, TextDocumentRegistrationOptions>;
+}
+/**
+ * A document will save request is sent from the client to the server before
+ * the document is actually saved. The request can return an array of TextEdits
+ * which will be applied to the text document before it is saved. Please note that
+ * clients might drop results if computing the text edits took too long or if a
+ * server constantly fails on this request. This is done to keep the save fast and
+ * reliable.
+ */
+export declare namespace WillSaveTextDocumentWaitUntilRequest {
+    const method: 'textDocument/willSaveWaitUntil';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<WillSaveTextDocumentParams, TextEdit[] | null, never, void, TextDocumentRegistrationOptions>;
+}
+export interface DidChangeWatchedFilesClientCapabilities {
+    /**
+     * Did change watched files notification supports dynamic registration. Please note
+     * that the current protocol doesn't support static configuration for file changes
+     * from the server side.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Whether the client has support for {@link  RelativePattern relative pattern}
+     * or not.
+     *
+     * @since 3.17.0
+     */
+    relativePatternSupport?: boolean;
+}
+/**
+ * The watched files notification is sent from the client to the server when
+ * the client detects changes to file watched by the language client.
+ */
+export declare namespace DidChangeWatchedFilesNotification {
+    const method: 'workspace/didChangeWatchedFiles';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions>;
+}
+/**
+ * The watched files change notification's parameters.
+ */
+export interface DidChangeWatchedFilesParams {
+    /**
+     * The actual file events.
+     */
+    changes: FileEvent[];
+}
+/**
+ * The file event type
+ */
+export declare namespace FileChangeType {
+    /**
+     * The file got created.
+     */
+    const Created = 1;
+    /**
+     * The file got changed.
+     */
+    const Changed = 2;
+    /**
+     * The file got deleted.
+     */
+    const Deleted = 3;
+}
+export type FileChangeType = 1 | 2 | 3;
+/**
+ * An event describing a file change.
+ */
+export interface FileEvent {
+    /**
+     * The file's uri.
+     */
+    uri: DocumentUri;
+    /**
+     * The change type.
+     */
+    type: FileChangeType;
+}
+/**
+ * Describe options to be used when registered for text document change events.
+ */
+export interface DidChangeWatchedFilesRegistrationOptions {
+    /**
+     * The watchers to register.
+     */
+    watchers: FileSystemWatcher[];
+}
+/**
+ * The glob pattern to watch relative to the base path. Glob patterns can have the following syntax:
+ * - `*` to match one or more characters in a path segment
+ * - `?` to match on one character in a path segment
+ * - `**` to match any number of path segments, including none
+ * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+ * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+ * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+ *
+ * @since 3.17.0
+ */
+export type Pattern = string;
+/**
+ * A relative pattern is a helper to construct glob patterns that are matched
+ * relatively to a base URI. The common value for a `baseUri` is a workspace
+ * folder root, but it can be another absolute URI as well.
+ *
+ * @since 3.17.0
+ */
+export interface RelativePattern {
+    /**
+     * A workspace folder or a base URI to which this pattern will be matched
+     * against relatively.
+     */
+    baseUri: WorkspaceFolder | URI;
+    /**
+     * The actual glob pattern;
+     */
+    pattern: Pattern;
+}
+export declare namespace RelativePattern {
+    function is(value: any): value is RelativePattern;
+}
+/**
+ * The glob pattern. Either a string pattern or a relative pattern.
+ *
+ * @since 3.17.0
+ */
+export type GlobPattern = Pattern | RelativePattern;
+export interface FileSystemWatcher {
+    /**
+     * The glob pattern to watch. See {@link GlobPattern glob pattern} for more detail.
+     *
+     * @since 3.17.0 support for relative patterns.
+     */
+    globPattern: GlobPattern;
+    /**
+     * The kind of events of interest. If omitted it defaults
+     * to WatchKind.Create | WatchKind.Change | WatchKind.Delete
+     * which is 7.
+     */
+    kind?: WatchKind;
+}
+export declare namespace WatchKind {
+    /**
+     * Interested in create events.
+     */
+    const Create: 1;
+    /**
+     * Interested in change events
+     */
+    const Change: 2;
+    /**
+     * Interested in delete events
+     */
+    const Delete: 4;
+}
+export type WatchKind = uinteger;
+/**
+ * The publish diagnostic client capabilities.
+ */
+export interface PublishDiagnosticsClientCapabilities {
+    /**
+     * Whether the clients accepts diagnostics with related information.
+     */
+    relatedInformation?: boolean;
+    /**
+     * Client supports the tag property to provide meta data about a diagnostic.
+     * Clients supporting tags have to handle unknown tags gracefully.
+     *
+     * @since 3.15.0
+     */
+    tagSupport?: {
+        /**
+         * The tags supported by the client.
+         */
+        valueSet: DiagnosticTag[];
+    };
+    /**
+     * Whether the client interprets the version property of the
+     * `textDocument/publishDiagnostics` notification's parameter.
+     *
+     * @since 3.15.0
+     */
+    versionSupport?: boolean;
+    /**
+     * Client supports a codeDescription property
+     *
+     * @since 3.16.0
+     */
+    codeDescriptionSupport?: boolean;
+    /**
+     * Whether code action supports the `data` property which is
+     * preserved between a `textDocument/publishDiagnostics` and
+     * `textDocument/codeAction` request.
+     *
+     * @since 3.16.0
+     */
+    dataSupport?: boolean;
+}
+/**
+ * The publish diagnostic notification's parameters.
+ */
+export interface PublishDiagnosticsParams {
+    /**
+     * The URI for which diagnostic information is reported.
+     */
+    uri: DocumentUri;
+    /**
+     * Optional the version number of the document the diagnostics are published for.
+     *
+     * @since 3.15.0
+     */
+    version?: integer;
+    /**
+     * An array of diagnostic information items.
+     */
+    diagnostics: Diagnostic[];
+}
+/**
+ * Diagnostics notification are sent from the server to the client to signal
+ * results of validation runs.
+ */
+export declare namespace PublishDiagnosticsNotification {
+    const method: 'textDocument/publishDiagnostics';
+    const messageDirection: MessageDirection;
+    const type: ProtocolNotificationType<PublishDiagnosticsParams, void>;
+}
+/**
+ * Completion client capabilities
+ */
+export interface CompletionClientCapabilities {
+    /**
+     * Whether completion supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports the following `CompletionItem` specific
+     * capabilities.
+     */
+    completionItem?: {
+        /**
+         * Client supports snippets as insert text.
+         *
+         * A snippet can define tab stops and placeholders with `$1`, `$2`
+         * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+         * the end of the snippet. Placeholders with equal identifiers are linked,
+         * that is typing in one will update others too.
+         */
+        snippetSupport?: boolean;
+        /**
+         * Client supports commit characters on a completion item.
+         */
+        commitCharactersSupport?: boolean;
+        /**
+         * Client supports the following content formats for the documentation
+         * property. The order describes the preferred format of the client.
+         */
+        documentationFormat?: MarkupKind[];
+        /**
+         * Client supports the deprecated property on a completion item.
+         */
+        deprecatedSupport?: boolean;
+        /**
+         * Client supports the preselect property on a completion item.
+         */
+        preselectSupport?: boolean;
+        /**
+         * Client supports the tag property on a completion item. Clients supporting
+         * tags have to handle unknown tags gracefully. Clients especially need to
+         * preserve unknown tags when sending a completion item back to the server in
+         * a resolve call.
+         *
+         * @since 3.15.0
+         */
+        tagSupport?: {
+            /**
+             * The tags supported by the client.
+             */
+            valueSet: CompletionItemTag[];
+        };
+        /**
+         * Client support insert replace edit to control different behavior if a
+         * completion item is inserted in the text or should replace text.
+         *
+         * @since 3.16.0
+         */
+        insertReplaceSupport?: boolean;
+        /**
+         * Indicates which properties a client can resolve lazily on a completion
+         * item. Before version 3.16.0 only the predefined properties `documentation`
+         * and `details` could be resolved lazily.
+         *
+         * @since 3.16.0
+         */
+        resolveSupport?: {
+            /**
+             * The properties that a client can resolve lazily.
+             */
+            properties: string[];
+        };
+        /**
+         * The client supports the `insertTextMode` property on
+         * a completion item to override the whitespace handling mode
+         * as defined by the client (see `insertTextMode`).
+         *
+         * @since 3.16.0
+         */
+        insertTextModeSupport?: {
+            valueSet: InsertTextMode[];
+        };
+        /**
+         * The client has support for completion item label
+         * details (see also `CompletionItemLabelDetails`).
+         *
+         * @since 3.17.0
+         */
+        labelDetailsSupport?: boolean;
+    };
+    completionItemKind?: {
+        /**
+         * The completion item kind values the client supports. When this
+         * property exists the client also guarantees that it will
+         * handle values outside its set gracefully and falls back
+         * to a default value when unknown.
+         *
+         * If this property is not present the client only supports
+         * the completion items kinds from `Text` to `Reference` as defined in
+         * the initial version of the protocol.
+         */
+        valueSet?: CompletionItemKind[];
+    };
+    /**
+     * Defines how the client handles whitespace and indentation
+     * when accepting a completion item that uses multi line
+     * text in either `insertText` or `textEdit`.
+     *
+     * @since 3.17.0
+     */
+    insertTextMode?: InsertTextMode;
+    /**
+     * The client supports to send additional context information for a
+     * `textDocument/completion` request.
+     */
+    contextSupport?: boolean;
+    /**
+     * The client supports the following `CompletionList` specific
+     * capabilities.
+     *
+     * @since 3.17.0
+     */
+    completionList?: {
+        /**
+         * The client supports the following itemDefaults on
+         * a completion list.
+         *
+         * The value lists the supported property names of the
+         * `CompletionList.itemDefaults` object. If omitted
+         * no properties are supported.
+         *
+         * @since 3.17.0
+         */
+        itemDefaults?: string[];
+    };
+}
+/**
+ * How a completion was triggered
+ */
+export declare namespace CompletionTriggerKind {
+    /**
+     * Completion was triggered by typing an identifier (24x7 code
+     * complete), manual invocation (e.g Ctrl+Space) or via API.
+     */
+    const Invoked: 1;
+    /**
+     * Completion was triggered by a trigger character specified by
+     * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
+     */
+    const TriggerCharacter: 2;
+    /**
+     * Completion was re-triggered as current completion list is incomplete
+     */
+    const TriggerForIncompleteCompletions: 3;
+}
+export type CompletionTriggerKind = 1 | 2 | 3;
+/**
+ * Contains additional information about the context in which a completion request is triggered.
+ */
+export interface CompletionContext {
+    /**
+     * How the completion was triggered.
+     */
+    triggerKind: CompletionTriggerKind;
+    /**
+     * The trigger character (a single character) that has trigger code complete.
+     * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
+     */
+    triggerCharacter?: string;
+}
+/**
+ * Completion parameters
+ */
+export interface CompletionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The completion context. This is only available it the client specifies
+     * to send this using the client capability `textDocument.completion.contextSupport === true`
+     */
+    context?: CompletionContext;
+}
+/**
+ * Completion options.
+ */
+export interface CompletionOptions extends WorkDoneProgressOptions {
+    /**
+     * Most tools trigger completion request automatically without explicitly requesting
+     * it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user
+     * starts to type an identifier. For example if the user types `c` in a JavaScript file
+     * code complete will automatically pop up present `console` besides others as a
+     * completion item. Characters that make up identifiers don't need to be listed here.
+     *
+     * If code complete should automatically be trigger on characters not being valid inside
+     * an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
+     */
+    triggerCharacters?: string[];
+    /**
+     * The list of all possible characters that commit a completion. This field can be used
+     * if clients don't support individual commit characters per completion item. See
+     * `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport`
+     *
+     * If a server provides both `allCommitCharacters` and commit characters on an individual
+     * completion item the ones on the completion item win.
+     *
+     * @since 3.2.0
+     */
+    allCommitCharacters?: string[];
+    /**
+     * The server provides support to resolve additional
+     * information for a completion item.
+     */
+    resolveProvider?: boolean;
+    /**
+     * The server supports the following `CompletionItem` specific
+     * capabilities.
+     *
+     * @since 3.17.0
+     */
+    completionItem?: {
+        /**
+         * The server has support for completion item label
+         * details (see also `CompletionItemLabelDetails`) when
+         * receiving a completion item in a resolve call.
+         *
+         * @since 3.17.0
+         */
+        labelDetailsSupport?: boolean;
+    };
+}
+/**
+ * Registration options for a {@link CompletionRequest}.
+ */
+export interface CompletionRegistrationOptions extends TextDocumentRegistrationOptions, CompletionOptions {
+}
+/**
+ * Request to request completion at a given text document position. The request's
+ * parameter is of type {@link TextDocumentPosition} the response
+ * is of type {@link CompletionItem CompletionItem[]} or {@link CompletionList}
+ * or a Thenable that resolves to such.
+ *
+ * The request can delay the computation of the {@link CompletionItem.detail `detail`}
+ * and {@link CompletionItem.documentation `documentation`} properties to the `completionItem/resolve`
+ * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
+ * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
+ */
+export declare namespace CompletionRequest {
+    const method: 'textDocument/completion';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CompletionParams, CompletionList | CompletionItem[] | null, CompletionItem[], void, CompletionRegistrationOptions>;
+}
+/**
+ * Request to resolve additional information for a given completion item.The request's
+ * parameter is of type {@link CompletionItem} the response
+ * is of type {@link CompletionItem} or a Thenable that resolves to such.
+ */
+export declare namespace CompletionResolveRequest {
+    const method: 'completionItem/resolve';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CompletionItem, CompletionItem, never, void, void>;
+}
+export interface HoverClientCapabilities {
+    /**
+     * Whether hover supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Client supports the following content formats for the content
+     * property. The order describes the preferred format of the client.
+     */
+    contentFormat?: MarkupKind[];
+}
+/**
+ * Hover options.
+ */
+export interface HoverOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Parameters for a {@link HoverRequest}.
+ */
+export interface HoverParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+/**
+ * Registration options for a {@link HoverRequest}.
+ */
+export interface HoverRegistrationOptions extends TextDocumentRegistrationOptions, HoverOptions {
+}
+/**
+ * Request to request hover information at a given text document position. The request's
+ * parameter is of type {@link TextDocumentPosition} the response is of
+ * type {@link Hover} or a Thenable that resolves to such.
+ */
+export declare namespace HoverRequest {
+    const method: 'textDocument/hover';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<HoverParams, Hover | null, never, void, HoverRegistrationOptions>;
+}
+/**
+ * Client Capabilities for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpClientCapabilities {
+    /**
+     * Whether signature help supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports the following `SignatureInformation`
+     * specific properties.
+     */
+    signatureInformation?: {
+        /**
+         * Client supports the following content formats for the documentation
+         * property. The order describes the preferred format of the client.
+         */
+        documentationFormat?: MarkupKind[];
+        /**
+         * Client capabilities specific to parameter information.
+         */
+        parameterInformation?: {
+            /**
+             * The client supports processing label offsets instead of a
+             * simple label string.
+             *
+             * @since 3.14.0
+             */
+            labelOffsetSupport?: boolean;
+        };
+        /**
+         * The client supports the `activeParameter` property on `SignatureInformation`
+         * literal.
+         *
+         * @since 3.16.0
+         */
+        activeParameterSupport?: boolean;
+    };
+    /**
+     * The client supports to send additional context information for a
+     * `textDocument/signatureHelp` request. A client that opts into
+     * contextSupport will also support the `retriggerCharacters` on
+     * `SignatureHelpOptions`.
+     *
+     * @since 3.15.0
+     */
+    contextSupport?: boolean;
+}
+/**
+ * Server Capabilities for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpOptions extends WorkDoneProgressOptions {
+    /**
+     * List of characters that trigger signature help automatically.
+     */
+    triggerCharacters?: string[];
+    /**
+     * List of characters that re-trigger signature help.
+     *
+     * These trigger characters are only active when signature help is already showing. All trigger characters
+     * are also counted as re-trigger characters.
+     *
+     * @since 3.15.0
+     */
+    retriggerCharacters?: string[];
+}
+/**
+ * How a signature help was triggered.
+ *
+ * @since 3.15.0
+ */
+export declare namespace SignatureHelpTriggerKind {
+    /**
+     * Signature help was invoked manually by the user or by a command.
+     */
+    const Invoked: 1;
+    /**
+     * Signature help was triggered by a trigger character.
+     */
+    const TriggerCharacter: 2;
+    /**
+     * Signature help was triggered by the cursor moving or by the document content changing.
+     */
+    const ContentChange: 3;
+}
+export type SignatureHelpTriggerKind = 1 | 2 | 3;
+/**
+ * Additional information about the context in which a signature help request was triggered.
+ *
+ * @since 3.15.0
+ */
+export interface SignatureHelpContext {
+    /**
+     * Action that caused signature help to be triggered.
+     */
+    triggerKind: SignatureHelpTriggerKind;
+    /**
+     * Character that caused signature help to be triggered.
+     *
+     * This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
+     */
+    triggerCharacter?: string;
+    /**
+     * `true` if signature help was already showing when it was triggered.
+     *
+     * Retriggers occurs when the signature help is already active and can be caused by actions such as
+     * typing a trigger character, a cursor move, or document content changes.
+     */
+    isRetrigger: boolean;
+    /**
+     * The currently active `SignatureHelp`.
+     *
+     * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
+     * the user navigating through available signatures.
+     */
+    activeSignatureHelp?: SignatureHelp;
+}
+/**
+ * Parameters for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+    /**
+     * The signature help context. This is only available if the client specifies
+     * to send this using the client capability `textDocument.signatureHelp.contextSupport === true`
+     *
+     * @since 3.15.0
+     */
+    context?: SignatureHelpContext;
+}
+/**
+ * Registration options for a {@link SignatureHelpRequest}.
+ */
+export interface SignatureHelpRegistrationOptions extends TextDocumentRegistrationOptions, SignatureHelpOptions {
+}
+export declare namespace SignatureHelpRequest {
+    const method: 'textDocument/signatureHelp';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<SignatureHelpParams, SignatureHelp | null, never, void, SignatureHelpRegistrationOptions>;
+}
+/**
+ * Client Capabilities for a {@link DefinitionRequest}.
+ */
+export interface DefinitionClientCapabilities {
+    /**
+     * Whether definition supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client supports additional metadata in the form of definition links.
+     *
+     * @since 3.14.0
+     */
+    linkSupport?: boolean;
+}
+/**
+ * Server Capabilities for a {@link DefinitionRequest}.
+ */
+export interface DefinitionOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Parameters for a {@link DefinitionRequest}.
+ */
+export interface DefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * Registration options for a {@link DefinitionRequest}.
+ */
+export interface DefinitionRegistrationOptions extends TextDocumentRegistrationOptions, DefinitionOptions {
+}
+/**
+ * A request to resolve the definition location of a symbol at a given text
+ * document position. The request's parameter is of type {@link TextDocumentPosition}
+ * the response is of either type {@link Definition} or a typed array of
+ * {@link DefinitionLink} or a Thenable that resolves to such.
+ */
+export declare namespace DefinitionRequest {
+    const method: 'textDocument/definition';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DefinitionParams, Definition | LocationLink[] | null, Location[] | LocationLink[], void, DefinitionRegistrationOptions>;
+}
+/**
+ * Client Capabilities for a {@link ReferencesRequest}.
+ */
+export interface ReferenceClientCapabilities {
+    /**
+     * Whether references supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * Parameters for a {@link ReferencesRequest}.
+ */
+export interface ReferenceParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+    context: ReferenceContext;
+}
+/**
+ * Reference options.
+ */
+export interface ReferenceOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Registration options for a {@link ReferencesRequest}.
+ */
+export interface ReferenceRegistrationOptions extends TextDocumentRegistrationOptions, ReferenceOptions {
+}
+/**
+ * A request to resolve project-wide references for the symbol denoted
+ * by the given text document position. The request's parameter is of
+ * type {@link ReferenceParams} the response is of type
+ * {@link Location Location[]} or a Thenable that resolves to such.
+ */
+export declare namespace ReferencesRequest {
+    const method: 'textDocument/references';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ReferenceParams, Location[] | null, Location[], void, ReferenceRegistrationOptions>;
+}
+/**
+ * Client Capabilities for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightClientCapabilities {
+    /**
+     * Whether document highlight supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * Parameters for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+}
+/**
+ * Provider options for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Registration options for a {@link DocumentHighlightRequest}.
+ */
+export interface DocumentHighlightRegistrationOptions extends TextDocumentRegistrationOptions, DocumentHighlightOptions {
+}
+/**
+ * Request to resolve a {@link DocumentHighlight} for a given
+ * text document position. The request's parameter is of type {@link TextDocumentPosition}
+ * the request response is an array of type {@link DocumentHighlight}
+ * or a Thenable that resolves to such.
+ */
+export declare namespace DocumentHighlightRequest {
+    const method: 'textDocument/documentHighlight';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentHighlightParams, DocumentHighlight[] | null, DocumentHighlight[], void, DocumentHighlightRegistrationOptions>;
+}
+/**
+ * Client Capabilities for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolClientCapabilities {
+    /**
+     * Whether document symbol supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Specific capabilities for the `SymbolKind` in the
+     * `textDocument/documentSymbol` request.
+     */
+    symbolKind?: {
+        /**
+         * The symbol kind values the client supports. When this
+         * property exists the client also guarantees that it will
+         * handle values outside its set gracefully and falls back
+         * to a default value when unknown.
+         *
+         * If this property is not present the client only supports
+         * the symbol kinds from `File` to `Array` as defined in
+         * the initial version of the protocol.
+         */
+        valueSet?: SymbolKind[];
+    };
+    /**
+     * The client supports hierarchical document symbols.
+     */
+    hierarchicalDocumentSymbolSupport?: boolean;
+    /**
+     * The client supports tags on `SymbolInformation`. Tags are supported on
+     * `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true.
+     * Clients supporting tags have to handle unknown tags gracefully.
+     *
+     * @since 3.16.0
+     */
+    tagSupport?: {
+        /**
+         * The tags supported by the client.
+         */
+        valueSet: SymbolTag[];
+    };
+    /**
+     * The client supports an additional label presented in the UI when
+     * registering a document symbol provider.
+     *
+     * @since 3.16.0
+     */
+    labelSupport?: boolean;
+}
+/**
+ * Parameters for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The text document.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * Provider options for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolOptions extends WorkDoneProgressOptions {
+    /**
+     * A human-readable string that is shown when multiple outlines trees
+     * are shown for the same document.
+     *
+     * @since 3.16.0
+     */
+    label?: string;
+}
+/**
+ * Registration options for a {@link DocumentSymbolRequest}.
+ */
+export interface DocumentSymbolRegistrationOptions extends TextDocumentRegistrationOptions, DocumentSymbolOptions {
+}
+/**
+ * A request to list all symbols found in a given text document. The request's
+ * parameter is of type {@link TextDocumentIdentifier} the
+ * response is of type {@link SymbolInformation SymbolInformation[]} or a Thenable
+ * that resolves to such.
+ */
+export declare namespace DocumentSymbolRequest {
+    const method: 'textDocument/documentSymbol';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentSymbolParams, DocumentSymbol[] | SymbolInformation[] | null, DocumentSymbol[] | SymbolInformation[], void, DocumentSymbolRegistrationOptions>;
+}
+/**
+ * The Client Capabilities of a {@link CodeActionRequest}.
+ */
+export interface CodeActionClientCapabilities {
+    /**
+     * Whether code action supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * The client support code action literals of type `CodeAction` as a valid
+     * response of the `textDocument/codeAction` request. If the property is not
+     * set the request can only return `Command` literals.
+     *
+     * @since 3.8.0
+     */
+    codeActionLiteralSupport?: {
+        /**
+         * The code action kind is support with the following value
+         * set.
+         */
+        codeActionKind: {
+            /**
+             * The code action kind values the client supports. When this
+             * property exists the client also guarantees that it will
+             * handle values outside its set gracefully and falls back
+             * to a default value when unknown.
+             */
+            valueSet: CodeActionKind[];
+        };
+    };
+    /**
+     * Whether code action supports the `isPreferred` property.
+     *
+     * @since 3.15.0
+     */
+    isPreferredSupport?: boolean;
+    /**
+     * Whether code action supports the `disabled` property.
+     *
+     * @since 3.16.0
+     */
+    disabledSupport?: boolean;
+    /**
+     * Whether code action supports the `data` property which is
+     * preserved between a `textDocument/codeAction` and a
+     * `codeAction/resolve` request.
+     *
+     * @since 3.16.0
+     */
+    dataSupport?: boolean;
+    /**
+     * Whether the client supports resolving additional code action
+     * properties via a separate `codeAction/resolve` request.
+     *
+     * @since 3.16.0
+     */
+    resolveSupport?: {
+        /**
+         * The properties that a client can resolve lazily.
+         */
+        properties: string[];
+    };
+    /**
+     * Whether the client honors the change annotations in
+     * text edits and resource operations returned via the
+     * `CodeAction#edit` property by for example presenting
+     * the workspace edit in the user interface and asking
+     * for confirmation.
+     *
+     * @since 3.16.0
+     */
+    honorsChangeAnnotations?: boolean;
+}
+/**
+ * The parameters of a {@link CodeActionRequest}.
+ */
+export interface CodeActionParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The document in which the command was invoked.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The range for which the command was invoked.
+     */
+    range: Range;
+    /**
+     * Context carrying additional information.
+     */
+    context: CodeActionContext;
+}
+/**
+ * Provider options for a {@link CodeActionRequest}.
+ */
+export interface CodeActionOptions extends WorkDoneProgressOptions {
+    /**
+     * CodeActionKinds that this server may return.
+     *
+     * The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
+     * may list out every specific kind they provide.
+     */
+    codeActionKinds?: CodeActionKind[];
+    /**
+     * The server provides support to resolve additional
+     * information for a code action.
+     *
+     * @since 3.16.0
+     */
+    resolveProvider?: boolean;
+}
+/**
+ * Registration options for a {@link CodeActionRequest}.
+ */
+export interface CodeActionRegistrationOptions extends TextDocumentRegistrationOptions, CodeActionOptions {
+}
+/**
+ * A request to provide commands for the given text document and range.
+ */
+export declare namespace CodeActionRequest {
+    const method: 'textDocument/codeAction';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CodeActionParams, (Command | CodeAction)[] | null, (Command | CodeAction)[], void, CodeActionRegistrationOptions>;
+}
+/**
+ * Request to resolve additional information for a given code action.The request's
+ * parameter is of type {@link CodeAction} the response
+ * is of type {@link CodeAction} or a Thenable that resolves to such.
+ */
+export declare namespace CodeActionResolveRequest {
+    const method: 'codeAction/resolve';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CodeAction, CodeAction, never, void, void>;
+}
+/**
+ * Client capabilities for a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolClientCapabilities {
+    /**
+     * Symbol request supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
+     */
+    symbolKind?: {
+        /**
+         * The symbol kind values the client supports. When this
+         * property exists the client also guarantees that it will
+         * handle values outside its set gracefully and falls back
+         * to a default value when unknown.
+         *
+         * If this property is not present the client only supports
+         * the symbol kinds from `File` to `Array` as defined in
+         * the initial version of the protocol.
+         */
+        valueSet?: SymbolKind[];
+    };
+    /**
+     * The client supports tags on `SymbolInformation`.
+     * Clients supporting tags have to handle unknown tags gracefully.
+     *
+     * @since 3.16.0
+     */
+    tagSupport?: {
+        /**
+         * The tags supported by the client.
+         */
+        valueSet: SymbolTag[];
+    };
+    /**
+     * The client support partial workspace symbols. The client will send the
+     * request `workspaceSymbol/resolve` to the server to resolve additional
+     * properties.
+     *
+     * @since 3.17.0
+     */
+    resolveSupport?: {
+        /**
+         * The properties that a client can resolve lazily. Usually
+         * `location.range`
+         */
+        properties: string[];
+    };
+}
+/**
+ * The parameters of a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * A query string to filter symbols by. Clients may send an empty
+     * string here to request all symbols.
+     */
+    query: string;
+}
+/**
+ * Server capabilities for a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolOptions extends WorkDoneProgressOptions {
+    /**
+     * The server provides support to resolve additional
+     * information for a workspace symbol.
+     *
+     * @since 3.17.0
+     */
+    resolveProvider?: boolean;
+}
+/**
+ * Registration options for a {@link WorkspaceSymbolRequest}.
+ */
+export interface WorkspaceSymbolRegistrationOptions extends WorkspaceSymbolOptions {
+}
+/**
+ * A request to list project-wide symbols matching the query string given
+ * by the {@link WorkspaceSymbolParams}. The response is
+ * of type {@link SymbolInformation SymbolInformation[]} or a Thenable that
+ * resolves to such.
+ *
+ * @since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients
+ *  need to advertise support for WorkspaceSymbols via the client capability
+ *  `workspace.symbol.resolveSupport`.
+ *
+ */
+export declare namespace WorkspaceSymbolRequest {
+    const method: 'workspace/symbol';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<WorkspaceSymbolParams, SymbolInformation[] | WorkspaceSymbol[] | null, SymbolInformation[] | WorkspaceSymbol[], void, WorkspaceSymbolRegistrationOptions>;
+}
+/**
+ * A request to resolve the range inside the workspace
+ * symbol's location.
+ *
+ * @since 3.17.0
+ */
+export declare namespace WorkspaceSymbolResolveRequest {
+    const method: 'workspaceSymbol/resolve';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<WorkspaceSymbol, WorkspaceSymbol, never, void, void>;
+}
+/**
+ * The client capabilities  of a {@link CodeLensRequest}.
+ */
+export interface CodeLensClientCapabilities {
+    /**
+     * Whether code lens supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * @since 3.16.0
+ */
+export interface CodeLensWorkspaceClientCapabilities {
+    /**
+     * 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
+     * code lenses 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;
+}
+/**
+ * The parameters of a {@link CodeLensRequest}.
+ */
+export interface CodeLensParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The document to request code lens for.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * Code Lens provider options of a {@link CodeLensRequest}.
+ */
+export interface CodeLensOptions extends WorkDoneProgressOptions {
+    /**
+     * Code lens has a resolve provider as well.
+     */
+    resolveProvider?: boolean;
+}
+/**
+ * Registration options for a {@link CodeLensRequest}.
+ */
+export interface CodeLensRegistrationOptions extends TextDocumentRegistrationOptions, CodeLensOptions {
+}
+/**
+ * A request to provide code lens for the given text document.
+ */
+export declare namespace CodeLensRequest {
+    const method: 'textDocument/codeLens';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CodeLensParams, CodeLens[] | null, CodeLens[], void, CodeLensRegistrationOptions>;
+}
+/**
+ * A request to resolve a command for a given code lens.
+ */
+export declare namespace CodeLensResolveRequest {
+    const method: 'codeLens/resolve';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<CodeLens, CodeLens, never, void, void>;
+}
+/**
+ * A request to refresh all code actions
+ *
+ * @since 3.16.0
+ */
+export declare namespace CodeLensRefreshRequest {
+    const method: `workspace/codeLens/refresh`;
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType0<void, void, void, void>;
+}
+/**
+ * The client capabilities of a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkClientCapabilities {
+    /**
+     * Whether document link supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Whether the client supports the `tooltip` property on `DocumentLink`.
+     *
+     * @since 3.15.0
+     */
+    tooltipSupport?: boolean;
+}
+/**
+ * The parameters of a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkParams extends WorkDoneProgressParams, PartialResultParams {
+    /**
+     * The document to provide document links for.
+     */
+    textDocument: TextDocumentIdentifier;
+}
+/**
+ * Provider options for a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkOptions extends WorkDoneProgressOptions {
+    /**
+     * Document links have a resolve provider as well.
+     */
+    resolveProvider?: boolean;
+}
+/**
+ * Registration options for a {@link DocumentLinkRequest}.
+ */
+export interface DocumentLinkRegistrationOptions extends TextDocumentRegistrationOptions, DocumentLinkOptions {
+}
+/**
+ * A request to provide document links
+ */
+export declare namespace DocumentLinkRequest {
+    const method: 'textDocument/documentLink';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentLinkParams, DocumentLink[] | null, DocumentLink[], void, DocumentLinkRegistrationOptions>;
+}
+/**
+ * Request to resolve additional information for a given document link. The request's
+ * parameter is of type {@link DocumentLink} the response
+ * is of type {@link DocumentLink} or a Thenable that resolves to such.
+ */
+export declare namespace DocumentLinkResolveRequest {
+    const method: 'documentLink/resolve';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentLink, DocumentLink, never, void, void>;
+}
+/**
+ * Client capabilities of a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingClientCapabilities {
+    /**
+     * Whether formatting supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * The parameters of a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingParams extends WorkDoneProgressParams {
+    /**
+     * The document to format.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The format options.
+     */
+    options: FormattingOptions;
+}
+/**
+ * Provider options for a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingOptions extends WorkDoneProgressOptions {
+}
+/**
+ * Registration options for a {@link DocumentFormattingRequest}.
+ */
+export interface DocumentFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentFormattingOptions {
+}
+/**
+ * A request to format a whole document.
+ */
+export declare namespace DocumentFormattingRequest {
+    const method: 'textDocument/formatting';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentFormattingParams, TextEdit[] | null, never, void, DocumentFormattingRegistrationOptions>;
+}
+/**
+ * Client capabilities of a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingClientCapabilities {
+    /**
+     * Whether range formatting supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Whether the client supports formatting multiple ranges at once.
+     *
+     * @since 3.18.0
+     * @proposed
+     */
+    rangesSupport?: boolean;
+}
+/**
+ * The parameters of a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingParams extends WorkDoneProgressParams {
+    /**
+     * The document to format.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The range to format
+     */
+    range: Range;
+    /**
+     * The format options
+     */
+    options: FormattingOptions;
+}
+/**
+ * The parameters of a {@link DocumentRangesFormattingRequest}.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export interface DocumentRangesFormattingParams extends WorkDoneProgressParams {
+    /**
+     * The document to format.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The ranges to format
+     */
+    ranges: Range[];
+    /**
+     * The format options
+     */
+    options: FormattingOptions;
+}
+/**
+ * Provider options for a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingOptions extends WorkDoneProgressOptions {
+    /**
+     * Whether the server supports formatting multiple ranges at once.
+     *
+     * @since 3.18.0
+     * @proposed
+     */
+    rangesSupport?: boolean;
+}
+/**
+ * Registration options for a {@link DocumentRangeFormattingRequest}.
+ */
+export interface DocumentRangeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentRangeFormattingOptions {
+}
+/**
+ * A request to format a range in a document.
+ */
+export declare namespace DocumentRangeFormattingRequest {
+    const method: 'textDocument/rangeFormatting';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentRangeFormattingParams, TextEdit[] | null, never, void, DocumentRangeFormattingRegistrationOptions>;
+}
+/**
+ * A request to format ranges in a document.
+ *
+ * @since 3.18.0
+ * @proposed
+ */
+export declare namespace DocumentRangesFormattingRequest {
+    const method: 'textDocument/rangesFormatting';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentRangesFormattingParams, TextEdit[] | null, never, void, DocumentRangeFormattingRegistrationOptions>;
+}
+/**
+ * Client capabilities of a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingClientCapabilities {
+    /**
+     * Whether on type formatting supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * The parameters of a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingParams {
+    /**
+     * The document to format.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The position around which the on type formatting should happen.
+     * This is not necessarily the exact position where the character denoted
+     * by the property `ch` got typed.
+     */
+    position: Position;
+    /**
+     * The character that has been typed that triggered the formatting
+     * on type request. That is not necessarily the last character that
+     * got inserted into the document since the client could auto insert
+     * characters as well (e.g. like automatic brace completion).
+     */
+    ch: string;
+    /**
+     * The formatting options.
+     */
+    options: FormattingOptions;
+}
+/**
+ * Provider options for a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingOptions {
+    /**
+     * A character on which formatting should be triggered, like `{`.
+     */
+    firstTriggerCharacter: string;
+    /**
+     * More trigger characters.
+     */
+    moreTriggerCharacter?: string[];
+}
+/**
+ * Registration options for a {@link DocumentOnTypeFormattingRequest}.
+ */
+export interface DocumentOnTypeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentOnTypeFormattingOptions {
+}
+/**
+ * A request to format a document on type.
+ */
+export declare namespace DocumentOnTypeFormattingRequest {
+    const method: 'textDocument/onTypeFormatting';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<DocumentOnTypeFormattingParams, TextEdit[] | null, never, void, DocumentOnTypeFormattingRegistrationOptions>;
+}
+export declare namespace PrepareSupportDefaultBehavior {
+    /**
+     * The client's default behavior is to select the identifier
+     * according the to language's syntax rule.
+     */
+    const Identifier: 1;
+}
+export type PrepareSupportDefaultBehavior = 1;
+export interface RenameClientCapabilities {
+    /**
+     * Whether rename supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+    /**
+     * Client supports testing for validity of rename operations
+     * before execution.
+     *
+     * @since 3.12.0
+     */
+    prepareSupport?: boolean;
+    /**
+     * Client supports the default behavior result.
+     *
+     * The value indicates the default behavior used by the
+     * client.
+     *
+     * @since 3.16.0
+     */
+    prepareSupportDefaultBehavior?: PrepareSupportDefaultBehavior;
+    /**
+     * Whether the client honors the change annotations in
+     * text edits and resource operations returned via the
+     * rename request's workspace edit by for example presenting
+     * the workspace edit in the user interface and asking
+     * for confirmation.
+     *
+     * @since 3.16.0
+     */
+    honorsChangeAnnotations?: boolean;
+}
+/**
+ * The parameters of a {@link RenameRequest}.
+ */
+export interface RenameParams extends WorkDoneProgressParams {
+    /**
+     * The document to rename.
+     */
+    textDocument: TextDocumentIdentifier;
+    /**
+     * The position at which this request was sent.
+     */
+    position: Position;
+    /**
+     * The new name of the symbol. If the given name is not valid the
+     * request must return a {@link ResponseError} with an
+     * appropriate message set.
+     */
+    newName: string;
+}
+/**
+ * Provider options for a {@link RenameRequest}.
+ */
+export interface RenameOptions extends WorkDoneProgressOptions {
+    /**
+     * Renames should be checked and tested before being executed.
+     *
+     * @since version 3.12.0
+     */
+    prepareProvider?: boolean;
+}
+/**
+ * Registration options for a {@link RenameRequest}.
+ */
+export interface RenameRegistrationOptions extends TextDocumentRegistrationOptions, RenameOptions {
+}
+/**
+ * A request to rename a symbol.
+ */
+export declare namespace RenameRequest {
+    const method: 'textDocument/rename';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<RenameParams, WorkspaceEdit | null, never, void, RenameRegistrationOptions>;
+}
+export interface PrepareRenameParams extends TextDocumentPositionParams, WorkDoneProgressParams {
+}
+export type PrepareRenameResult = Range | {
+    range: Range;
+    placeholder: string;
+} | {
+    defaultBehavior: boolean;
+};
+/**
+ * A request to test and perform the setup necessary for a rename.
+ *
+ * @since 3.16 - support for default behavior
+ */
+export declare namespace PrepareRenameRequest {
+    const method: 'textDocument/prepareRename';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<PrepareRenameParams, PrepareRenameResult | null, never, void, void>;
+}
+/**
+ * The client capabilities of a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandClientCapabilities {
+    /**
+     * Execute command supports dynamic registration.
+     */
+    dynamicRegistration?: boolean;
+}
+/**
+ * The parameters of a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandParams extends WorkDoneProgressParams {
+    /**
+     * The identifier of the actual command handler.
+     */
+    command: string;
+    /**
+     * Arguments that the command should be invoked with.
+     */
+    arguments?: LSPAny[];
+}
+/**
+ * The server capabilities of a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandOptions extends WorkDoneProgressOptions {
+    /**
+     * The commands to be executed on the server
+     */
+    commands: string[];
+}
+/**
+ * Registration options for a {@link ExecuteCommandRequest}.
+ */
+export interface ExecuteCommandRegistrationOptions extends ExecuteCommandOptions {
+}
+/**
+ * A request send from the client to the server to execute a command. The request might return
+ * a workspace edit which the client will apply to the workspace.
+ */
+export declare namespace ExecuteCommandRequest {
+    const method: 'workspace/executeCommand';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ExecuteCommandParams, any, never, void, ExecuteCommandRegistrationOptions>;
+}
+export interface WorkspaceEditClientCapabilities {
+    /**
+     * The client supports versioned document changes in `WorkspaceEdit`s
+     */
+    documentChanges?: boolean;
+    /**
+     * The resource operations the client supports. Clients should at least
+     * support 'create', 'rename' and 'delete' files and folders.
+     *
+     * @since 3.13.0
+     */
+    resourceOperations?: ResourceOperationKind[];
+    /**
+     * The failure handling strategy of a client if applying the workspace edit
+     * fails.
+     *
+     * @since 3.13.0
+     */
+    failureHandling?: FailureHandlingKind;
+    /**
+     * Whether the client normalizes line endings to the client specific
+     * setting.
+     * If set to `true` the client will normalize line ending characters
+     * in a workspace edit to the client-specified new line
+     * character.
+     *
+     * @since 3.16.0
+     */
+    normalizesLineEndings?: boolean;
+    /**
+     * Whether the client in general supports change annotations on text edits,
+     * create file, rename file and delete file changes.
+     *
+     * @since 3.16.0
+     */
+    changeAnnotationSupport?: {
+        /**
+         * Whether the client groups edits with equal labels into tree nodes,
+         * for instance all edits labelled with "Changes in Strings" would
+         * be a tree node.
+         */
+        groupsOnLabel?: boolean;
+    };
+}
+/**
+ * The parameters passed via an apply workspace edit request.
+ */
+export interface ApplyWorkspaceEditParams {
+    /**
+     * An optional label of the workspace edit. This label is
+     * presented in the user interface for example on an undo
+     * stack to undo the workspace edit.
+     */
+    label?: string;
+    /**
+     * The edits to apply.
+     */
+    edit: WorkspaceEdit;
+}
+/**
+ * The result returned from the apply workspace edit request.
+ *
+ * @since 3.17 renamed from ApplyWorkspaceEditResponse
+ */
+export interface ApplyWorkspaceEditResult {
+    /**
+     * Indicates whether the edit was applied or not.
+     */
+    applied: boolean;
+    /**
+     * An optional textual description for why the edit was not applied.
+     * This may be used by the server for diagnostic logging or to provide
+     * a suitable error for a request that triggered the edit.
+     */
+    failureReason?: string;
+    /**
+     * Depending on the client's failure handling strategy `failedChange` might
+     * contain the index of the change that failed. This property is only available
+     * if the client signals a `failureHandlingStrategy` in its client capabilities.
+     */
+    failedChange?: uinteger;
+}
+/**
+ * @deprecated Use ApplyWorkspaceEditResult instead.
+ */
+export type ApplyWorkspaceEditResponse = ApplyWorkspaceEditResult;
+/**
+ * A request sent from the server to the client to modified certain resources.
+ */
+export declare namespace ApplyWorkspaceEditRequest {
+    const method: 'workspace/applyEdit';
+    const messageDirection: MessageDirection;
+    const type: ProtocolRequestType<ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, never, void, void>;
+}
+export { ImplementationRequest, ImplementationParams, ImplementationRegistrationOptions, ImplementationOptions, TypeDefinitionRequest, TypeDefinitionParams, TypeDefinitionRegistrationOptions, TypeDefinitionOptions, WorkspaceFoldersRequest, DidChangeWorkspaceFoldersNotification, DidChangeWorkspaceFoldersParams, WorkspaceFoldersChangeEvent, ConfigurationRequest, ConfigurationParams, ConfigurationItem, DocumentColorRequest, ColorPresentationRequest, DocumentColorOptions, DocumentColorParams, ColorPresentationParams, DocumentColorRegistrationOptions, FoldingRangeClientCapabilities, FoldingRangeOptions, FoldingRangeRequest, FoldingRangeParams, FoldingRangeRegistrationOptions, FoldingRangeRefreshRequest, DeclarationClientCapabilities, DeclarationRequest, DeclarationParams, DeclarationRegistrationOptions, DeclarationOptions, SelectionRangeClientCapabilities, SelectionRangeOptions, SelectionRangeParams, SelectionRangeRequest, SelectionRangeRegistrationOptions, WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd, WorkDoneProgress, WorkDoneProgressCreateParams, WorkDoneProgressCreateRequest, WorkDoneProgressCancelParams, WorkDoneProgressCancelNotification, CallHierarchyClientCapabilities, CallHierarchyOptions, CallHierarchyRegistrationOptions, CallHierarchyIncomingCallsParams, CallHierarchyIncomingCallsRequest, CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCallsRequest, CallHierarchyPrepareParams, CallHierarchyPrepareRequest, SemanticTokensPartialResult, SemanticTokensDeltaPartialResult, TokenFormat, SemanticTokensClientCapabilities, SemanticTokensOptions, SemanticTokensRegistrationOptions, SemanticTokensParams, SemanticTokensRequest, SemanticTokensDeltaParams, SemanticTokensDeltaRequest, SemanticTokensRangeParams, SemanticTokensRangeRequest, SemanticTokensRefreshRequest, SemanticTokensRegistrationType, ShowDocumentParams, ShowDocumentRequest, ShowDocumentResult, ShowDocumentClientCapabilities, LinkedEditingRangeClientCapabilities, LinkedEditingRanges, LinkedEditingRangeOptions, LinkedEditingRangeParams, LinkedEditingRangeRegistrationOptions, LinkedEditingRangeRequest, FileOperationOptions, FileOperationClientCapabilities, FileOperationRegistrationOptions, FileOperationPatternOptions, FileOperationPatternKind, DidCreateFilesNotification, CreateFilesParams, FileCreate, WillCreateFilesRequest, DidRenameFilesNotification, RenameFilesParams, FileRename, WillRenameFilesRequest, DidDeleteFilesNotification, DeleteFilesParams, FileDelete, WillDeleteFilesRequest, UniquenessLevel, MonikerKind, Moniker, MonikerClientCapabilities, MonikerOptions, MonikerRegistrationOptions, MonikerParams, MonikerRequest, TypeHierarchyClientCapabilities, TypeHierarchyOptions, TypeHierarchyRegistrationOptions, TypeHierarchyPrepareParams, TypeHierarchyPrepareRequest, TypeHierarchySubtypesParams, TypeHierarchySubtypesRequest, TypeHierarchySupertypesParams, TypeHierarchySupertypesRequest, InlineValueClientCapabilities, InlineValueOptions, InlineValueRegistrationOptions, InlineValueWorkspaceClientCapabilities, InlineValueParams, InlineValueRequest, InlineValueRefreshRequest, InlayHintClientCapabilities, InlayHintOptions, InlayHintRegistrationOptions, InlayHintWorkspaceClientCapabilities, InlayHintParams, InlayHintRequest, InlayHintResolveRequest, InlayHintRefreshRequest, DiagnosticClientCapabilities, DiagnosticOptions, DiagnosticRegistrationOptions, DiagnosticServerCancellationData, DocumentDiagnosticParams, DocumentDiagnosticReportKind, FullDocumentDiagnosticReport, RelatedFullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport, RelatedUnchangedDocumentDiagnosticReport, DocumentDiagnosticReport, DocumentDiagnosticReportPartialResult, DocumentDiagnosticRequest, PreviousResultId, WorkspaceDiagnosticParams, WorkspaceFullDocumentDiagnosticReport, WorkspaceUnchangedDocumentDiagnosticReport, WorkspaceDocumentDiagnosticReport, WorkspaceDiagnosticReport, WorkspaceDiagnosticReportPartialResult, WorkspaceDiagnosticRequest, DiagnosticRefreshRequest, NotebookDocumentSyncClientCapabilities, NotebookCellKind, ExecutionSummary, NotebookCell, NotebookDocument, NotebookDocumentIdentifier, VersionedNotebookDocumentIdentifier, NotebookDocumentSyncOptions, NotebookDocumentSyncRegistrationOptions, NotebookDocumentSyncRegistrationType, DidOpenNotebookDocumentParams, DidOpenNotebookDocumentNotification, NotebookCellArrayChange, NotebookDocumentChangeEvent, DidChangeNotebookDocumentParams, DidChangeNotebookDocumentNotification, DidSaveNotebookDocumentParams, DidSaveNotebookDocumentNotification, DidCloseNotebookDocumentParams, DidCloseNotebookDocumentNotification, InlineCompletionClientCapabilities, InlineCompletionOptions, InlineCompletionParams, InlineCompletionRegistrationOptions, InlineCompletionRequest };
+export { DocumentColorOptions as ColorProviderOptions, DocumentColorOptions as ColorOptions, FoldingRangeOptions as FoldingRangeProviderOptions, SelectionRangeOptions as SelectionRangeProviderOptions, DocumentColorRegistrationOptions as ColorRegistrationOptions };