.config/coc/extensions/node_modules/coc-json/node_modules/vscode-languageserver-protocol/lib/common/protocol.d.ts

   1 import { ProgressToken } from 'vscode-jsonrpc';
   2 import { ProtocolRequestType, ProtocolRequestType0, ProtocolNotificationType, ProtocolNotificationType0 } from './messages';
   3 import { Position, Range, Location, LocationLink, Diagnostic, Command, TextEdit, WorkspaceEdit, DocumentUri, TextDocumentIdentifier, VersionedTextDocumentIdentifier, TextDocumentItem, CompletionItem, CompletionList, Hover, SignatureHelp, ReferenceContext, DocumentHighlight, SymbolInformation, CodeLens, CodeActionContext, FormattingOptions, DocumentLink, MarkupKind, SymbolKind, CompletionItemKind, CodeAction, CodeActionKind, DocumentSymbol, CompletionItemTag, DiagnosticTag, SymbolTag, uinteger, integer, InsertTextMode } from 'vscode-languageserver-types';
   4 import { ImplementationRequest, ImplementationClientCapabilities, ImplementationOptions, ImplementationRegistrationOptions, ImplementationParams } from './protocol.implementation';
   5 import { TypeDefinitionRequest, TypeDefinitionClientCapabilities, TypeDefinitionOptions, TypeDefinitionRegistrationOptions, TypeDefinitionParams } from './protocol.typeDefinition';
   6 import { WorkspaceFoldersRequest, DidChangeWorkspaceFoldersNotification, DidChangeWorkspaceFoldersParams, WorkspaceFolder, WorkspaceFoldersChangeEvent, WorkspaceFoldersInitializeParams, WorkspaceFoldersClientCapabilities, WorkspaceFoldersServerCapabilities } from './protocol.workspaceFolders';
   7 import { ConfigurationRequest, ConfigurationParams, ConfigurationItem, ConfigurationClientCapabilities } from './protocol.configuration';
   8 import { DocumentColorRequest, ColorPresentationRequest, DocumentColorOptions, DocumentColorParams, ColorPresentationParams, DocumentColorClientCapabilities, DocumentColorRegistrationOptions } from './protocol.colorProvider';
   9 import { FoldingRangeClientCapabilities, FoldingRangeOptions, FoldingRangeRequest, FoldingRangeParams, FoldingRangeRegistrationOptions } from './protocol.foldingRange';
  10 import { DeclarationClientCapabilities, DeclarationRequest, DeclarationOptions, DeclarationRegistrationOptions, DeclarationParams } from './protocol.declaration';
  11 import { SelectionRangeClientCapabilities, SelectionRangeOptions, SelectionRangeRequest, SelectionRangeParams, SelectionRangeRegistrationOptions } from './protocol.selectionRange';
  12 import { WorkDoneProgressClientCapabilities, WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd, WorkDoneProgress, WorkDoneProgressCreateParams, WorkDoneProgressCreateRequest, WorkDoneProgressCancelParams, WorkDoneProgressCancelNotification } from './protocol.progress';
  13 import { CallHierarchyClientCapabilities, CallHierarchyOptions, CallHierarchyRegistrationOptions, CallHierarchyIncomingCallsParams, CallHierarchyIncomingCallsRequest, CallHierarchyOutgoingCallsParams, CallHierarchyOutgoingCallsRequest, CallHierarchyPrepareParams, CallHierarchyPrepareRequest } from './protocol.callHierarchy';
  14 import { SemanticTokenTypes, SemanticTokenModifiers, SemanticTokensLegend, SemanticTokens, SemanticTokensPartialResult, SemanticTokensEdit, SemanticTokensDelta, SemanticTokensDeltaPartialResult, TokenFormat, SemanticTokensClientCapabilities, SemanticTokensOptions, SemanticTokensRegistrationOptions, SemanticTokensParams, SemanticTokensRequest, SemanticTokensDeltaParams, SemanticTokensDeltaRequest, SemanticTokensRangeParams, SemanticTokensRangeRequest, SemanticTokensRefreshRequest, SemanticTokensWorkspaceClientCapabilities, SemanticTokensRegistrationType } from './protocol.semanticTokens';
  15 import { ShowDocumentParams, ShowDocumentResult, ShowDocumentRequest, ShowDocumentClientCapabilities } from './protocol.showDocument';
  16 import { LinkedEditingRangeClientCapabilities, LinkedEditingRanges, LinkedEditingRangeOptions, LinkedEditingRangeParams, LinkedEditingRangeRegistrationOptions, LinkedEditingRangeRequest } from './protocol.linkedEditingRange';
  17 import { FileOperationOptions, FileOperationClientCapabilities, FileOperationRegistrationOptions, FileOperationPatternOptions, FileOperationPatternKind, DidCreateFilesNotification, CreateFilesParams, FileCreate, WillCreateFilesRequest, DidRenameFilesNotification, RenameFilesParams, FileRename, WillRenameFilesRequest, DidDeleteFilesNotification, DeleteFilesParams, FileDelete, WillDeleteFilesRequest } from './protocol.fileOperations';
  18 import { UniquenessLevel, MonikerKind, Moniker, MonikerClientCapabilities, MonikerOptions, MonikerRegistrationOptions, MonikerParams, MonikerRequest } from './protocol.moniker';
  19 /**
  20  * A document filter denotes a document by different properties like
  21  * the [language](#TextDocument.languageId), the [scheme](#Uri.scheme) of
  22  * its resource, or a glob-pattern that is applied to the [path](#TextDocument.fileName).
  23  *
  24  * Glob patterns can have the following syntax:
  25  * - `*` to match one or more characters in a path segment
  26  * - `?` to match on one character in a path segment
  27  * - `**` to match any number of path segments, including none
  28  * - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
  29  * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
  30  * - `[!...]` 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`)
  31  *
  32  * @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }`
  33  * @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }`
  34  */
  35 export declare type DocumentFilter = {
  36     /** A language id, like `typescript`. */
  37     language: string;
  38     /** A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
  39     scheme?: string;
  40     /** A glob pattern, like `*.{ts,js}`. */
  41     pattern?: string;
  42 } | {
  43     /** A language id, like `typescript`. */
  44     language?: string;
  45     /** A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
  46     scheme: string;
  47     /** A glob pattern, like `*.{ts,js}`. */
  48     pattern?: string;
  49 } | {
  50     /** A language id, like `typescript`. */
  51     language?: string;
  52     /** A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
  53     scheme?: string;
  54     /** A glob pattern, like `*.{ts,js}`. */
  55     pattern: string;
  56 };
  57 /**
  58  * The DocumentFilter namespace provides helper functions to work with
  59  * [DocumentFilter](#DocumentFilter) literals.
  60  */
  61 export declare namespace DocumentFilter {
  62     function is(value: any): value is DocumentFilter;
  63 }
  64 /**
  65  * A document selector is the combination of one or many document filters.
  66  *
  67  * @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`;
  68  *
  69  * The use of a string as a document filter is deprecated @since 3.16.0.
  70  */
  71 export declare type DocumentSelector = (string | DocumentFilter)[];
  72 /**
  73  * The DocumentSelector namespace provides helper functions to work with
  74  * [DocumentSelector](#DocumentSelector)s.
  75  */
  76 export declare namespace DocumentSelector {
  77     function is(value: any[] | undefined | null): value is DocumentSelector;
  78 }
  79 /**
  80  * General parameters to to register for an notification or to register a provider.
  81  */
  82 export interface Registration {
  83     /**
  84      * The id used to register the request. The id can be used to deregister
  85      * the request again.
  86      */
  87     id: string;
  88     /**
  89      * The method to register for.
  90      */
  91     method: string;
  92     /**
  93      * Options necessary for the registration.
  94      */
  95     registerOptions?: any;
  96 }
  97 export interface RegistrationParams {
  98     registrations: Registration[];
  99 }
 100 /**
 101  * The `client/registerCapability` request is sent from the server to the client to register a new capability
 102  * handler on the client side.
 103  */
 104 export declare namespace RegistrationRequest {
 105     const type: ProtocolRequestType<RegistrationParams, void, never, void, void>;
 106 }
 107 /**
 108  * General parameters to unregister a request or notification.
 109  */
 110 export interface Unregistration {
 111     /**
 112      * The id used to unregister the request or notification. Usually an id
 113      * provided during the register request.
 114      */
 115     id: string;
 116     /**
 117      * The method to unregister for.
 118      */
 119     method: string;
 120 }
 121 export interface UnregistrationParams {
 122     unregisterations: Unregistration[];
 123 }
 124 /**
 125  * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
 126  * handler on the client side.
 127  */
 128 export declare namespace UnregistrationRequest {
 129     const type: ProtocolRequestType<UnregistrationParams, void, never, void, void>;
 130 }
 131 export interface WorkDoneProgressParams {
 132     /**
 133      * An optional token that a server can use to report work done progress.
 134      */
 135     workDoneToken?: ProgressToken;
 136 }
 137 export interface PartialResultParams {
 138     /**
 139      * An optional token that a server can use to report partial results (e.g. streaming) to
 140      * the client.
 141      */
 142     partialResultToken?: ProgressToken;
 143 }
 144 /**
 145  * A parameter literal used in requests to pass a text document and a position inside that
 146  * document.
 147  */
 148 export interface TextDocumentPositionParams {
 149     /**
 150      * The text document.
 151      */
 152     textDocument: TextDocumentIdentifier;
 153     /**
 154      * The position inside the text document.
 155      */
 156     position: Position;
 157 }
 158 /**
 159  * The kind of resource operations supported by the client.
 160  */
 161 export declare type ResourceOperationKind = 'create' | 'rename' | 'delete';
 162 export declare namespace ResourceOperationKind {
 163     /**
 164      * Supports creating new files and folders.
 165      */
 166     const Create: ResourceOperationKind;
 167     /**
 168      * Supports renaming existing files and folders.
 169      */
 170     const Rename: ResourceOperationKind;
 171     /**
 172      * Supports deleting existing files and folders.
 173      */
 174     const Delete: ResourceOperationKind;
 175 }
 176 export declare type FailureHandlingKind = 'abort' | 'transactional' | 'undo' | 'textOnlyTransactional';
 177 export declare namespace FailureHandlingKind {
 178     /**
 179      * Applying the workspace change is simply aborted if one of the changes provided
 180      * fails. All operations executed before the failing operation stay executed.
 181      */
 182     const Abort: FailureHandlingKind;
 183     /**
 184      * All operations are executed transactional. That means they either all
 185      * succeed or no changes at all are applied to the workspace.
 186      */
 187     const Transactional: FailureHandlingKind;
 188     /**
 189      * If the workspace edit contains only textual file changes they are executed transactional.
 190      * If resource changes (create, rename or delete file) are part of the change the failure
 191      * handling strategy is abort.
 192      */
 193     const TextOnlyTransactional: FailureHandlingKind;
 194     /**
 195      * The client tries to undo the operations already executed. But there is no
 196      * guarantee that this is succeeding.
 197      */
 198     const Undo: FailureHandlingKind;
 199 }
 200 /**
 201  * Workspace specific client capabilities.
 202  */
 203 export interface WorkspaceClientCapabilities {
 204     /**
 205      * The client supports applying batch edits
 206      * to the workspace by supporting the request
 207      * 'workspace/applyEdit'
 208      */
 209     applyEdit?: boolean;
 210     /**
 211      * Capabilities specific to `WorkspaceEdit`s
 212      */
 213     workspaceEdit?: WorkspaceEditClientCapabilities;
 214     /**
 215      * Capabilities specific to the `workspace/didChangeConfiguration` notification.
 216      */
 217     didChangeConfiguration?: DidChangeConfigurationClientCapabilities;
 218     /**
 219      * Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
 220      */
 221     didChangeWatchedFiles?: DidChangeWatchedFilesClientCapabilities;
 222     /**
 223      * Capabilities specific to the `workspace/symbol` request.
 224      */
 225     symbol?: WorkspaceSymbolClientCapabilities;
 226     /**
 227      * Capabilities specific to the `workspace/executeCommand` request.
 228      */
 229     executeCommand?: ExecuteCommandClientCapabilities;
 230     /**
 231      * Capabilities specific to the semantic token requests scoped to the
 232      * workspace.
 233      *
 234      * @since 3.16.0.
 235      */
 236     semanticTokens?: SemanticTokensWorkspaceClientCapabilities;
 237     /**
 238      * Capabilities specific to the code lens requests scoped to the
 239      * workspace.
 240      *
 241      * @since 3.16.0.
 242      */
 243     codeLens?: CodeLensWorkspaceClientCapabilities;
 244     /**
 245      * The client has support for file notifications/requests for user operations on files.
 246      *
 247      * Since 3.16.0
 248      */
 249     fileOperations?: FileOperationClientCapabilities;
 250 }
 251 /**
 252  * Text document specific client capabilities.
 253  */
 254 export interface TextDocumentClientCapabilities {
 255     /**
 256      * Defines which synchronization capabilities the client supports.
 257      */
 258     synchronization?: TextDocumentSyncClientCapabilities;
 259     /**
 260      * Capabilities specific to the `textDocument/completion`
 261      */
 262     completion?: CompletionClientCapabilities;
 263     /**
 264      * Capabilities specific to the `textDocument/hover`
 265      */
 266     hover?: HoverClientCapabilities;
 267     /**
 268      * Capabilities specific to the `textDocument/signatureHelp`
 269      */
 270     signatureHelp?: SignatureHelpClientCapabilities;
 271     /**
 272      * Capabilities specific to the `textDocument/declaration`
 273      *
 274      * @since 3.14.0
 275      */
 276     declaration?: DeclarationClientCapabilities;
 277     /**
 278      * Capabilities specific to the `textDocument/definition`
 279      */
 280     definition?: DefinitionClientCapabilities;
 281     /**
 282      * Capabilities specific to the `textDocument/typeDefinition`
 283      *
 284      * @since 3.6.0
 285      */
 286     typeDefinition?: TypeDefinitionClientCapabilities;
 287     /**
 288      * Capabilities specific to the `textDocument/implementation`
 289      *
 290      * @since 3.6.0
 291      */
 292     implementation?: ImplementationClientCapabilities;
 293     /**
 294      * Capabilities specific to the `textDocument/references`
 295      */
 296     references?: ReferenceClientCapabilities;
 297     /**
 298      * Capabilities specific to the `textDocument/documentHighlight`
 299      */
 300     documentHighlight?: DocumentHighlightClientCapabilities;
 301     /**
 302      * Capabilities specific to the `textDocument/documentSymbol`
 303      */
 304     documentSymbol?: DocumentSymbolClientCapabilities;
 305     /**
 306      * Capabilities specific to the `textDocument/codeAction`
 307      */
 308     codeAction?: CodeActionClientCapabilities;
 309     /**
 310      * Capabilities specific to the `textDocument/codeLens`
 311      */
 312     codeLens?: CodeLensClientCapabilities;
 313     /**
 314      * Capabilities specific to the `textDocument/documentLink`
 315      */
 316     documentLink?: DocumentLinkClientCapabilities;
 317     /**
 318      * Capabilities specific to the `textDocument/documentColor`
 319      */
 320     colorProvider?: DocumentColorClientCapabilities;
 321     /**
 322      * Capabilities specific to the `textDocument/formatting`
 323      */
 324     formatting?: DocumentFormattingClientCapabilities;
 325     /**
 326      * Capabilities specific to the `textDocument/rangeFormatting`
 327      */
 328     rangeFormatting?: DocumentRangeFormattingClientCapabilities;
 329     /**
 330      * Capabilities specific to the `textDocument/onTypeFormatting`
 331      */
 332     onTypeFormatting?: DocumentOnTypeFormattingClientCapabilities;
 333     /**
 334      * Capabilities specific to the `textDocument/rename`
 335      */
 336     rename?: RenameClientCapabilities;
 337     /**
 338      * Capabilities specific to `textDocument/foldingRange` request.
 339      *
 340      * @since 3.10.0
 341      */
 342     foldingRange?: FoldingRangeClientCapabilities;
 343     /**
 344      * Capabilities specific to `textDocument/selectionRange` request.
 345      *
 346      * @since 3.15.0
 347      */
 348     selectionRange?: SelectionRangeClientCapabilities;
 349     /**
 350      * Capabilities specific to `textDocument/publishDiagnostics` notification.
 351      */
 352     publishDiagnostics?: PublishDiagnosticsClientCapabilities;
 353     /**
 354      * Capabilities specific to the various call hierarchy request.
 355      *
 356      * @since 3.16.0
 357      */
 358     callHierarchy?: CallHierarchyClientCapabilities;
 359     /**
 360      * Capabilities specific to the various semantic token request.
 361      *
 362      * @since 3.16.0
 363      */
 364     semanticTokens?: SemanticTokensClientCapabilities;
 365     /**
 366      * Capabilities specific to the linked editing range request.
 367      *
 368      * @since 3.16.0
 369      */
 370     linkedEditingRange?: LinkedEditingRangeClientCapabilities;
 371     /**
 372      * Client capabilities specific to the moniker request.
 373      *
 374      * @since 3.16.0
 375      */
 376     moniker: MonikerClientCapabilities;
 377 }
 378 export interface WindowClientCapabilities {
 379     /**
 380      * Whether client supports handling progress notifications. If set
 381      * servers are allowed to report in `workDoneProgress` property in the
 382      * request specific server capabilities.
 383      *
 384      * @since 3.15.0
 385      */
 386     workDoneProgress?: boolean;
 387     /**
 388      * Capabilities specific to the showMessage request.
 389      *
 390      * @since 3.16.0
 391      */
 392     showMessage?: ShowMessageRequestClientCapabilities;
 393     /**
 394      * Capabilities specific to the showDocument request.
 395      *
 396      * @since 3.16.0
 397      */
 398     showDocument?: ShowDocumentClientCapabilities;
 399 }
 400 /**
 401  * Client capabilities specific to regular expressions.
 402  *
 403  * @since 3.16.0
 404  */
 405 export interface RegularExpressionsClientCapabilities {
 406     /**
 407      * The engine's name.
 408      */
 409     engine: string;
 410     /**
 411      * The engine's version.
 412      */
 413     version?: string;
 414 }
 415 /**
 416  * Client capabilities specific to the used markdown parser.
 417  *
 418  * @since 3.16.0
 419  */
 420 export interface MarkdownClientCapabilities {
 421     /**
 422      * The name of the parser.
 423      */
 424     parser: string;
 425     /**
 426      * The version of the parser.
 427      */
 428     version?: string;
 429 }
 430 /**
 431  * General client capabilities.
 432  *
 433  * @since 3.16.0
 434  */
 435 export interface GeneralClientCapabilities {
 436     /**
 437      * Client capabilities specific to regular expressions.
 438      *
 439      * @since 3.16.0
 440      */
 441     regularExpressions?: RegularExpressionsClientCapabilities;
 442     /**
 443      * Client capabilities specific to the client's markdown parser.
 444      *
 445      * @since 3.16.0
 446      */
 447     markdown?: MarkdownClientCapabilities;
 448 }
 449 /**
 450  * Defines the capabilities provided by the client.
 451  */
 452 export interface _ClientCapabilities {
 453     /**
 454      * Workspace specific client capabilities.
 455      */
 456     workspace?: WorkspaceClientCapabilities;
 457     /**
 458      * Text document specific client capabilities.
 459      */
 460     textDocument?: TextDocumentClientCapabilities;
 461     /**
 462      * Window specific client capabilities.
 463      */
 464     window?: WindowClientCapabilities;
 465     /**
 466      * General client capabilities.
 467      *
 468      * @since 3.16.0
 469      */
 470     general?: GeneralClientCapabilities;
 471     /**
 472      * Experimental client capabilities.
 473      */
 474     experimental?: object;
 475 }
 476 export declare type ClientCapabilities = _ClientCapabilities & WorkspaceFoldersClientCapabilities & ConfigurationClientCapabilities & WorkDoneProgressClientCapabilities;
 477 /**
 478  * Static registration options to be returned in the initialize
 479  * request.
 480  */
 481 export interface StaticRegistrationOptions {
 482     /**
 483      * The id used to register the request. The id can be used to deregister
 484      * the request again. See also Registration#id.
 485      */
 486     id?: string;
 487 }
 488 /**
 489  * The StaticRegistrationOptions namespace provides helper functions to work with
 490  * [StaticRegistrationOptions](#StaticRegistrationOptions) literals.
 491  */
 492 export declare namespace StaticRegistrationOptions {
 493     function hasId(value: object): value is {
 494         id: string;
 495     };
 496 }
 497 /**
 498  * General text document registration options.
 499  */
 500 export interface TextDocumentRegistrationOptions {
 501     /**
 502      * A document selector to identify the scope of the registration. If set to null
 503      * the document selector provided on the client side will be used.
 504      */
 505     documentSelector: DocumentSelector | null;
 506 }
 507 /**
 508  * The TextDocumentRegistrationOptions namespace provides helper functions to work with
 509  * [TextDocumentRegistrationOptions](#TextDocumentRegistrationOptions) literals.
 510  */
 511 export declare namespace TextDocumentRegistrationOptions {
 512     function is(value: any): value is TextDocumentRegistrationOptions;
 513 }
 514 /**
 515  * Save options.
 516  */
 517 export interface SaveOptions {
 518     /**
 519      * The client is supposed to include the content on save.
 520      */
 521     includeText?: boolean;
 522 }
 523 export interface WorkDoneProgressOptions {
 524     workDoneProgress?: boolean;
 525 }
 526 /**
 527  * The WorkDoneProgressOptions namespace provides helper functions to work with
 528  * [WorkDoneProgressOptions](#WorkDoneProgressOptions) literals.
 529  */
 530 export declare namespace WorkDoneProgressOptions {
 531     function is(value: any): value is WorkDoneProgressOptions;
 532     function hasWorkDoneProgress(value: any): value is {
 533         workDoneProgress: boolean;
 534     };
 535 }
 536 /**
 537  * Defines the capabilities provided by a language
 538  * server.
 539  */
 540 export interface _ServerCapabilities<T = any> {
 541     /**
 542      * Defines how text documents are synced. Is either a detailed structure defining each notification or
 543      * for backwards compatibility the TextDocumentSyncKind number.
 544      */
 545     textDocumentSync?: TextDocumentSyncOptions | TextDocumentSyncKind;
 546     /**
 547      * The server provides completion support.
 548      */
 549     completionProvider?: CompletionOptions;
 550     /**
 551      * The server provides hover support.
 552      */
 553     hoverProvider?: boolean | HoverOptions;
 554     /**
 555      * The server provides signature help support.
 556      */
 557     signatureHelpProvider?: SignatureHelpOptions;
 558     /**
 559      * The server provides Goto Declaration support.
 560      */
 561     declarationProvider?: boolean | DeclarationOptions | DeclarationRegistrationOptions;
 562     /**
 563      * The server provides goto definition support.
 564      */
 565     definitionProvider?: boolean | DefinitionOptions;
 566     /**
 567      * The server provides Goto Type Definition support.
 568      */
 569     typeDefinitionProvider?: boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions;
 570     /**
 571      * The server provides Goto Implementation support.
 572      */
 573     implementationProvider?: boolean | ImplementationOptions | ImplementationRegistrationOptions;
 574     /**
 575      * The server provides find references support.
 576      */
 577     referencesProvider?: boolean | ReferenceOptions;
 578     /**
 579      * The server provides document highlight support.
 580      */
 581     documentHighlightProvider?: boolean | DocumentHighlightOptions;
 582     /**
 583      * The server provides document symbol support.
 584      */
 585     documentSymbolProvider?: boolean | DocumentSymbolOptions;
 586     /**
 587      * The server provides code actions. CodeActionOptions may only be
 588      * specified if the client states that it supports
 589      * `codeActionLiteralSupport` in its initial `initialize` request.
 590      */
 591     codeActionProvider?: boolean | CodeActionOptions;
 592     /**
 593      * The server provides code lens.
 594      */
 595     codeLensProvider?: CodeLensOptions;
 596     /**
 597      * The server provides document link support.
 598      */
 599     documentLinkProvider?: DocumentLinkOptions;
 600     /**
 601      * The server provides color provider support.
 602      */
 603     colorProvider?: boolean | DocumentColorOptions | DocumentColorRegistrationOptions;
 604     /**
 605      * The server provides workspace symbol support.
 606      */
 607     workspaceSymbolProvider?: boolean | WorkspaceSymbolOptions;
 608     /**
 609      * The server provides document formatting.
 610      */
 611     documentFormattingProvider?: boolean | DocumentFormattingOptions;
 612     /**
 613      * The server provides document range formatting.
 614      */
 615     documentRangeFormattingProvider?: boolean | DocumentRangeFormattingOptions;
 616     /**
 617      * The server provides document formatting on typing.
 618      */
 619     documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions;
 620     /**
 621      * The server provides rename support. RenameOptions may only be
 622      * specified if the client states that it supports
 623      * `prepareSupport` in its initial `initialize` request.
 624      */
 625     renameProvider?: boolean | RenameOptions;
 626     /**
 627      * The server provides folding provider support.
 628      */
 629     foldingRangeProvider?: boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions;
 630     /**
 631      * The server provides selection range support.
 632      */
 633     selectionRangeProvider?: boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions;
 634     /**
 635      * The server provides execute command support.
 636      */
 637     executeCommandProvider?: ExecuteCommandOptions;
 638     /**
 639      * The server provides call hierarchy support.
 640      *
 641      * @since 3.16.0
 642      */
 643     callHierarchyProvider?: boolean | CallHierarchyOptions | CallHierarchyRegistrationOptions;
 644     /**
 645      * The server provides linked editing range support.
 646      *
 647      * @since 3.16.0
 648      */
 649     linkedEditingRangeProvider?: boolean | LinkedEditingRangeOptions | LinkedEditingRangeRegistrationOptions;
 650     /**
 651      * The server provides semantic tokens support.
 652      *
 653      * @since 3.16.0
 654      */
 655     semanticTokensProvider?: SemanticTokensOptions | SemanticTokensRegistrationOptions;
 656     /**
 657      * Window specific server capabilities.
 658      */
 659     workspace?: {
 660         /**
 661         * The server is interested in notifications/requests for operations on files.
 662         *
 663         * @since 3.16.0
 664         */
 665         fileOperations?: FileOperationOptions;
 666     };
 667     /**
 668      * The server provides moniker support.
 669      *
 670      * @since 3.16.0
 671      */
 672     monikerProvider?: boolean | MonikerOptions | MonikerRegistrationOptions;
 673     /**
 674      * Experimental server capabilities.
 675      */
 676     experimental?: T;
 677 }
 678 export declare type ServerCapabilities<T = any> = _ServerCapabilities<T> & WorkspaceFoldersServerCapabilities;
 679 /**
 680  * The initialize request is sent from the client to the server.
 681  * It is sent once as the request after starting up the server.
 682  * The requests parameter is of type [InitializeParams](#InitializeParams)
 683  * the response if of type [InitializeResult](#InitializeResult) of a Thenable that
 684  * resolves to such.
 685  */
 686 export declare namespace InitializeRequest {
 687     const type: ProtocolRequestType<_InitializeParams & WorkspaceFoldersInitializeParams & WorkDoneProgressParams, InitializeResult<any>, never, InitializeError, void>;
 688 }
 689 /**
 690  * The initialize parameters
 691  */
 692 export interface _InitializeParams extends WorkDoneProgressParams {
 693     /**
 694      * The process Id of the parent process that started
 695      * the server.
 696      */
 697     processId: integer | null;
 698     /**
 699      * Information about the client
 700      *
 701      * @since 3.15.0
 702      */
 703     clientInfo?: {
 704         /**
 705          * The name of the client as defined by the client.
 706          */
 707         name: string;
 708         /**
 709          * The client's version as defined by the client.
 710          */
 711         version?: string;
 712     };
 713     /**
 714      * The locale the client is currently showing the user interface
 715      * in. This must not necessarily be the locale of the operating
 716      * system.
 717      *
 718      * Uses IETF language tags as the value's syntax
 719      * (See https://en.wikipedia.org/wiki/IETF_language_tag)
 720      *
 721      * @since 3.16.0
 722      */
 723     locale?: string;
 724     /**
 725      * The rootPath of the workspace. Is null
 726      * if no folder is open.
 727      *
 728      * @deprecated in favour of rootUri.
 729      */
 730     rootPath?: string | null;
 731     /**
 732      * The rootUri of the workspace. Is null if no
 733      * folder is open. If both `rootPath` and `rootUri` are set
 734      * `rootUri` wins.
 735      *
 736      * @deprecated in favour of workspaceFolders.
 737      */
 738     rootUri: DocumentUri | null;
 739     /**
 740      * The capabilities provided by the client (editor or tool)
 741      */
 742     capabilities: ClientCapabilities;
 743     /**
 744      * User provided initialization options.
 745      */
 746     initializationOptions?: any;
 747     /**
 748      * The initial trace setting. If omitted trace is disabled ('off').
 749      */
 750     trace?: 'off' | 'messages' | 'verbose';
 751 }
 752 export declare type InitializeParams = _InitializeParams & WorkspaceFoldersInitializeParams;
 753 /**
 754  * The result returned from an initialize request.
 755  */
 756 export interface InitializeResult<T = any> {
 757     /**
 758      * The capabilities the language server provides.
 759      */
 760     capabilities: ServerCapabilities<T>;
 761     /**
 762      * Information about the server.
 763      *
 764      * @since 3.15.0
 765      */
 766     serverInfo?: {
 767         /**
 768          * The name of the server as defined by the server.
 769          */
 770         name: string;
 771         /**
 772          * The server's version as defined by the server.
 773          */
 774         version?: string;
 775     };
 776     /**
 777      * Custom initialization results.
 778      */
 779     [custom: string]: any;
 780 }
 781 /**
 782  * Known error codes for an `InitializeError`;
 783  */
 784 export declare namespace InitializeError {
 785     /**
 786      * If the protocol version provided by the client can't be handled by the server.
 787      * @deprecated This initialize error got replaced by client capabilities. There is
 788      * no version handshake in version 3.0x
 789      */
 790     const unknownProtocolVersion: 1;
 791 }
 792 /**
 793  * The data type of the ResponseError if the
 794  * initialize request fails.
 795  */
 796 export interface InitializeError {
 797     /**
 798      * Indicates whether the client execute the following retry logic:
 799      * (1) show the message provided by the ResponseError to the user
 800      * (2) user selects retry or cancel
 801      * (3) if user selected retry the initialize method is sent again.
 802      */
 803     retry: boolean;
 804 }
 805 export interface InitializedParams {
 806 }
 807 /**
 808  * The initialized notification is sent from the client to the
 809  * server after the client is fully initialized and the server
 810  * is allowed to send requests from the server to the client.
 811  */
 812 export declare namespace InitializedNotification {
 813     const type: ProtocolNotificationType<InitializedParams, void>;
 814 }
 815 /**
 816  * A shutdown request is sent from the client to the server.
 817  * It is sent once when the client decides to shutdown the
 818  * server. The only notification that is sent after a shutdown request
 819  * is the exit event.
 820  */
 821 export declare namespace ShutdownRequest {
 822     const type: ProtocolRequestType0<void, never, void, void>;
 823 }
 824 /**
 825  * The exit event is sent from the client to the server to
 826  * ask the server to exit its process.
 827  */
 828 export declare namespace ExitNotification {
 829     const type: ProtocolNotificationType0<void>;
 830 }
 831 export interface DidChangeConfigurationClientCapabilities {
 832     /**
 833      * Did change configuration notification supports dynamic registration.
 834      */
 835     dynamicRegistration?: boolean;
 836 }
 837 /**
 838  * The configuration change notification is sent from the client to the server
 839  * when the client's configuration has changed. The notification contains
 840  * the changed configuration as defined by the language client.
 841  */
 842 export declare namespace DidChangeConfigurationNotification {
 843     const type: ProtocolNotificationType<DidChangeConfigurationParams, DidChangeConfigurationRegistrationOptions>;
 844 }
 845 export interface DidChangeConfigurationRegistrationOptions {
 846     section?: string | string[];
 847 }
 848 /**
 849  * The parameters of a change configuration notification.
 850  */
 851 export interface DidChangeConfigurationParams {
 852     /**
 853      * The actual changed settings
 854      */
 855     settings: any;
 856 }
 857 /**
 858  * The message type
 859  */
 860 export declare namespace MessageType {
 861     /**
 862      * An error message.
 863      */
 864     const Error = 1;
 865     /**
 866      * A warning message.
 867      */
 868     const Warning = 2;
 869     /**
 870      * An information message.
 871      */
 872     const Info = 3;
 873     /**
 874      * A log message.
 875      */
 876     const Log = 4;
 877 }
 878 export declare type MessageType = 1 | 2 | 3 | 4;
 879 /**
 880  * The parameters of a notification message.
 881  */
 882 export interface ShowMessageParams {
 883     /**
 884      * The message type. See {@link MessageType}
 885      */
 886     type: MessageType;
 887     /**
 888      * The actual message
 889      */
 890     message: string;
 891 }
 892 /**
 893  * The show message notification is sent from a server to a client to ask
 894  * the client to display a particular message in the user interface.
 895  */
 896 export declare namespace ShowMessageNotification {
 897     const type: ProtocolNotificationType<ShowMessageParams, void>;
 898 }
 899 /**
 900  * Show message request client capabilities
 901  */
 902 export interface ShowMessageRequestClientCapabilities {
 903     /**
 904      * Capabilities specific to the `MessageActionItem` type.
 905      */
 906     messageActionItem?: {
 907         /**
 908          * Whether the client supports additional attributes which
 909          * are preserved and send back to the server in the
 910          * request's response.
 911          */
 912         additionalPropertiesSupport?: boolean;
 913     };
 914 }
 915 export interface MessageActionItem {
 916     /**
 917      * A short title like 'Retry', 'Open Log' etc.
 918      */
 919     title: string;
 920     /**
 921      * Additional attributes that the client preserves and
 922      * sends back to the server. This depends on the client
 923      * capability window.messageActionItem.additionalPropertiesSupport
 924      */
 925     [key: string]: string | boolean | integer | object;
 926 }
 927 export interface ShowMessageRequestParams {
 928     /**
 929      * The message type. See {@link MessageType}
 930      */
 931     type: MessageType;
 932     /**
 933      * The actual message
 934      */
 935     message: string;
 936     /**
 937      * The message action items to present.
 938      */
 939     actions?: MessageActionItem[];
 940 }
 941 /**
 942  * The show message request is sent from the server to the client to show a message
 943  * and a set of options actions to the user.
 944  */
 945 export declare namespace ShowMessageRequest {
 946     const type: ProtocolRequestType<ShowMessageRequestParams, MessageActionItem | null, never, void, void>;
 947 }
 948 /**
 949  * The log message notification is sent from the server to the client to ask
 950  * the client to log a particular message.
 951  */
 952 export declare namespace LogMessageNotification {
 953     const type: ProtocolNotificationType<LogMessageParams, void>;
 954 }
 955 /**
 956  * The log message parameters.
 957  */
 958 export interface LogMessageParams {
 959     /**
 960      * The message type. See {@link MessageType}
 961      */
 962     type: MessageType;
 963     /**
 964      * The actual message
 965      */
 966     message: string;
 967 }
 968 /**
 969  * The telemetry event notification is sent from the server to the client to ask
 970  * the client to log telemetry data.
 971  */
 972 export declare namespace TelemetryEventNotification {
 973     const type: ProtocolNotificationType<any, void>;
 974 }
 975 export interface TextDocumentSyncClientCapabilities {
 976     /**
 977      * Whether text document synchronization supports dynamic registration.
 978      */
 979     dynamicRegistration?: boolean;
 980     /**
 981      * The client supports sending will save notifications.
 982      */
 983     willSave?: boolean;
 984     /**
 985      * The client supports sending a will save request and
 986      * waits for a response providing text edits which will
 987      * be applied to the document before it is saved.
 988      */
 989     willSaveWaitUntil?: boolean;
 990     /**
 991      * The client supports did save notifications.
 992      */
 993     didSave?: boolean;
 994 }
 995 /**
 996  * Defines how the host (editor) should sync
 997  * document changes to the language server.
 998  */
 999 export declare namespace TextDocumentSyncKind {
1000     /**
1001      * Documents should not be synced at all.
1002      */
1003     const None = 0;
1004     /**
1005      * Documents are synced by always sending the full content
1006      * of the document.
1007      */
1008     const Full = 1;
1009     /**
1010      * Documents are synced by sending the full content on open.
1011      * After that only incremental updates to the document are
1012      * send.
1013      */
1014     const Incremental = 2;
1015 }
1016 export declare type TextDocumentSyncKind = 0 | 1 | 2;
1017 export interface TextDocumentSyncOptions {
1018     /**
1019      * Open and close notifications are sent to the server. If omitted open close notification should not
1020      * be sent.
1021      */
1022     openClose?: boolean;
1023     /**
1024      * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
1025      * and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None.
1026      */
1027     change?: TextDocumentSyncKind;
1028     /**
1029      * If present will save notifications are sent to the server. If omitted the notification should not be
1030      * sent.
1031      */
1032     willSave?: boolean;
1033     /**
1034      * If present will save wait until requests are sent to the server. If omitted the request should not be
1035      * sent.
1036      */
1037     willSaveWaitUntil?: boolean;
1038     /**
1039      * If present save notifications are sent to the server. If omitted the notification should not be
1040      * sent.
1041      */
1042     save?: boolean | SaveOptions;
1043 }
1044 /**
1045  * The parameters send in a open text document notification
1046  */
1047 export interface DidOpenTextDocumentParams {
1048     /**
1049      * The document that was opened.
1050      */
1051     textDocument: TextDocumentItem;
1052 }
1053 /**
1054  * The document open notification is sent from the client to the server to signal
1055  * newly opened text documents. The document's truth is now managed by the client
1056  * and the server must not try to read the document's truth using the document's
1057  * uri. Open in this sense means it is managed by the client. It doesn't necessarily
1058  * mean that its content is presented in an editor. An open notification must not
1059  * be sent more than once without a corresponding close notification send before.
1060  * This means open and close notification must be balanced and the max open count
1061  * is one.
1062  */
1063 export declare namespace DidOpenTextDocumentNotification {
1064     const method: 'textDocument/didOpen';
1065     const type: ProtocolNotificationType<DidOpenTextDocumentParams, TextDocumentRegistrationOptions>;
1066 }
1067 /**
1068  * An event describing a change to a text document. If range and rangeLength are omitted
1069  * the new text is considered to be the full content of the document.
1070  */
1071 export declare type TextDocumentContentChangeEvent = {
1072     /**
1073      * The range of the document that changed.
1074      */
1075     range: Range;
1076     /**
1077      * The optional length of the range that got replaced.
1078      *
1079      * @deprecated use range instead.
1080      */
1081     rangeLength?: uinteger;
1082     /**
1083      * The new text for the provided range.
1084      */
1085     text: string;
1086 } | {
1087     /**
1088      * The new text of the whole document.
1089      */
1090     text: string;
1091 };
1092 export declare namespace TextDocumentContentChangeEvent {
1093     /**
1094      * Checks whether the information describes a delta event.
1095      */
1096     function isIncremental(event: TextDocumentContentChangeEvent): event is {
1097         range: Range;
1098         rangeLength?: uinteger;
1099         text: string;
1100     };
1101     /**
1102      * Checks whether the information describes a full replacement event.
1103      */
1104     function isFull(event: TextDocumentContentChangeEvent): event is {
1105         text: string;
1106     };
1107 }
1108 /**
1109  * The change text document notification's parameters.
1110  */
1111 export interface DidChangeTextDocumentParams {
1112     /**
1113      * The document that did change. The version number points
1114      * to the version after all provided content changes have
1115      * been applied.
1116      */
1117     textDocument: VersionedTextDocumentIdentifier;
1118     /**
1119      * The actual content changes. The content changes describe single state changes
1120      * to the document. So if there are two content changes c1 (at array index 0) and
1121      * c2 (at array index 1) for a document in state S then c1 moves the document from
1122      * S to S' and c2 from S' to S''. So c1 is computed on the state S and c2 is computed
1123      * on the state S'.
1124      *
1125      * To mirror the content of a document using change events use the following approach:
1126      * - start with the same initial content
1127      * - apply the 'textDocument/didChange' notifications in the order you receive them.
1128      * - apply the `TextDocumentContentChangeEvent`s in a single notification in the order
1129      *   you receive them.
1130      */
1131     contentChanges: TextDocumentContentChangeEvent[];
1132 }
1133 /**
1134  * Describe options to be used when registered for text document change events.
1135  */
1136 export interface TextDocumentChangeRegistrationOptions extends TextDocumentRegistrationOptions {
1137     /**
1138      * How documents are synced to the server.
1139      */
1140     syncKind: TextDocumentSyncKind;
1141 }
1142 /**
1143  * The document change notification is sent from the client to the server to signal
1144  * changes to a text document.
1145  */
1146 export declare namespace DidChangeTextDocumentNotification {
1147     const method: 'textDocument/didChange';
1148     const type: ProtocolNotificationType<DidChangeTextDocumentParams, TextDocumentChangeRegistrationOptions>;
1149 }
1150 /**
1151  * The parameters send in a close text document notification
1152  */
1153 export interface DidCloseTextDocumentParams {
1154     /**
1155      * The document that was closed.
1156      */
1157     textDocument: TextDocumentIdentifier;
1158 }
1159 /**
1160  * The document close notification is sent from the client to the server when
1161  * the document got closed in the client. The document's truth now exists where
1162  * the document's uri points to (e.g. if the document's uri is a file uri the
1163  * truth now exists on disk). As with the open notification the close notification
1164  * is about managing the document's content. Receiving a close notification
1165  * doesn't mean that the document was open in an editor before. A close
1166  * notification requires a previous open notification to be sent.
1167  */
1168 export declare namespace DidCloseTextDocumentNotification {
1169     const method: 'textDocument/didClose';
1170     const type: ProtocolNotificationType<DidCloseTextDocumentParams, TextDocumentRegistrationOptions>;
1171 }
1172 /**
1173  * The parameters send in a save text document notification
1174  */
1175 export interface DidSaveTextDocumentParams {
1176     /**
1177      * The document that was closed.
1178      */
1179     textDocument: TextDocumentIdentifier;
1180     /**
1181      * Optional the content when saved. Depends on the includeText value
1182      * when the save notification was requested.
1183      */
1184     text?: string;
1185 }
1186 /**
1187  * Save registration options.
1188  */
1189 export interface TextDocumentSaveRegistrationOptions extends TextDocumentRegistrationOptions, SaveOptions {
1190 }
1191 /**
1192  * The document save notification is sent from the client to the server when
1193  * the document got saved in the client.
1194  */
1195 export declare namespace DidSaveTextDocumentNotification {
1196     const method: 'textDocument/didSave';
1197     const type: ProtocolNotificationType<DidSaveTextDocumentParams, TextDocumentSaveRegistrationOptions>;
1198 }
1199 /**
1200  * Represents reasons why a text document is saved.
1201  */
1202 export declare namespace TextDocumentSaveReason {
1203     /**
1204      * Manually triggered, e.g. by the user pressing save, by starting debugging,
1205      * or by an API call.
1206      */
1207     const Manual: 1;
1208     /**
1209      * Automatic after a delay.
1210      */
1211     const AfterDelay: 2;
1212     /**
1213      * When the editor lost focus.
1214      */
1215     const FocusOut: 3;
1216 }
1217 export declare type TextDocumentSaveReason = 1 | 2 | 3;
1218 /**
1219  * The parameters send in a will save text document notification.
1220  */
1221 export interface WillSaveTextDocumentParams {
1222     /**
1223      * The document that will be saved.
1224      */
1225     textDocument: TextDocumentIdentifier;
1226     /**
1227      * The 'TextDocumentSaveReason'.
1228      */
1229     reason: TextDocumentSaveReason;
1230 }
1231 /**
1232  * A document will save notification is sent from the client to the server before
1233  * the document is actually saved.
1234  */
1235 export declare namespace WillSaveTextDocumentNotification {
1236     const method: 'textDocument/willSave';
1237     const type: ProtocolNotificationType<WillSaveTextDocumentParams, TextDocumentRegistrationOptions>;
1238 }
1239 /**
1240  * A document will save request is sent from the client to the server before
1241  * the document is actually saved. The request can return an array of TextEdits
1242  * which will be applied to the text document before it is saved. Please note that
1243  * clients might drop results if computing the text edits took too long or if a
1244  * server constantly fails on this request. This is done to keep the save fast and
1245  * reliable.
1246  */
1247 export declare namespace WillSaveTextDocumentWaitUntilRequest {
1248     const method: 'textDocument/willSaveWaitUntil';
1249     const type: ProtocolRequestType<WillSaveTextDocumentParams, TextEdit[] | null, never, void, TextDocumentRegistrationOptions>;
1250 }
1251 export interface DidChangeWatchedFilesClientCapabilities {
1252     /**
1253      * Did change watched files notification supports dynamic registration. Please note
1254      * that the current protocol doesn't support static configuration for file changes
1255      * from the server side.
1256      */
1257     dynamicRegistration?: boolean;
1258 }
1259 /**
1260  * The watched files notification is sent from the client to the server when
1261  * the client detects changes to file watched by the language client.
1262  */
1263 export declare namespace DidChangeWatchedFilesNotification {
1264     const type: ProtocolNotificationType<DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions>;
1265 }
1266 /**
1267  * The watched files change notification's parameters.
1268  */
1269 export interface DidChangeWatchedFilesParams {
1270     /**
1271      * The actual file events.
1272      */
1273     changes: FileEvent[];
1274 }
1275 /**
1276  * The file event type
1277  */
1278 export declare namespace FileChangeType {
1279     /**
1280      * The file got created.
1281      */
1282     const Created = 1;
1283     /**
1284      * The file got changed.
1285      */
1286     const Changed = 2;
1287     /**
1288      * The file got deleted.
1289      */
1290     const Deleted = 3;
1291 }
1292 export declare type FileChangeType = 1 | 2 | 3;
1293 /**
1294  * An event describing a file change.
1295  */
1296 export interface FileEvent {
1297     /**
1298      * The file's uri.
1299      */
1300     uri: DocumentUri;
1301     /**
1302      * The change type.
1303      */
1304     type: FileChangeType;
1305 }
1306 /**
1307  * Describe options to be used when registered for text document change events.
1308  */
1309 export interface DidChangeWatchedFilesRegistrationOptions {
1310     /**
1311      * The watchers to register.
1312      */
1313     watchers: FileSystemWatcher[];
1314 }
1315 export interface FileSystemWatcher {
1316     /**
1317      * The  glob pattern to watch. Glob patterns can have the following syntax:
1318      * - `*` to match one or more characters in a path segment
1319      * - `?` to match on one character in a path segment
1320      * - `**` to match any number of path segments, including none
1321      * - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
1322      * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
1323      * - `[!...]` 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`)
1324      */
1325     globPattern: string;
1326     /**
1327      * The kind of events of interest. If omitted it defaults
1328      * to WatchKind.Create | WatchKind.Change | WatchKind.Delete
1329      * which is 7.
1330      */
1331     kind?: uinteger;
1332 }
1333 export declare namespace WatchKind {
1334     /**
1335      * Interested in create events.
1336      */
1337     const Create = 1;
1338     /**
1339      * Interested in change events
1340      */
1341     const Change = 2;
1342     /**
1343      * Interested in delete events
1344      */
1345     const Delete = 4;
1346 }
1347 /**
1348  * The publish diagnostic client capabilities.
1349  */
1350 export interface PublishDiagnosticsClientCapabilities {
1351     /**
1352      * Whether the clients accepts diagnostics with related information.
1353      */
1354     relatedInformation?: boolean;
1355     /**
1356      * Client supports the tag property to provide meta data about a diagnostic.
1357      * Clients supporting tags have to handle unknown tags gracefully.
1358      *
1359      * @since 3.15.0
1360      */
1361     tagSupport?: {
1362         /**
1363          * The tags supported by the client.
1364          */
1365         valueSet: DiagnosticTag[];
1366     };
1367     /**
1368      * Whether the client interprets the version property of the
1369      * `textDocument/publishDiagnostics` notification`s parameter.
1370      *
1371      * @since 3.15.0
1372      */
1373     versionSupport?: boolean;
1374     /**
1375      * Client supports a codeDescription property
1376      *
1377      * @since 3.16.0
1378      */
1379     codeDescriptionSupport?: boolean;
1380     /**
1381      * Whether code action supports the `data` property which is
1382      * preserved between a `textDocument/publishDiagnostics` and
1383      * `textDocument/codeAction` request.
1384      *
1385      * @since 3.16.0
1386      */
1387     dataSupport?: boolean;
1388 }
1389 /**
1390  * The publish diagnostic notification's parameters.
1391  */
1392 export interface PublishDiagnosticsParams {
1393     /**
1394      * The URI for which diagnostic information is reported.
1395      */
1396     uri: DocumentUri;
1397     /**
1398      * Optional the version number of the document the diagnostics are published for.
1399      *
1400      * @since 3.15.0
1401      */
1402     version?: integer;
1403     /**
1404      * An array of diagnostic information items.
1405      */
1406     diagnostics: Diagnostic[];
1407 }
1408 /**
1409  * Diagnostics notification are sent from the server to the client to signal
1410  * results of validation runs.
1411  */
1412 export declare namespace PublishDiagnosticsNotification {
1413     const type: ProtocolNotificationType<PublishDiagnosticsParams, void>;
1414 }
1415 /**
1416  * Completion client capabilities
1417  */
1418 export interface CompletionClientCapabilities {
1419     /**
1420      * Whether completion supports dynamic registration.
1421      */
1422     dynamicRegistration?: boolean;
1423     /**
1424      * The client supports the following `CompletionItem` specific
1425      * capabilities.
1426      */
1427     completionItem?: {
1428         /**
1429          * Client supports snippets as insert text.
1430          *
1431          * A snippet can define tab stops and placeholders with `$1`, `$2`
1432          * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
1433          * the end of the snippet. Placeholders with equal identifiers are linked,
1434          * that is typing in one will update others too.
1435          */
1436         snippetSupport?: boolean;
1437         /**
1438          * Client supports commit characters on a completion item.
1439          */
1440         commitCharactersSupport?: boolean;
1441         /**
1442          * Client supports the follow content formats for the documentation
1443          * property. The order describes the preferred format of the client.
1444          */
1445         documentationFormat?: MarkupKind[];
1446         /**
1447          * Client supports the deprecated property on a completion item.
1448          */
1449         deprecatedSupport?: boolean;
1450         /**
1451          * Client supports the preselect property on a completion item.
1452          */
1453         preselectSupport?: boolean;
1454         /**
1455          * Client supports to kee
1456          */
1457         /**
1458          * Client supports the tag property on a completion item. Clients supporting
1459          * tags have to handle unknown tags gracefully. Clients especially need to
1460          * preserve unknown tags when sending a completion item back to the server in
1461          * a resolve call.
1462          *
1463          * @since 3.15.0
1464          */
1465         tagSupport?: {
1466             /**
1467              * The tags supported by the client.
1468              */
1469             valueSet: CompletionItemTag[];
1470         };
1471         /**
1472          * Client support insert replace edit to control different behavior if a
1473          * completion item is inserted in the text or should replace text.
1474          *
1475          * @since 3.16.0
1476          */
1477         insertReplaceSupport?: boolean;
1478         /**
1479          * Indicates which properties a client can resolve lazily on a completion
1480          * item. Before version 3.16.0 only the predefined properties `documentation`
1481          * and `details` could be resolved lazily.
1482          *
1483          * @since 3.16.0
1484          */
1485         resolveSupport?: {
1486             /**
1487              * The properties that a client can resolve lazily.
1488              */
1489             properties: string[];
1490         };
1491         /**
1492          * The client supports the `insertTextMode` property on
1493          * a completion item to override the whitespace handling mode
1494          * as defined by the client (see `insertTextMode`).
1495          *
1496          * @since 3.16.0
1497          */
1498         insertTextModeSupport?: {
1499             valueSet: InsertTextMode[];
1500         };
1501     };
1502     completionItemKind?: {
1503         /**
1504          * The completion item kind values the client supports. When this
1505          * property exists the client also guarantees that it will
1506          * handle values outside its set gracefully and falls back
1507          * to a default value when unknown.
1508          *
1509          * If this property is not present the client only supports
1510          * the completion items kinds from `Text` to `Reference` as defined in
1511          * the initial version of the protocol.
1512          */
1513         valueSet?: CompletionItemKind[];
1514     };
1515     /**
1516      * Defines how the client handles whitespace and indentation
1517      * when accepting a completion item that uses multi line
1518      * text in either `insertText` or `textEdit`.
1519      *
1520      * @since 3.16.0
1521      */
1522     insertTextMode?: InsertTextMode;
1523     /**
1524      * The client supports to send additional context information for a
1525      * `textDocument/completion` request.
1526      */
1527     contextSupport?: boolean;
1528 }
1529 /**
1530  * How a completion was triggered
1531  */
1532 export declare namespace CompletionTriggerKind {
1533     /**
1534      * Completion was triggered by typing an identifier (24x7 code
1535      * complete), manual invocation (e.g Ctrl+Space) or via API.
1536      */
1537     const Invoked: 1;
1538     /**
1539      * Completion was triggered by a trigger character specified by
1540      * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
1541      */
1542     const TriggerCharacter: 2;
1543     /**
1544      * Completion was re-triggered as current completion list is incomplete
1545      */
1546     const TriggerForIncompleteCompletions: 3;
1547 }
1548 export declare type CompletionTriggerKind = 1 | 2 | 3;
1549 /**
1550  * Contains additional information about the context in which a completion request is triggered.
1551  */
1552 export interface CompletionContext {
1553     /**
1554      * How the completion was triggered.
1555      */
1556     triggerKind: CompletionTriggerKind;
1557     /**
1558      * The trigger character (a single character) that has trigger code complete.
1559      * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
1560      */
1561     triggerCharacter?: string;
1562 }
1563 /**
1564  * Completion parameters
1565  */
1566 export interface CompletionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
1567     /**
1568      * The completion context. This is only available it the client specifies
1569      * to send this using the client capability `textDocument.completion.contextSupport === true`
1570      */
1571     context?: CompletionContext;
1572 }
1573 /**
1574  * Completion options.
1575  */
1576 export interface CompletionOptions extends WorkDoneProgressOptions {
1577     /**
1578      * Most tools trigger completion request automatically without explicitly requesting
1579      * it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user
1580      * starts to type an identifier. For example if the user types `c` in a JavaScript file
1581      * code complete will automatically pop up present `console` besides others as a
1582      * completion item. Characters that make up identifiers don't need to be listed here.
1583      *
1584      * If code complete should automatically be trigger on characters not being valid inside
1585      * an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
1586      */
1587     triggerCharacters?: string[];
1588     /**
1589      * The list of all possible characters that commit a completion. This field can be used
1590      * if clients don't support individual commit characters per completion item. See
1591      * `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport`
1592      *
1593      * If a server provides both `allCommitCharacters` and commit characters on an individual
1594      * completion item the ones on the completion item win.
1595      *
1596      * @since 3.2.0
1597      */
1598     allCommitCharacters?: string[];
1599     /**
1600      * The server provides support to resolve additional
1601      * information for a completion item.
1602      */
1603     resolveProvider?: boolean;
1604 }
1605 /**
1606  * Registration options for a [CompletionRequest](#CompletionRequest).
1607  */
1608 export interface CompletionRegistrationOptions extends TextDocumentRegistrationOptions, CompletionOptions {
1609 }
1610 /**
1611  * Request to request completion at a given text document position. The request's
1612  * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response
1613  * is of type [CompletionItem[]](#CompletionItem) or [CompletionList](#CompletionList)
1614  * or a Thenable that resolves to such.
1615  *
1616  * The request can delay the computation of the [`detail`](#CompletionItem.detail)
1617  * and [`documentation`](#CompletionItem.documentation) properties to the `completionItem/resolve`
1618  * request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
1619  * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
1620  */
1621 export declare namespace CompletionRequest {
1622     const method: 'textDocument/completion';
1623     const type: ProtocolRequestType<CompletionParams, CompletionList | CompletionItem[] | null, CompletionItem[], void, CompletionRegistrationOptions>;
1624 }
1625 /**
1626  * Request to resolve additional information for a given completion item.The request's
1627  * parameter is of type [CompletionItem](#CompletionItem) the response
1628  * is of type [CompletionItem](#CompletionItem) or a Thenable that resolves to such.
1629  */
1630 export declare namespace CompletionResolveRequest {
1631     const method: 'completionItem/resolve';
1632     const type: ProtocolRequestType<CompletionItem, CompletionItem, never, void, void>;
1633 }
1634 export interface HoverClientCapabilities {
1635     /**
1636      * Whether hover supports dynamic registration.
1637      */
1638     dynamicRegistration?: boolean;
1639     /**
1640      * Client supports the follow content formats for the content
1641      * property. The order describes the preferred format of the client.
1642      */
1643     contentFormat?: MarkupKind[];
1644 }
1645 /**
1646  * Hover options.
1647  */
1648 export interface HoverOptions extends WorkDoneProgressOptions {
1649 }
1650 /**
1651  * Parameters for a [HoverRequest](#HoverRequest).
1652  */
1653 export interface HoverParams extends TextDocumentPositionParams, WorkDoneProgressParams {
1654 }
1655 /**
1656  * Registration options for a [HoverRequest](#HoverRequest).
1657  */
1658 export interface HoverRegistrationOptions extends TextDocumentRegistrationOptions, HoverOptions {
1659 }
1660 /**
1661  * Request to request hover information at a given text document position. The request's
1662  * parameter is of type [TextDocumentPosition](#TextDocumentPosition) the response is of
1663  * type [Hover](#Hover) or a Thenable that resolves to such.
1664  */
1665 export declare namespace HoverRequest {
1666     const method: 'textDocument/hover';
1667     const type: ProtocolRequestType<HoverParams, Hover | null, never, void, HoverRegistrationOptions>;
1668 }
1669 /**
1670  * Client Capabilities for a [SignatureHelpRequest](#SignatureHelpRequest).
1671  */
1672 export interface SignatureHelpClientCapabilities {
1673     /**
1674      * Whether signature help supports dynamic registration.
1675      */
1676     dynamicRegistration?: boolean;
1677     /**
1678      * The client supports the following `SignatureInformation`
1679      * specific properties.
1680      */
1681     signatureInformation?: {
1682         /**
1683          * Client supports the follow content formats for the documentation
1684          * property. The order describes the preferred format of the client.
1685          */
1686         documentationFormat?: MarkupKind[];
1687         /**
1688          * Client capabilities specific to parameter information.
1689          */
1690         parameterInformation?: {
1691             /**
1692              * The client supports processing label offsets instead of a
1693              * simple label string.
1694              *
1695              * @since 3.14.0
1696              */
1697             labelOffsetSupport?: boolean;
1698         };
1699         /**
1700          * The client support the `activeParameter` property on `SignatureInformation`
1701          * literal.
1702          *
1703          * @since 3.16.0
1704          */
1705         activeParameterSupport?: boolean;
1706     };
1707     /**
1708      * The client supports to send additional context information for a
1709      * `textDocument/signatureHelp` request. A client that opts into
1710      * contextSupport will also support the `retriggerCharacters` on
1711      * `SignatureHelpOptions`.
1712      *
1713      * @since 3.15.0
1714      */
1715     contextSupport?: boolean;
1716 }
1717 /**
1718  * Server Capabilities for a [SignatureHelpRequest](#SignatureHelpRequest).
1719  */
1720 export interface SignatureHelpOptions extends WorkDoneProgressOptions {
1721     /**
1722      * List of characters that trigger signature help.
1723      */
1724     triggerCharacters?: string[];
1725     /**
1726      * List of characters that re-trigger signature help.
1727      *
1728      * These trigger characters are only active when signature help is already showing. All trigger characters
1729      * are also counted as re-trigger characters.
1730      *
1731      * @since 3.15.0
1732      */
1733     retriggerCharacters?: string[];
1734 }
1735 /**
1736  * How a signature help was triggered.
1737  *
1738  * @since 3.15.0
1739  */
1740 export declare namespace SignatureHelpTriggerKind {
1741     /**
1742      * Signature help was invoked manually by the user or by a command.
1743      */
1744     const Invoked: 1;
1745     /**
1746      * Signature help was triggered by a trigger character.
1747      */
1748     const TriggerCharacter: 2;
1749     /**
1750      * Signature help was triggered by the cursor moving or by the document content changing.
1751      */
1752     const ContentChange: 3;
1753 }
1754 export declare type SignatureHelpTriggerKind = 1 | 2 | 3;
1755 /**
1756  * Additional information about the context in which a signature help request was triggered.
1757  *
1758  * @since 3.15.0
1759  */
1760 export interface SignatureHelpContext {
1761     /**
1762      * Action that caused signature help to be triggered.
1763      */
1764     triggerKind: SignatureHelpTriggerKind;
1765     /**
1766      * Character that caused signature help to be triggered.
1767      *
1768      * This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
1769      */
1770     triggerCharacter?: string;
1771     /**
1772      * `true` if signature help was already showing when it was triggered.
1773      *
1774      * Retrigger occurs when the signature help is already active and can be caused by actions such as
1775      * typing a trigger character, a cursor move, or document content changes.
1776      */
1777     isRetrigger: boolean;
1778     /**
1779      * The currently active `SignatureHelp`.
1780      *
1781      * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
1782      * the user navigating through available signatures.
1783      */
1784     activeSignatureHelp?: SignatureHelp;
1785 }
1786 /**
1787  * Parameters for a [SignatureHelpRequest](#SignatureHelpRequest).
1788  */
1789 export interface SignatureHelpParams extends TextDocumentPositionParams, WorkDoneProgressParams {
1790     /**
1791      * The signature help context. This is only available if the client specifies
1792      * to send this using the client capability `textDocument.signatureHelp.contextSupport === true`
1793      *
1794      * @since 3.15.0
1795      */
1796     context?: SignatureHelpContext;
1797 }
1798 /**
1799  * Registration options for a [SignatureHelpRequest](#SignatureHelpRequest).
1800  */
1801 export interface SignatureHelpRegistrationOptions extends TextDocumentRegistrationOptions, SignatureHelpOptions {
1802 }
1803 export declare namespace SignatureHelpRequest {
1804     const method: 'textDocument/signatureHelp';
1805     const type: ProtocolRequestType<SignatureHelpParams, SignatureHelp | null, never, void, SignatureHelpRegistrationOptions>;
1806 }
1807 /**
1808  * Client Capabilities for a [DefinitionRequest](#DefinitionRequest).
1809  */
1810 export interface DefinitionClientCapabilities {
1811     /**
1812      * Whether definition supports dynamic registration.
1813      */
1814     dynamicRegistration?: boolean;
1815     /**
1816      * The client supports additional metadata in the form of definition links.
1817      *
1818      * @since 3.14.0
1819      */
1820     linkSupport?: boolean;
1821 }
1822 /**
1823  * Server Capabilities for a [DefinitionRequest](#DefinitionRequest).
1824  */
1825 export interface DefinitionOptions extends WorkDoneProgressOptions {
1826 }
1827 /**
1828  * Parameters for a [DefinitionRequest](#DefinitionRequest).
1829  */
1830 export interface DefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
1831 }
1832 /**
1833  * Registration options for a [DefinitionRequest](#DefinitionRequest).
1834  */
1835 export interface DefinitionRegistrationOptions extends TextDocumentRegistrationOptions, DefinitionOptions {
1836 }
1837 /**
1838  * A request to resolve the definition location of a symbol at a given text
1839  * document position. The request's parameter is of type [TextDocumentPosition]
1840  * (#TextDocumentPosition) the response is of either type [Definition](#Definition)
1841  * or a typed array of [DefinitionLink](#DefinitionLink) or a Thenable that resolves
1842  * to such.
1843  */
1844 export declare namespace DefinitionRequest {
1845     const method: 'textDocument/definition';
1846     const type: ProtocolRequestType<DefinitionParams, Location | Location[] | LocationLink[] | null, Location[] | LocationLink[], void, DefinitionRegistrationOptions>;
1847 }
1848 /**
1849  * Client Capabilities for a [ReferencesRequest](#ReferencesRequest).
1850  */
1851 export interface ReferenceClientCapabilities {
1852     /**
1853      * Whether references supports dynamic registration.
1854      */
1855     dynamicRegistration?: boolean;
1856 }
1857 /**
1858  * Parameters for a [ReferencesRequest](#ReferencesRequest).
1859  */
1860 export interface ReferenceParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
1861     context: ReferenceContext;
1862 }
1863 /**
1864  * Reference options.
1865  */
1866 export interface ReferenceOptions extends WorkDoneProgressOptions {
1867 }
1868 /**
1869  * Registration options for a [ReferencesRequest](#ReferencesRequest).
1870  */
1871 export interface ReferenceRegistrationOptions extends TextDocumentRegistrationOptions, ReferenceOptions {
1872 }
1873 /**
1874  * A request to resolve project-wide references for the symbol denoted
1875  * by the given text document position. The request's parameter is of
1876  * type [ReferenceParams](#ReferenceParams) the response is of type
1877  * [Location[]](#Location) or a Thenable that resolves to such.
1878  */
1879 export declare namespace ReferencesRequest {
1880     const method: 'textDocument/references';
1881     const type: ProtocolRequestType<ReferenceParams, Location[] | null, Location[], void, ReferenceRegistrationOptions>;
1882 }
1883 /**
1884  * Client Capabilities for a [DocumentHighlightRequest](#DocumentHighlightRequest).
1885  */
1886 export interface DocumentHighlightClientCapabilities {
1887     /**
1888      * Whether document highlight supports dynamic registration.
1889      */
1890     dynamicRegistration?: boolean;
1891 }
1892 /**
1893  * Parameters for a [DocumentHighlightRequest](#DocumentHighlightRequest).
1894  */
1895 export interface DocumentHighlightParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
1896 }
1897 /**
1898  * Provider options for a [DocumentHighlightRequest](#DocumentHighlightRequest).
1899  */
1900 export interface DocumentHighlightOptions extends WorkDoneProgressOptions {
1901 }
1902 /**
1903  * Registration options for a [DocumentHighlightRequest](#DocumentHighlightRequest).
1904  */
1905 export interface DocumentHighlightRegistrationOptions extends TextDocumentRegistrationOptions, DocumentHighlightOptions {
1906 }
1907 /**
1908  * Request to resolve a [DocumentHighlight](#DocumentHighlight) for a given
1909  * text document position. The request's parameter is of type [TextDocumentPosition]
1910  * (#TextDocumentPosition) the request response is of type [DocumentHighlight[]]
1911  * (#DocumentHighlight) or a Thenable that resolves to such.
1912  */
1913 export declare namespace DocumentHighlightRequest {
1914     const method: 'textDocument/documentHighlight';
1915     const type: ProtocolRequestType<DocumentHighlightParams, DocumentHighlight[] | null, DocumentHighlight[], void, DocumentHighlightRegistrationOptions>;
1916 }
1917 /**
1918  * Client Capabilities for a [DocumentSymbolRequest](#DocumentSymbolRequest).
1919  */
1920 export interface DocumentSymbolClientCapabilities {
1921     /**
1922      * Whether document symbol supports dynamic registration.
1923      */
1924     dynamicRegistration?: boolean;
1925     /**
1926      * Specific capabilities for the `SymbolKind`.
1927      */
1928     symbolKind?: {
1929         /**
1930          * The symbol kind values the client supports. When this
1931          * property exists the client also guarantees that it will
1932          * handle values outside its set gracefully and falls back
1933          * to a default value when unknown.
1934          *
1935          * If this property is not present the client only supports
1936          * the symbol kinds from `File` to `Array` as defined in
1937          * the initial version of the protocol.
1938          */
1939         valueSet?: SymbolKind[];
1940     };
1941     /**
1942      * The client support hierarchical document symbols.
1943      */
1944     hierarchicalDocumentSymbolSupport?: boolean;
1945     /**
1946      * The client supports tags on `SymbolInformation`. Tags are supported on
1947      * `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true.
1948      * Clients supporting tags have to handle unknown tags gracefully.
1949      *
1950      * @since 3.16.0
1951      */
1952     tagSupport?: {
1953         /**
1954          * The tags supported by the client.
1955          */
1956         valueSet: SymbolTag[];
1957     };
1958     /**
1959      * The client supports an additional label presented in the UI when
1960      * registering a document symbol provider.
1961      *
1962      * @since 3.16.0
1963      */
1964     labelSupport?: boolean;
1965 }
1966 /**
1967  * Parameters for a [DocumentSymbolRequest](#DocumentSymbolRequest).
1968  */
1969 export interface DocumentSymbolParams extends WorkDoneProgressParams, PartialResultParams {
1970     /**
1971      * The text document.
1972      */
1973     textDocument: TextDocumentIdentifier;
1974 }
1975 /**
1976  * Provider options for a [DocumentSymbolRequest](#DocumentSymbolRequest).
1977  */
1978 export interface DocumentSymbolOptions extends WorkDoneProgressOptions {
1979     /**
1980      * A human-readable string that is shown when multiple outlines trees
1981      * are shown for the same document.
1982      *
1983      * @since 3.16.0
1984      */
1985     label?: string;
1986 }
1987 /**
1988  * Registration options for a [DocumentSymbolRequest](#DocumentSymbolRequest).
1989  */
1990 export interface DocumentSymbolRegistrationOptions extends TextDocumentRegistrationOptions, DocumentSymbolOptions {
1991 }
1992 /**
1993  * A request to list all symbols found in a given text document. The request's
1994  * parameter is of type [TextDocumentIdentifier](#TextDocumentIdentifier) the
1995  * response is of type [SymbolInformation[]](#SymbolInformation) or a Thenable
1996  * that resolves to such.
1997  */
1998 export declare namespace DocumentSymbolRequest {
1999     const method: 'textDocument/documentSymbol';
2000     const type: ProtocolRequestType<DocumentSymbolParams, DocumentSymbol[] | SymbolInformation[] | null, DocumentSymbol[] | SymbolInformation[], void, DocumentSymbolRegistrationOptions>;
2001 }
2002 /**
2003  * The Client Capabilities of a [CodeActionRequest](#CodeActionRequest).
2004  */
2005 export interface CodeActionClientCapabilities {
2006     /**
2007      * Whether code action supports dynamic registration.
2008      */
2009     dynamicRegistration?: boolean;
2010     /**
2011      * The client support code action literals of type `CodeAction` as a valid
2012      * response of the `textDocument/codeAction` request. If the property is not
2013      * set the request can only return `Command` literals.
2014      *
2015      * @since 3.8.0
2016      */
2017     codeActionLiteralSupport?: {
2018         /**
2019          * The code action kind is support with the following value
2020          * set.
2021          */
2022         codeActionKind: {
2023             /**
2024              * The code action kind values the client supports. When this
2025              * property exists the client also guarantees that it will
2026              * handle values outside its set gracefully and falls back
2027              * to a default value when unknown.
2028              */
2029             valueSet: CodeActionKind[];
2030         };
2031     };
2032     /**
2033      * Whether code action supports the `isPreferred` property.
2034      *
2035      * @since 3.15.0
2036      */
2037     isPreferredSupport?: boolean;
2038     /**
2039      * Whether code action supports the `disabled` property.
2040      *
2041      * @since 3.16.0
2042      */
2043     disabledSupport?: boolean;
2044     /**
2045      * Whether code action supports the `data` property which is
2046      * preserved between a `textDocument/codeAction` and a
2047      * `codeAction/resolve` request.
2048      *
2049      * @since 3.16.0
2050      */
2051     dataSupport?: boolean;
2052     /**
2053      * Whether the client support resolving additional code action
2054      * properties via a separate `codeAction/resolve` request.
2055      *
2056      * @since 3.16.0
2057      */
2058     resolveSupport?: {
2059         /**
2060          * The properties that a client can resolve lazily.
2061          */
2062         properties: string[];
2063     };
2064     /**
2065      * Whether th client honors the change annotations in
2066      * text edits and resource operations returned via the
2067      * `CodeAction#edit` property by for example presenting
2068      * the workspace edit in the user interface and asking
2069      * for confirmation.
2070      *
2071      * @since 3.16.0
2072      */
2073     honorsChangeAnnotations?: boolean;
2074 }
2075 /**
2076  * The parameters of a [CodeActionRequest](#CodeActionRequest).
2077  */
2078 export interface CodeActionParams extends WorkDoneProgressParams, PartialResultParams {
2079     /**
2080      * The document in which the command was invoked.
2081      */
2082     textDocument: TextDocumentIdentifier;
2083     /**
2084      * The range for which the command was invoked.
2085      */
2086     range: Range;
2087     /**
2088      * Context carrying additional information.
2089      */
2090     context: CodeActionContext;
2091 }
2092 /**
2093  * Provider options for a [CodeActionRequest](#CodeActionRequest).
2094  */
2095 export interface CodeActionOptions extends WorkDoneProgressOptions {
2096     /**
2097      * CodeActionKinds that this server may return.
2098      *
2099      * The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
2100      * may list out every specific kind they provide.
2101      */
2102     codeActionKinds?: CodeActionKind[];
2103     /**
2104      * The server provides support to resolve additional
2105      * information for a code action.
2106      *
2107      * @since 3.16.0
2108      */
2109     resolveProvider?: boolean;
2110 }
2111 /**
2112  * Registration options for a [CodeActionRequest](#CodeActionRequest).
2113  */
2114 export interface CodeActionRegistrationOptions extends TextDocumentRegistrationOptions, CodeActionOptions {
2115 }
2116 /**
2117  * A request to provide commands for the given text document and range.
2118  */
2119 export declare namespace CodeActionRequest {
2120     const method: 'textDocument/codeAction';
2121     const type: ProtocolRequestType<CodeActionParams, (Command | CodeAction)[] | null, (Command | CodeAction)[], void, CodeActionRegistrationOptions>;
2122 }
2123 /**
2124  * Request to resolve additional information for a given code action.The request's
2125  * parameter is of type [CodeAction](#CodeAction) the response
2126  * is of type [CodeAction](#CodeAction) or a Thenable that resolves to such.
2127  */
2128 export declare namespace CodeActionResolveRequest {
2129     const method: 'codeAction/resolve';
2130     const type: ProtocolRequestType<CodeAction, CodeAction, never, void, void>;
2131 }
2132 /**
2133  * Client capabilities for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
2134  */
2135 export interface WorkspaceSymbolClientCapabilities {
2136     /**
2137      * Symbol request supports dynamic registration.
2138      */
2139     dynamicRegistration?: boolean;
2140     /**
2141      * Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
2142      */
2143     symbolKind?: {
2144         /**
2145          * The symbol kind values the client supports. When this
2146          * property exists the client also guarantees that it will
2147          * handle values outside its set gracefully and falls back
2148          * to a default value when unknown.
2149          *
2150          * If this property is not present the client only supports
2151          * the symbol kinds from `File` to `Array` as defined in
2152          * the initial version of the protocol.
2153          */
2154         valueSet?: SymbolKind[];
2155     };
2156     /**
2157      * The client supports tags on `SymbolInformation`.
2158      * Clients supporting tags have to handle unknown tags gracefully.
2159      *
2160      * @since 3.16.0
2161      */
2162     tagSupport?: {
2163         /**
2164          * The tags supported by the client.
2165          */
2166         valueSet: SymbolTag[];
2167     };
2168 }
2169 /**
2170  * The parameters of a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
2171  */
2172 export interface WorkspaceSymbolParams extends WorkDoneProgressParams, PartialResultParams {
2173     /**
2174      * A query string to filter symbols by. Clients may send an empty
2175      * string here to request all symbols.
2176      */
2177     query: string;
2178 }
2179 /**
2180  * Server capabilities for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
2181  */
2182 export interface WorkspaceSymbolOptions extends WorkDoneProgressOptions {
2183 }
2184 /**
2185  * Registration options for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
2186  */
2187 export interface WorkspaceSymbolRegistrationOptions extends WorkspaceSymbolOptions {
2188 }
2189 /**
2190  * A request to list project-wide symbols matching the query string given
2191  * by the [WorkspaceSymbolParams](#WorkspaceSymbolParams). The response is
2192  * of type [SymbolInformation[]](#SymbolInformation) or a Thenable that
2193  * resolves to such.
2194  */
2195 export declare namespace WorkspaceSymbolRequest {
2196     const method: 'workspace/symbol';
2197     const type: ProtocolRequestType<WorkspaceSymbolParams, SymbolInformation[] | null, SymbolInformation[], void, WorkspaceSymbolRegistrationOptions>;
2198 }
2199 /**
2200  * The client capabilities  of a [CodeLensRequest](#CodeLensRequest).
2201  */
2202 export interface CodeLensClientCapabilities {
2203     /**
2204      * Whether code lens supports dynamic registration.
2205      */
2206     dynamicRegistration?: boolean;
2207 }
2208 /**
2209  * @since 3.16.0
2210  */
2211 export interface CodeLensWorkspaceClientCapabilities {
2212     /**
2213      * Whether the client implementation supports a refresh request sent from the
2214      * server to the client.
2215      *
2216      * Note that this event is global and will force the client to refresh all
2217      * code lenses currently shown. It should be used with absolute care and is
2218      * useful for situation where a server for example detect a project wide
2219      * change that requires such a calculation.
2220      */
2221     refreshSupport?: boolean;
2222 }
2223 /**
2224  * The parameters of a [CodeLensRequest](#CodeLensRequest).
2225  */
2226 export interface CodeLensParams extends WorkDoneProgressParams, PartialResultParams {
2227     /**
2228      * The document to request code lens for.
2229      */
2230     textDocument: TextDocumentIdentifier;
2231 }
2232 /**
2233  * Code Lens provider options of a [CodeLensRequest](#CodeLensRequest).
2234  */
2235 export interface CodeLensOptions extends WorkDoneProgressOptions {
2236     /**
2237      * Code lens has a resolve provider as well.
2238      */
2239     resolveProvider?: boolean;
2240 }
2241 /**
2242  * Registration options for a [CodeLensRequest](#CodeLensRequest).
2243  */
2244 export interface CodeLensRegistrationOptions extends TextDocumentRegistrationOptions, CodeLensOptions {
2245 }
2246 /**
2247  * A request to provide code lens for the given text document.
2248  */
2249 export declare namespace CodeLensRequest {
2250     const method: 'textDocument/codeLens';
2251     const type: ProtocolRequestType<CodeLensParams, CodeLens[] | null, CodeLens[], void, CodeLensRegistrationOptions>;
2252 }
2253 /**
2254  * A request to resolve a command for a given code lens.
2255  */
2256 export declare namespace CodeLensResolveRequest {
2257     const method: 'codeLens/resolve';
2258     const type: ProtocolRequestType<CodeLens, CodeLens, never, void, void>;
2259 }
2260 /**
2261  * A request to refresh all code actions
2262  *
2263  * @since 3.16.0
2264  */
2265 export declare namespace CodeLensRefreshRequest {
2266     const method: `workspace/codeLens/refresh`;
2267     const type: ProtocolRequestType0<void, void, void, void>;
2268 }
2269 /**
2270  * The client capabilities of a [DocumentLinkRequest](#DocumentLinkRequest).
2271  */
2272 export interface DocumentLinkClientCapabilities {
2273     /**
2274      * Whether document link supports dynamic registration.
2275      */
2276     dynamicRegistration?: boolean;
2277     /**
2278      * Whether the client support the `tooltip` property on `DocumentLink`.
2279      *
2280      * @since 3.15.0
2281      */
2282     tooltipSupport?: boolean;
2283 }
2284 /**
2285  * The parameters of a [DocumentLinkRequest](#DocumentLinkRequest).
2286  */
2287 export interface DocumentLinkParams extends WorkDoneProgressParams, PartialResultParams {
2288     /**
2289      * The document to provide document links for.
2290      */
2291     textDocument: TextDocumentIdentifier;
2292 }
2293 /**
2294  * Provider options for a [DocumentLinkRequest](#DocumentLinkRequest).
2295  */
2296 export interface DocumentLinkOptions extends WorkDoneProgressOptions {
2297     /**
2298      * Document links have a resolve provider as well.
2299      */
2300     resolveProvider?: boolean;
2301 }
2302 /**
2303  * Registration options for a [DocumentLinkRequest](#DocumentLinkRequest).
2304  */
2305 export interface DocumentLinkRegistrationOptions extends TextDocumentRegistrationOptions, DocumentLinkOptions {
2306 }
2307 /**
2308  * A request to provide document links
2309  */
2310 export declare namespace DocumentLinkRequest {
2311     const method: 'textDocument/documentLink';
2312     const type: ProtocolRequestType<DocumentLinkParams, DocumentLink[] | null, DocumentLink[], void, DocumentLinkRegistrationOptions>;
2313 }
2314 /**
2315  * Request to resolve additional information for a given document link. The request's
2316  * parameter is of type [DocumentLink](#DocumentLink) the response
2317  * is of type [DocumentLink](#DocumentLink) or a Thenable that resolves to such.
2318  */
2319 export declare namespace DocumentLinkResolveRequest {
2320     const method: 'documentLink/resolve';
2321     const type: ProtocolRequestType<DocumentLink, DocumentLink, never, void, void>;
2322 }
2323 /**
2324  * Client capabilities of a [DocumentFormattingRequest](#DocumentFormattingRequest).
2325  */
2326 export interface DocumentFormattingClientCapabilities {
2327     /**
2328      * Whether formatting supports dynamic registration.
2329      */
2330     dynamicRegistration?: boolean;
2331 }
2332 /**
2333  * The parameters of a [DocumentFormattingRequest](#DocumentFormattingRequest).
2334  */
2335 export interface DocumentFormattingParams extends WorkDoneProgressParams {
2336     /**
2337      * The document to format.
2338      */
2339     textDocument: TextDocumentIdentifier;
2340     /**
2341      * The format options
2342      */
2343     options: FormattingOptions;
2344 }
2345 /**
2346  * Provider options for a [DocumentFormattingRequest](#DocumentFormattingRequest).
2347  */
2348 export interface DocumentFormattingOptions extends WorkDoneProgressOptions {
2349 }
2350 /**
2351  * Registration options for a [DocumentFormattingRequest](#DocumentFormattingRequest).
2352  */
2353 export interface DocumentFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentFormattingOptions {
2354 }
2355 /**
2356  * A request to to format a whole document.
2357  */
2358 export declare namespace DocumentFormattingRequest {
2359     const method: 'textDocument/formatting';
2360     const type: ProtocolRequestType<DocumentFormattingParams, TextEdit[] | null, never, void, DocumentFormattingRegistrationOptions>;
2361 }
2362 /**
2363  * Client capabilities of a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
2364  */
2365 export interface DocumentRangeFormattingClientCapabilities {
2366     /**
2367      * Whether range formatting supports dynamic registration.
2368      */
2369     dynamicRegistration?: boolean;
2370 }
2371 /**
2372  * The parameters of a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
2373  */
2374 export interface DocumentRangeFormattingParams extends WorkDoneProgressParams {
2375     /**
2376      * The document to format.
2377      */
2378     textDocument: TextDocumentIdentifier;
2379     /**
2380      * The range to format
2381      */
2382     range: Range;
2383     /**
2384      * The format options
2385      */
2386     options: FormattingOptions;
2387 }
2388 /**
2389  * Provider options for a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
2390  */
2391 export interface DocumentRangeFormattingOptions extends WorkDoneProgressOptions {
2392 }
2393 /**
2394  * Registration options for a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
2395  */
2396 export interface DocumentRangeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentRangeFormattingOptions {
2397 }
2398 /**
2399  * A request to to format a range in a document.
2400  */
2401 export declare namespace DocumentRangeFormattingRequest {
2402     const method: 'textDocument/rangeFormatting';
2403     const type: ProtocolRequestType<DocumentRangeFormattingParams, TextEdit[] | null, never, void, DocumentRangeFormattingRegistrationOptions>;
2404 }
2405 /**
2406  * Client capabilities of a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
2407  */
2408 export interface DocumentOnTypeFormattingClientCapabilities {
2409     /**
2410      * Whether on type formatting supports dynamic registration.
2411      */
2412     dynamicRegistration?: boolean;
2413 }
2414 /**
2415  * The parameters of a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
2416  */
2417 export interface DocumentOnTypeFormattingParams {
2418     /**
2419      * The document to format.
2420      */
2421     textDocument: TextDocumentIdentifier;
2422     /**
2423      * The position at which this request was send.
2424      */
2425     position: Position;
2426     /**
2427      * The character that has been typed.
2428      */
2429     ch: string;
2430     /**
2431      * The format options.
2432      */
2433     options: FormattingOptions;
2434 }
2435 /**
2436  * Provider options for a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
2437  */
2438 export interface DocumentOnTypeFormattingOptions {
2439     /**
2440      * A character on which formatting should be triggered, like `}`.
2441      */
2442     firstTriggerCharacter: string;
2443     /**
2444      * More trigger characters.
2445      */
2446     moreTriggerCharacter?: string[];
2447 }
2448 /**
2449  * Registration options for a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
2450  */
2451 export interface DocumentOnTypeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentOnTypeFormattingOptions {
2452 }
2453 /**
2454  * A request to format a document on type.
2455  */
2456 export declare namespace DocumentOnTypeFormattingRequest {
2457     const method: 'textDocument/onTypeFormatting';
2458     const type: ProtocolRequestType<DocumentOnTypeFormattingParams, TextEdit[] | null, never, void, DocumentOnTypeFormattingRegistrationOptions>;
2459 }
2460 export declare namespace PrepareSupportDefaultBehavior {
2461     /**
2462      * The client's default behavior is to select the identifier
2463      * according the to language's syntax rule.
2464      */
2465     const Identifier: 1;
2466 }
2467 export declare type PrepareSupportDefaultBehavior = 1;
2468 export interface RenameClientCapabilities {
2469     /**
2470      * Whether rename supports dynamic registration.
2471      */
2472     dynamicRegistration?: boolean;
2473     /**
2474      * Client supports testing for validity of rename operations
2475      * before execution.
2476      *
2477      * @since 3.12.0
2478      */
2479     prepareSupport?: boolean;
2480     /**
2481      * Client supports the default behavior result.
2482      *
2483      * The value indicates the default behavior used by the
2484      * client.
2485      *
2486      * @since 3.16.0
2487      */
2488     prepareSupportDefaultBehavior?: PrepareSupportDefaultBehavior;
2489     /**
2490      * Whether th client honors the change annotations in
2491      * text edits and resource operations returned via the
2492      * rename request's workspace edit by for example presenting
2493      * the workspace edit in the user interface and asking
2494      * for confirmation.
2495      *
2496      * @since 3.16.0
2497      */
2498     honorsChangeAnnotations?: boolean;
2499 }
2500 /**
2501  * The parameters of a [RenameRequest](#RenameRequest).
2502  */
2503 export interface RenameParams extends WorkDoneProgressParams {
2504     /**
2505      * The document to rename.
2506      */
2507     textDocument: TextDocumentIdentifier;
2508     /**
2509      * The position at which this request was sent.
2510      */
2511     position: Position;
2512     /**
2513      * The new name of the symbol. If the given name is not valid the
2514      * request must return a [ResponseError](#ResponseError) with an
2515      * appropriate message set.
2516      */
2517     newName: string;
2518 }
2519 /**
2520  * Provider options for a [RenameRequest](#RenameRequest).
2521  */
2522 export interface RenameOptions extends WorkDoneProgressOptions {
2523     /**
2524      * Renames should be checked and tested before being executed.
2525      *
2526      * @since version 3.12.0
2527      */
2528     prepareProvider?: boolean;
2529 }
2530 /**
2531  * Registration options for a [RenameRequest](#RenameRequest).
2532  */
2533 export interface RenameRegistrationOptions extends TextDocumentRegistrationOptions, RenameOptions {
2534 }
2535 /**
2536  * A request to rename a symbol.
2537  */
2538 export declare namespace RenameRequest {
2539     const method: 'textDocument/rename';
2540     const type: ProtocolRequestType<RenameParams, WorkspaceEdit | null, never, void, RenameRegistrationOptions>;
2541 }
2542 export interface PrepareRenameParams extends TextDocumentPositionParams, WorkDoneProgressParams {
2543 }
2544 /**
2545  * A request to test and perform the setup necessary for a rename.
2546  *
2547  * @since 3.16 - support for default behavior
2548  */
2549 export declare namespace PrepareRenameRequest {
2550     const method: 'textDocument/prepareRename';
2551     const type: ProtocolRequestType<PrepareRenameParams, Range | {
2552         range: Range;
2553         placeholder: string;
2554     } | {
2555         defaultBehavior: boolean;
2556     } | null, never, void, void>;
2557 }
2558 /**
2559  * The client capabilities of a [ExecuteCommandRequest](#ExecuteCommandRequest).
2560  */
2561 export interface ExecuteCommandClientCapabilities {
2562     /**
2563      * Execute command supports dynamic registration.
2564      */
2565     dynamicRegistration?: boolean;
2566 }
2567 /**
2568  * The parameters of a [ExecuteCommandRequest](#ExecuteCommandRequest).
2569  */
2570 export interface ExecuteCommandParams extends WorkDoneProgressParams {
2571     /**
2572      * The identifier of the actual command handler.
2573      */
2574     command: string;
2575     /**
2576      * Arguments that the command should be invoked with.
2577      */
2578     arguments?: any[];
2579 }
2580 /**
2581  * The server capabilities of a [ExecuteCommandRequest](#ExecuteCommandRequest).
2582  */
2583 export interface ExecuteCommandOptions extends WorkDoneProgressOptions {
2584     /**
2585      * The commands to be executed on the server
2586      */
2587     commands: string[];
2588 }
2589 /**
2590  * Registration options for a [ExecuteCommandRequest](#ExecuteCommandRequest).
2591  */
2592 export interface ExecuteCommandRegistrationOptions extends ExecuteCommandOptions {
2593 }
2594 /**
2595  * A request send from the client to the server to execute a command. The request might return
2596  * a workspace edit which the client will apply to the workspace.
2597  */
2598 export declare namespace ExecuteCommandRequest {
2599     const type: ProtocolRequestType<ExecuteCommandParams, any, never, void, ExecuteCommandRegistrationOptions>;
2600 }
2601 export interface WorkspaceEditClientCapabilities {
2602     /**
2603      * The client supports versioned document changes in `WorkspaceEdit`s
2604      */
2605     documentChanges?: boolean;
2606     /**
2607      * The resource operations the client supports. Clients should at least
2608      * support 'create', 'rename' and 'delete' files and folders.
2609      *
2610      * @since 3.13.0
2611      */
2612     resourceOperations?: ResourceOperationKind[];
2613     /**
2614      * The failure handling strategy of a client if applying the workspace edit
2615      * fails.
2616      *
2617      * @since 3.13.0
2618      */
2619     failureHandling?: FailureHandlingKind;
2620     /**
2621      * Whether the client normalizes line endings to the client specific
2622      * setting.
2623      * If set to `true` the client will normalize line ending characters
2624      * in a workspace edit containing to the client specific new line
2625      * character.
2626      *
2627      * @since 3.16.0
2628      */
2629     normalizesLineEndings?: boolean;
2630     /**
2631      * Whether the client in general supports change annotations on text edits,
2632      * create file, rename file and delete file changes.
2633      *
2634      * @since 3.16.0
2635      */
2636     changeAnnotationSupport?: {
2637         /**
2638          * Whether the client groups edits with equal labels into tree nodes,
2639          * for instance all edits labelled with "Changes in Strings" would
2640          * be a tree node.
2641          */
2642         groupsOnLabel?: boolean;
2643     };
2644 }
2645 /**
2646  * The parameters passed via a apply workspace edit request.
2647  */
2648 export interface ApplyWorkspaceEditParams {
2649     /**
2650      * An optional label of the workspace edit. This label is
2651      * presented in the user interface for example on an undo
2652      * stack to undo the workspace edit.
2653      */
2654     label?: string;
2655     /**
2656      * The edits to apply.
2657      */
2658     edit: WorkspaceEdit;
2659 }
2660 /**
2661  * A response returned from the apply workspace edit request.
2662  */
2663 export interface ApplyWorkspaceEditResponse {
2664     /**
2665      * Indicates whether the edit was applied or not.
2666      */
2667     applied: boolean;
2668     /**
2669      * An optional textual description for why the edit was not applied.
2670      * This may be used by the server for diagnostic logging or to provide
2671      * a suitable error for a request that triggered the edit.
2672      */
2673     failureReason?: string;
2674     /**
2675      * Depending on the client's failure handling strategy `failedChange` might
2676      * contain the index of the change that failed. This property is only available
2677      * if the client signals a `failureHandlingStrategy` in its client capabilities.
2678      */
2679     failedChange?: uinteger;
2680 }
2681 /**
2682  * A request sent from the server to the client to modified certain resources.
2683  */
2684 export declare namespace ApplyWorkspaceEditRequest {
2685     const type: ProtocolRequestType<ApplyWorkspaceEditParams, ApplyWorkspaceEditResponse, never, void, void>;
2686 }
2687 export { ImplementationRequest, ImplementationParams, ImplementationRegistrationOptions, ImplementationOptions, TypeDefinitionRequest, TypeDefinitionParams, TypeDefinitionRegistrationOptions, TypeDefinitionOptions, WorkspaceFoldersRequest, DidChangeWorkspaceFoldersNotification, DidChangeWorkspaceFoldersParams, WorkspaceFolder, WorkspaceFoldersChangeEvent, ConfigurationRequest, ConfigurationParams, ConfigurationItem, DocumentColorRequest, ColorPresentationRequest, DocumentColorOptions, DocumentColorParams, ColorPresentationParams, DocumentColorRegistrationOptions, FoldingRangeClientCapabilities, FoldingRangeOptions, FoldingRangeRequest, FoldingRangeParams, FoldingRangeRegistrationOptions, 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, SemanticTokenTypes, SemanticTokenModifiers, SemanticTokensLegend, SemanticTokens, SemanticTokensPartialResult, SemanticTokensEdit, SemanticTokensDelta, 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 };
2688 export { DocumentColorOptions as ColorProviderOptions, DocumentColorOptions as ColorOptions, FoldingRangeOptions as FoldingRangeProviderOptions, SelectionRangeOptions as SelectionRangeProviderOptions, DocumentColorRegistrationOptions as ColorRegistrationOptions };