vscode-languageclient

vscode-languageclient

Version 10.1.0
Published 11 days ago
770 kB
4 dependencies
MIT license

Install

npm i vscode-languageclient

yarn add vscode-languageclient

pnpm add vscode-languageclient

Overview

VSCode Language client implementation

Index

Functions

function ensure

ensure: <T, K extends keyof T>(target: T, key: K) => T[K];

Classes

class BaseLanguageClient

abstract class BaseLanguageClient
    implements FeatureClient<Middleware, LanguageClientOptions> {}

constructor

constructor(id: string, name: string, clientOptions: LanguageClientOptions);

property clientOptions

readonly clientOptions: LanguageClientOptions;

property code2ProtocolConverter

readonly code2ProtocolConverter: c2p.Converter;

property diagnostics

readonly diagnostics: any;

property initializeResult

readonly initializeResult: any;

property middleware

readonly middleware: Middleware;

property name

readonly name: string;

property onDidChangeState

readonly onDidChangeState: Event<StateChangeEvent>;

property onTelemetry

readonly onTelemetry: Event<any>;

property outputChannel

readonly outputChannel: LogOutputChannel;

property protocol2CodeConverter

readonly protocol2CodeConverter: p2c.Converter;

property state

readonly state: State;

property traceOutputChannel

readonly traceOutputChannel: LogOutputChannel;

property visibleDocuments

readonly visibleDocuments: VisibleDocuments;

method createDefaultErrorHandler

createDefaultErrorHandler: (maxRestartCount?: number) => ErrorHandler;

method createMessageTransports

protected abstract createMessageTransports: (
    encoding: string
) => Promise<MessageTransports>;

method debug

debug: (message: string, data?: any, showNotification?: boolean) => void;

method dispose

dispose: (timeout?: number) => Promise<void>;

method error

error: (
    message: string,
    data?: any,
    showNotification?: boolean | 'force'
) => void;

method fillInitializeParams

protected fillInitializeParams: (params: InitializeParams) => void;

method getFeature

getFeature: {
    (request: any): DidOpenTextDocumentFeatureShape;
    (request: any): DidChangeTextDocumentFeatureShape;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentSendFeature<
            (textDocument: TextDocument) => ProviderResult<VTextEdit[]>
        >;
    (request: any): DidSaveTextDocumentFeatureShape;
    (request: any): DidCloseTextDocumentFeatureShape;
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileCreateEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileRenameEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileDeleteEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileWillCreateEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileWillRenameEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileWillDeleteEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CompletionItemProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<HoverProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<SignatureHelpProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DefinitionProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<ReferenceProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentHighlightProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CodeActionProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CodeLensProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentFormattingEditProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentRangeFormattingEditProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<OnTypeFormattingEditProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<RenameProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentSymbolProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentLinkProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentColorProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DeclarationProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<FoldingRangeProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<ImplementationProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<SelectionRangeProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<TypeDefinitionProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CallHierarchyProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<SemanticTokensProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<LinkedEditingRangeProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<TypeHierarchyProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<InlineValueProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<InlayHintsProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        WorkspaceProviderFeature<WorkspaceSymbolProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DiagnosticProviderShape> &
        DiagnosticFeatureShape;
    (request: any): DynamicFeature<NotebookDocumentSyncRegistrationOptions> &
        NotebookDocumentProviderShape;
    (request: any): DynamicFeature<InlineCompletionRegistrationOptions> &
        TextDocumentProviderFeature<InlineCompletionItemProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        WorkspaceProviderFeature<TextDocumentContentProviderShape>;
    (request: any): DynamicFeature<ExecuteCommandOptions>;
};

method getLocale

protected getLocale: () => string;

method handleConnectionClosed

protected handleConnectionClosed: () => Promise<void>;

method handleFailedRequest

handleFailedRequest: <T>(
    type: MessageSignature,
    token: CancellationToken | undefined,
    error: any,
    defaultValue: T,
    showNotification?: boolean,
    throwOnCancel?: boolean
) => T;

method hasDedicatedTextSynchronizationFeature

hasDedicatedTextSynchronizationFeature: (textDocument: TextDocument) => boolean;

method info

info: (message: string, data?: any, showNotification?: boolean) => void;

method isRunning

isRunning: () => boolean;

method needsStart

needsStart: () => boolean;

method needsStop

needsStop: () => boolean;

method onNotification

onNotification: {
    <RO>(
        type: ProtocolNotificationType0<RO>,
        handler: NotificationHandler0
    ): Disposable;
    <P, RO>(
        type: ProtocolNotificationType<P, RO>,
        handler: NoInfer<NotificationHandler<P>>
    ): Disposable;
    (type: NotificationType0, handler: NotificationHandler0): Disposable;
    <P>(
        type: NotificationType<P>,
        handler: NoInfer<NotificationHandler<P>>
    ): Disposable;
    (method: string, handler: GenericNotificationHandler): Disposable;
};

method onProgress

onProgress: <P>(
    type: ProgressType<P>,
    token: string | number,
    handler: NoInfer<NotificationHandler<P>>
) => Disposable;

method onRequest

onRequest: {
    <R, PR, E, RO>(
        type: ProtocolRequestType0<R, PR, E, RO>,
        handler: NoInfer<RequestHandler0<R, E>>
    ): Disposable;
    <P, R, PR, E, RO>(
        type: ProtocolRequestType<P, R, PR, E, RO>,
        handler: NoInfer<RequestHandler<P, R, E>>
    ): Disposable;
    <R, E>(
        type: RequestType0<R, E>,
        handler: NoInfer<RequestHandler0<R, E>>
    ): Disposable;
    <P, R, E>(
        type: RequestType<P, R, E>,
        handler: NoInfer<RequestHandler<P, R, E>>
    ): Disposable;
    <R, E>(method: string, handler: GenericRequestHandler<R, E>): Disposable;
};

method registerBuiltinFeatures

protected registerBuiltinFeatures: () => void;

method registerFeature

registerFeature: (feature: StaticFeature | DynamicFeature<any>) => void;

method registerFeatures

registerFeatures: (features: (StaticFeature | DynamicFeature<any>)[]) => void;

method registerProposedFeatures

registerProposedFeatures: () => void;

method sendNotification

sendNotification: {
    <RO>(type: ProtocolNotificationType0<RO>): Promise<void>;
    <P, RO>(
        type: ProtocolNotificationType<P, RO>,
        params?: NoInfer<RequestParam<P>>
    ): Promise<void>;
    (type: NotificationType0): Promise<void>;
    <P>(
        type: NotificationType<P>,
        params?: NoInfer<RequestParam<P>>
    ): Promise<void>;
    (method: string): Promise<void>;
    (method: string, params: any): Promise<void>;
};

method sendProgress

sendProgress: <P>(
    type: ProgressType<P>,
    token: string | number,
    value: NoInfer<RequestParam<P>>
) => Promise<void>;

method sendRequest

sendRequest: {
    <R, PR, E, RO>(
        type: ProtocolRequestType0<R, PR, E, RO>,
        token?: CancellationToken
    ): Promise<R>;
    <P, R, PR, E, RO>(
        type: ProtocolRequestType<P, R, PR, E, RO>,
        params: NoInfer<RequestParam<P>>,
        token?: CancellationToken
    ): Promise<R>;
    <R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
    <P, R, E>(
        type: RequestType<P, R, E>,
        params: NoInfer<RequestParam<P>>,
        token?: CancellationToken
    ): Promise<R>;
    <R>(method: string, token?: CancellationToken): Promise<R>;
    <R>(method: string, param: any, token?: CancellationToken): Promise<R>;
};

method setTrace

setTrace: (value: Trace) => Promise<void>;

method shutdown

protected shutdown: (mode: ShutdownMode, timeout?: number) => Promise<void>;

method start

start: () => Promise<void>;

method stop

stop: (timeout?: number) => Promise<void>;

method trace

trace: (message: string, data?: any) => void;

method validateWorkspaceEdit

validateWorkspaceEdit: (workspaceEdit: WorkspaceEdit) => boolean;

method warn

warn: (message: string, data?: any, showNotification?: boolean) => void;

class DefaultDiagnosticCollectionProvider

class DefaultDiagnosticCollectionProvider implements DiagnosticCollectionProvider {}

The default DiagnosticCollectionProvider. It never shares a diagnostic collection between the push and the pull model. Every call to create returns a new collection and dispose disposes it directly.

method create

create: (
    name: string | undefined,
    _source: DiagnosticCollectionSource
) => DiagnosticCollection;

method dispose

dispose: (
    collection: DiagnosticCollection,
    _source: DiagnosticCollectionSource
) => void;

class DynamicDocumentFeature

abstract class DynamicDocumentFeature<RO, MW, CO = object>
    implements DynamicFeature<RO> {}

An abstract dynamic feature implementation that operates on documents (e.g. text documents or notebooks).

constructor

constructor(client: FeatureClient<MW, CO>);

property registrationType

abstract registrationType: RegistrationType<RO>;

method clear

abstract clear: () => void;

method fillClientCapabilities

abstract fillClientCapabilities: (capabilities: ClientCapabilities) => void;

method getDocumentSelectors

protected abstract getDocumentSelectors: () => IterableIterator<VDocumentSelector>;

method getState

getState: () => FeatureState;

Returns the state the feature is in.

method initialize

abstract initialize: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector | undefined
) => void;

method register

abstract register: (data: RegistrationData<RO>) => void;

method unregister

abstract unregister: (id: string) => void;

class LanguageClient

class LanguageClient extends BaseLanguageClient {}

constructor

constructor(
    id: string,
    name: string,
    serverOptions: ServerOptions,
    clientOptions: LanguageClientOptions
);

method createMessageTransports

protected createMessageTransports: (
    _encoding: string
) => Promise<MessageTransports>;

class LSPCancellationError

class LSPCancellationError extends CancellationError {}

constructor

constructor(data: object | Object);

property data

readonly data: object | Object;

class TextDocumentEventFeature

abstract class TextDocumentEventFeature<
        P extends {
            textDocument: TextDocumentIdentifier;
        },
        E,
        M
    >
    extends DynamicDocumentFeature<TextDocumentRegistrationOptions, M>
    implements
        TextDocumentSendFeature<(data: E) => Promise<void>>,
        NotifyingFeature<P> {}

An abstract base class to implement features that react to events emitted from text documents.

constructor

constructor(
    client: FeatureClient<M, object>,
    event: Event<E>,
    type: ProtocolNotificationType<P, TextDocumentRegistrationOptions>,
    middleware: () => NextSignature<E, Promise<void>> | undefined,
    createParams: NoInfer<CreateParamsSignature<E, P>>,
    textDocument: (data: E) => TextDocument,
    selectorFilter?: (
        selectors: IterableIterator<VDocumentSelector>,
        data: E
    ) => boolean
);

property onAboutToSendNotification

readonly onAboutToSendNotification: VEvent<AboutToSendNotificationEvent<P>>;

property onNotificationSent

readonly onNotificationSent: VEvent<NotificationSentEvent<P>>;

method aboutToSendNotification

protected aboutToSendNotification: (
    textDocument: TextDocument,
    type: ProtocolNotificationType<P, TextDocumentRegistrationOptions>,
    params: RequestParam<P>
) => void;

method callback

protected callback: (data: E) => Promise<void>;

method clear

clear: () => void;

method getDocumentSelectors

protected getDocumentSelectors: () => IterableIterator<VDocumentSelector>;

method getProvider

getProvider: (document: TextDocument) => { send: (data: E) => Promise<void> };

method getStateInfo

protected getStateInfo: () => [IterableIterator<VDocumentSelector>, boolean];

method getTextDocument

protected abstract getTextDocument: (data: E) => TextDocument;

method matches

protected matches: (data: E) => boolean;

method notificationSent

protected notificationSent: (
    textDocument: TextDocument,
    type: ProtocolNotificationType<P, TextDocumentRegistrationOptions>,
    params: RequestParam<P>
) => void;

method register

register: (data: RegistrationData<TextDocumentRegistrationOptions>) => void;

method textDocumentFilter

static textDocumentFilter: (
    selectors: IterableIterator<VDocumentSelector>,
    textDocument: TextDocument
) => boolean;

method unregister

unregister: (id: string) => void;

class TextDocumentLanguageFeature

abstract class TextDocumentLanguageFeature<
    PO,
    RO extends TextDocumentRegistrationOptions & PO,
    PR,
    MW,
    CO = object
> extends DynamicDocumentFeature<RO, MW, CO> {}

A abstract feature implementation that registers language providers for text documents using a given document selector.

constructor

constructor(
    client: FeatureClient<MW, CO>,
    registrationType: RegistrationType<RO>
);

property registrationType

readonly registrationType: RegistrationType<RO>;

method clear

clear: () => void;

method fillClientCapabilities

abstract fillClientCapabilities: (capabilities: ClientCapabilities) => void;

method getAllProviders

protected getAllProviders: () => Iterable<PR>;

method getDocumentSelectors

protected getDocumentSelectors: () => IterableIterator<VDocumentSelector>;

method getProvider

getProvider: (textDocument: TextDocument) => PR | undefined;

method getRegistration

protected getRegistration: (
    documentSelector: DocumentSelector | undefined,
    capability: undefined | PO | (RO & StaticRegistrationOptions)
) => [string, RO & { documentSelector: DocumentSelector }];

method getRegistrationOptions

protected getRegistrationOptions: (
    documentSelector: DocumentSelector | undefined,
    capability: undefined | PO
) => RO & { documentSelector: DocumentSelector };

method initialize

abstract initialize: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector
) => void;

method register

register: (data: RegistrationData<RO>) => void;

method registerLanguageProvider

protected abstract registerLanguageProvider: (
    options: RO,
    id: string
) => [Disposable, PR];

method unregister

unregister: (id: string) => void;

class WorkspaceFeature

abstract class WorkspaceFeature<RO, PR, M> implements DynamicFeature<RO> {}

constructor

constructor(
    client: FeatureClient<M, object>,
    registrationType: RegistrationType<RO>
);

property registrationType

readonly registrationType: RegistrationType<RO>;

method clear

clear: () => void;

method fillClientCapabilities

abstract fillClientCapabilities: (capabilities: ClientCapabilities) => void;

method getProviders

getProviders: () => PR[];

method getState

getState: () => FeatureState;

method initialize

abstract initialize: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector | undefined
) => void;

method register

register: (data: RegistrationData<RO>) => void;

method registerLanguageProvider

protected abstract registerLanguageProvider: (options: RO) => [Disposable, PR];

method unregister

unregister: (id: string) => void;

Interfaces

interface AboutToSendNotificationEvent

interface AboutToSendNotificationEvent<
    P extends {
        textDocument: TextDocumentIdentifier;
    }
> extends NotificationEvent<P> {}

interface CallHierarchyIncomingCallsSignature

interface CallHierarchyIncomingCallsSignature {}

call signature

(this: void, item: VCallHierarchyItem, token: CancellationToken): ProviderResult<
    VCallHierarchyIncomingCall[]
>;

interface CallHierarchyMiddleware

interface CallHierarchyMiddleware {}

Call hierarchy middleware
3.16.0

property prepareCallHierarchy

prepareCallHierarchy?: (
    this: void,
    document: TextDocument,
    positions: VPosition,
    token: CancellationToken,
    next: PrepareCallHierarchySignature
) => ProviderResult<VCallHierarchyItem | VCallHierarchyItem[]>;

property provideCallHierarchyIncomingCalls

provideCallHierarchyIncomingCalls?: (
    this: void,
    item: VCallHierarchyItem,
    token: CancellationToken,
    next: CallHierarchyIncomingCallsSignature
) => ProviderResult<VCallHierarchyIncomingCall[]>;

property provideCallHierarchyOutgoingCalls

provideCallHierarchyOutgoingCalls?: (
    this: void,
    item: VCallHierarchyItem,
    token: CancellationToken,
    next: CallHierarchyOutgoingCallsSignature
) => ProviderResult<VCallHierarchyOutgoingCall[]>;

interface CallHierarchyOutgoingCallsSignature

interface CallHierarchyOutgoingCallsSignature {}

call signature

(this: void, item: VCallHierarchyItem, token: CancellationToken): ProviderResult<
    VCallHierarchyOutgoingCall[]
>;

interface Code2ProtocolConverter

interface Converter {}

method asCallHierarchyItem

asCallHierarchyItem: (value: code.CallHierarchyItem) => proto.CallHierarchyItem;

method asChangeTextDocumentParams

asChangeTextDocumentParams: {
    (textDocument: code.TextDocument): proto.DidChangeTextDocumentParams;
    (
        event: code.TextDocumentChangeEvent,
        uri: code.Uri,
        version: number
    ): proto.DidChangeTextDocumentParams;
};

method asCloseTextDocumentParams

asCloseTextDocumentParams: (
    textDocument: code.TextDocument
) => proto.DidCloseTextDocumentParams;

method asCodeAction

asCodeAction: (
    item: code.CodeAction,
    token?: code.CancellationToken
) => Promise<proto.CodeAction>;

method asCodeActionContext

asCodeActionContext: (
    context: code.CodeActionContext,
    token?: code.CancellationToken
) => Promise<proto.CodeActionContext>;

method asCodeActionContextSync

asCodeActionContextSync: (
    context: code.CodeActionContext
) => proto.CodeActionContext;

method asCodeActionSync

asCodeActionSync: (item: code.CodeAction) => proto.CodeAction;

method asCodeLens

asCodeLens: (item: code.CodeLens) => proto.CodeLens;

method asCodeLensParams

asCodeLensParams: (textDocument: code.TextDocument) => proto.CodeLensParams;

method asCommand

asCommand: (item: code.Command) => proto.Command;

method asCompletionItem

asCompletionItem: (
    item: code.CompletionItem,
    labelDetailsSupport?: boolean
) => proto.CompletionItem;

method asCompletionParams

asCompletionParams: (
    textDocument: code.TextDocument,
    position: code.Position,
    context: code.CompletionContext
) => proto.CompletionParams;

method asDiagnostic

asDiagnostic: (item: code.Diagnostic) => proto.Diagnostic;

method asDiagnostics

asDiagnostics: (
    items: code.Diagnostic[],
    token?: code.CancellationToken
) => Promise<proto.Diagnostic[]>;

method asDiagnosticSeverity

asDiagnosticSeverity: (value: code.DiagnosticSeverity) => number;

method asDiagnosticsSync

asDiagnosticsSync: (items: code.Diagnostic[]) => proto.Diagnostic[];

method asDiagnosticTag

asDiagnosticTag: (value: code.DiagnosticTag) => number | undefined;

method asDidCreateFilesParams

asDidCreateFilesParams: (event: code.FileCreateEvent) => proto.CreateFilesParams;

method asDidDeleteFilesParams

asDidDeleteFilesParams: (event: code.FileDeleteEvent) => proto.DeleteFilesParams;

method asDidRenameFilesParams

asDidRenameFilesParams: (event: code.FileRenameEvent) => proto.RenameFilesParams;

method asDocumentLink

asDocumentLink: (item: code.DocumentLink) => proto.DocumentLink;

method asDocumentLinkParams

asDocumentLinkParams: (
    textDocument: code.TextDocument
) => proto.DocumentLinkParams;

method asDocumentSymbolParams

asDocumentSymbolParams: (
    textDocument: code.TextDocument
) => proto.DocumentSymbolParams;

method asFormattingOptions

asFormattingOptions: (
    options: code.FormattingOptions,
    fileOptions: FileFormattingOptions
) => proto.FormattingOptions;

method asInlayHint

asInlayHint: (value: code.InlayHint) => proto.InlayHint;

method asInlineCompletionContext

asInlineCompletionContext: (
    context: code.InlineCompletionContext
) => proto.InlineCompletionContext;

method asInlineCompletionParams

asInlineCompletionParams: (
    document: code.TextDocument,
    position: code.Position,
    context: code.InlineCompletionContext
) => proto.InlineCompletionParams;

method asInlineValueContext

asInlineValueContext: (
    context: code.InlineValueContext
) => proto.InlineValueContext;

method asLocation

asLocation: {
    (value: null): null;
    (value: undefined): undefined;
    (value: code.Location): proto.Location;
    (value: any): any;
};

method asOpenTextDocumentParams

asOpenTextDocumentParams: (
    textDocument: code.TextDocument
) => proto.DidOpenTextDocumentParams;

method asPosition

asPosition: {
    (value: null): null;
    (value: undefined): undefined;
    (value: code.Position): proto.Position;
    (value: any): any;
};

method asPositions

asPositions: (
    value: readonly code.Position[],
    token?: code.CancellationToken
) => Promise<proto.Position[]>;

method asPositionsSync

asPositionsSync: (
    value: readonly code.Position[],
    token?: code.CancellationToken
) => proto.Position[];

method asRange

asRange: {
    (value: null): null;
    (value: undefined): undefined;
    (value: code.Range): proto.Range;
    (value: any): any;
};

method asRanges

asRanges: (values: readonly code.Range[]) => proto.Range[];

method asReferenceParams

asReferenceParams: (
    textDocument: code.TextDocument,
    position: code.Position,
    options: { includeDeclaration: boolean }
) => proto.ReferenceParams;

method asSaveTextDocumentParams

asSaveTextDocumentParams: (
    textDocument: code.TextDocument,
    includeContent?: boolean
) => proto.DidSaveTextDocumentParams;

method asSignatureHelpParams

asSignatureHelpParams: (
    textDocument: code.TextDocument,
    position: code.Position,
    context: code.SignatureHelpContext
) => proto.SignatureHelpParams;

method asSymbolKind

asSymbolKind: (item: code.SymbolKind) => proto.SymbolKind;

method asSymbolTag

asSymbolTag: (item: code.SymbolTag) => proto.SymbolTag;

method asSymbolTags

asSymbolTags: (items: ReadonlyArray<code.SymbolTag>) => proto.SymbolTag[];

method asTextDocumentIdentifier

asTextDocumentIdentifier: (
    textDocument: code.TextDocument
) => proto.TextDocumentIdentifier;

method asTextDocumentItem

asTextDocumentItem: (textDocument: code.TextDocument) => proto.TextDocumentItem;

method asTextDocumentPositionParams

asTextDocumentPositionParams: (
    textDocument: code.TextDocument,
    position: code.Position
) => proto.TextDocumentPositionParams;

method asTextEdit

asTextEdit: (edit: code.TextEdit) => proto.TextEdit;

method asTypeHierarchyItem

asTypeHierarchyItem: (value: code.TypeHierarchyItem) => proto.TypeHierarchyItem;

method asUri

asUri: (uri: code.Uri) => string;

method asVersionedTextDocumentIdentifier

asVersionedTextDocumentIdentifier: (
    textDocument: code.TextDocument
) => proto.VersionedTextDocumentIdentifier;

method asWillCreateFilesParams

asWillCreateFilesParams: (
    event: code.FileCreateEvent
) => proto.CreateFilesParams;

method asWillDeleteFilesParams

asWillDeleteFilesParams: (
    event: code.FileDeleteEvent
) => proto.DeleteFilesParams;

method asWillRenameFilesParams

asWillRenameFilesParams: (
    event: code.FileRenameEvent
) => proto.RenameFilesParams;

method asWillSaveTextDocumentParams

asWillSaveTextDocumentParams: (
    event: code.TextDocumentWillSaveEvent
) => proto.WillSaveTextDocumentParams;

method asWorkerPosition

asWorkerPosition: (position: code.Position) => proto.Position;

method asWorkspaceSymbol

asWorkspaceSymbol: (item: code.SymbolInformation) => proto.WorkspaceSymbol;

interface CodeActionMiddleware

interface CodeActionMiddleware {}

property provideCodeActions

provideCodeActions?: (
    this: void,
    document: TextDocument,
    range: VRange,
    context: VCodeActionContext,
    token: CancellationToken,
    next: ProvideCodeActionsSignature
) => ProviderResult<(VCommand | VCodeAction)[]>;

property resolveCodeAction

resolveCodeAction?: (
    this: void,
    item: VCodeAction,
    token: CancellationToken,
    next: ResolveCodeActionSignature
) => ProviderResult<VCodeAction>;

interface CodeLensMiddleware

interface CodeLensMiddleware {}

property provideCodeLenses

provideCodeLenses?: (
    this: void,
    document: TextDocument,
    token: CancellationToken,
    next: ProvideCodeLensesSignature
) => ProviderResult<VCodeLens[]>;

property resolveCodeLens

resolveCodeLens?: (
    this: void,
    codeLens: VCodeLens,
    token: CancellationToken,
    next: ResolveCodeLensSignature
) => ProviderResult<VCodeLens>;

interface ColorProviderMiddleware

interface ColorProviderMiddleware {}

property provideColorPresentations

provideColorPresentations?: (
    this: void,
    color: VColor,
    context: {
        document: TextDocument;
        range: VRange;
    },
    token: CancellationToken,
    next: ProvideColorPresentationSignature
) => ProviderResult<VColorPresentation[]>;

property provideDocumentColors

provideDocumentColors?: (
    this: void,
    document: TextDocument,
    token: CancellationToken,
    next: ProvideDocumentColorsSignature
) => ProviderResult<VColorInformation[]>;

interface CompletionMiddleware

interface CompletionMiddleware {}

property provideCompletionItem

provideCompletionItem?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    context: VCompletionContext,
    token: CancellationToken,
    next: ProvideCompletionItemsSignature
) => ProviderResult<VCompletionItem[] | VCompletionList>;

property resolveCompletionItem

resolveCompletionItem?: (
    this: void,
    item: VCompletionItem,
    token: CancellationToken,
    next: ResolveCompletionItemSignature
) => ProviderResult<VCompletionItem>;

interface ConfigurationMiddleware

interface ConfigurationMiddleware {}

property configuration

configuration?: ConfigurationRequest.MiddlewareSignature;

interface DeclarationMiddleware

interface DeclarationMiddleware {}

property provideDeclaration

provideDeclaration?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: ProvideDeclarationSignature
) => ProviderResult<VDeclaration>;

interface DedicatedTextSynchronizationFeature

interface DedicatedTextSynchronizationFeature {}

method handles

handles: (textDocument: TextDocument) => boolean;

interface DefinitionMiddleware

interface DefinitionMiddleware {}

property provideDefinition

provideDefinition?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: ProvideDefinitionSignature
) => ProviderResult<VDefinition | VDefinitionLink[]>;

interface DiagnosticCollectionProvider

interface DiagnosticCollectionProvider {}

A provider that creates and disposes the diagnostic collections used by the push (textDocument/publishDiagnostics) and the pull (textDocument/diagnostic) model. The same provider instance is shared between the client and the diagnostic pull implementation so that an implementation can decide whether the two models share the same underlying collection.

method create

create: (
    name: string | undefined,
    source: DiagnosticCollectionSource
) => DiagnosticCollection;

Creates or returns a diagnostic collection for the given name and source.
Parameter name
the name of the diagnostic collection or undefined if no name is available.
Parameter source
whether the collection is requested by the push or the pull model.

method dispose

dispose: (
    collection: DiagnosticCollection,
    source: DiagnosticCollectionSource
) => void;

Disposes the given diagnostic collection on behalf of the given source.
Parameter collection
the collection to dispose.
Parameter source
whether the push or the pull model releases the collection.

interface DidChangeConfigurationMiddleware

interface DidChangeConfigurationMiddleware {}

property didChangeConfiguration

didChangeConfiguration?: (
    this: void,
    sections: string[] | undefined,
    next: DidChangeConfigurationSignature
) => Promise<void>;

interface DidChangeConfigurationSignature

interface DidChangeConfigurationSignature {}

call signature

(this: void, sections: string[] | undefined): Promise<void>;

interface DidChangeTextDocumentFeatureShape

interface DidChangeTextDocumentFeatureShape
    extends DynamicFeature<TextDocumentChangeRegistrationOptions>,
        TextDocumentSendFeature<(event: TextDocumentChangeEvent) => Promise<void>>,
        NotifyingFeature<DidChangeTextDocumentParams> {}

interface DidChangeWatchedFileSignature

interface DidChangeWatchedFileSignature {}

call signature

(this: void, event: FileEvent): Promise<void>;

interface DidCloseTextDocumentFeatureShape

interface DidCloseTextDocumentFeatureShape
    extends DynamicFeature<TextDocumentRegistrationOptions>,
        TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>,
        NotifyingFeature<DidCloseTextDocumentParams> {}

interface DidOpenTextDocumentFeatureShape

interface DidOpenTextDocumentFeatureShape
    extends DynamicFeature<TextDocumentRegistrationOptions>,
        TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>,
        NotifyingFeature<DidOpenTextDocumentParams> {}

property openDocuments

openDocuments: Iterable<TextDocument>;

interface DidSaveTextDocumentFeatureShape

interface DidSaveTextDocumentFeatureShape
    extends DynamicFeature<TextDocumentRegistrationOptions>,
        TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>,
        NotifyingFeature<DidSaveTextDocumentParams> {}

interface DocumentHighlightMiddleware

interface DocumentHighlightMiddleware {}

property provideDocumentHighlights

provideDocumentHighlights?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: ProvideDocumentHighlightsSignature
) => ProviderResult<VDocumentHighlight[]>;

interface DocumentLinkMiddleware

interface DocumentLinkMiddleware {}

property provideDocumentLinks

provideDocumentLinks?: (
    this: void,
    document: TextDocument,
    token: CancellationToken,
    next: ProvideDocumentLinksSignature
) => ProviderResult<VDocumentLink[]>;

property resolveDocumentLink

resolveDocumentLink?: (
    this: void,
    link: VDocumentLink,
    token: CancellationToken,
    next: ResolveDocumentLinkSignature
) => ProviderResult<VDocumentLink>;

interface DocumentRangeSemanticTokensSignature

interface DocumentRangeSemanticTokensSignature {}

call signature

(
    this: void,
    document: vscode.TextDocument,
    range: vscode.Range,
    token: vscode.CancellationToken
): vscode.ProviderResult<vscode.SemanticTokens>;

interface DocumentSemanticsTokensEditsSignature

interface DocumentSemanticsTokensEditsSignature {}

call signature

(
    this: void,
    document: vscode.TextDocument,
    previousResultId: string,
    token: vscode.CancellationToken
): vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens>;

interface DocumentSemanticsTokensSignature

interface DocumentSemanticsTokensSignature {}

call signature

(
    this: void,
    document: vscode.TextDocument,
    token: vscode.CancellationToken
): vscode.ProviderResult<vscode.SemanticTokens>;

interface DocumentSymbolMiddleware

interface DocumentSymbolMiddleware {}

property provideDocumentSymbols

provideDocumentSymbols?: (
    this: void,
    document: TextDocument,
    token: CancellationToken,
    next: ProvideDocumentSymbolsSignature
) => ProviderResult<VSymbolInformation[] | VDocumentSymbol[]>;

interface DynamicFeature

interface DynamicFeature<RO> {}

A dynamic feature can be activated via the server.

property fillInitializeParams

fillInitializeParams?: (params: InitializeParams) => void;

Called to fill the initialize params.
the initialize params.

property preInitialize

preInitialize?: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector | undefined
) => void;

A preflight where the server capabilities are shown to all features before a feature is actually initialized. This allows feature to capture some state if they are a pre-requisite for other features.
Parameter capabilities
the server capabilities
Parameter documentSelector
the document selector pass to the client's constructor. May be undefined if the client was created without a selector.

property registrationType

registrationType: RegistrationType<RO>;

The signature (e.g. method) for which this features support dynamic activation / registration.

method clear

clear: () => void;

Called when the client is stopped or re-started to clear this feature. Usually a feature un-registers listeners registered hooked up with the VS Code extension host.

method fillClientCapabilities

fillClientCapabilities: (capabilities: ClientCapabilities) => void;

Called to fill in the client capabilities this feature implements.
Parameter capabilities
The client capabilities to fill.

method getState

getState: () => FeatureState;

Returns the state the feature is in.

method initialize

initialize: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector | undefined
) => void;

Initialize the feature. This method is called on a feature instance when the client has successfully received the initialize request from the server and before the client sends the initialized notification to the server.
Parameter capabilities
the server capabilities.
Parameter documentSelector
the document selector pass to the client's constructor. May be undefined if the client was created without a selector.

method register

register: (data: RegistrationData<RO>) => void;

Is called when the server send a register request for the given message.
Parameter data
additional registration data as defined in the protocol.

method unregister

unregister: (id: string) => void;

Is called when the server wants to unregister a feature.
Parameter id
the id used when registering the feature.

interface ErrorHandler

interface ErrorHandler {}

A plugable error handler that is invoked when the connection is either producing errors or got closed.

method closed

closed: () => CloseHandlerResult | Promise<CloseHandlerResult>;

The connection to the server got closed.

method error

error: (
    error: Error,
    message: Message | undefined,
    count: number | undefined
) => ErrorHandlerResult | Promise<ErrorHandlerResult>;

An error has occurred while writing or reading from the connection.
Parameter error
the error received
Parameter message
the message to be delivered to the server if know.
Parameter count
a count indicating how often an error is received. Will be reset if a message got successfully send or received.

interface ExecuteCommandMiddleware

interface ExecuteCommandMiddleware {}

property executeCommand

executeCommand?: (
    this: void,
    command: string,
    args: any[],
    next: ExecuteCommandSignature
) => ProviderResult<any>;

interface ExecuteCommandSignature

interface ExecuteCommandSignature {}

call signature

(this: void, command: string, args: any[]): ProviderResult<any>;

interface FeatureClient

interface FeatureClient<M, CO = object> {}

property clientOptions

clientOptions: CO;

property code2ProtocolConverter

code2ProtocolConverter: c2p.Converter;

property middleware

middleware: M;

property protocol2CodeConverter

protocol2CodeConverter: p2c.Converter;

property visibleDocuments

visibleDocuments: VisibleDocuments;

method error

error: (
    message: string,
    data?: any,
    showNotification?: boolean | 'force'
) => void;

method getFeature

getFeature: {
    (request: any): DidOpenTextDocumentFeatureShape;
    (request: any): DidChangeTextDocumentFeatureShape;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentSendFeature<(textDocument: TextDocument) => Promise<void>>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentSendFeature<
            (textDocument: TextDocument) => ProviderResult<VTextEdit[]>
        >;
    (request: any): DidSaveTextDocumentFeatureShape;
    (request: any): DidCloseTextDocumentFeatureShape;
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileCreateEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileRenameEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileDeleteEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileWillCreateEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileWillRenameEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<FileOperationRegistrationOptions> & {
        send: (event: FileWillDeleteEvent) => Promise<void>;
    };
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CompletionItemProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<HoverProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<SignatureHelpProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DefinitionProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<ReferenceProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentHighlightProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CodeActionProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CodeLensProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentFormattingEditProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentRangeFormattingEditProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<OnTypeFormattingEditProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<RenameProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentSymbolProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentLinkProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DocumentColorProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DeclarationProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<FoldingRangeProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<ImplementationProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<SelectionRangeProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<TypeDefinitionProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<CallHierarchyProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<SemanticTokensProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<LinkedEditingRangeProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<TypeHierarchyProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<InlineValueProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<InlayHintsProviderShape>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        WorkspaceProviderFeature<WorkspaceSymbolProvider>;
    (request: any): DynamicFeature<TextDocumentRegistrationOptions> &
        TextDocumentProviderFeature<DiagnosticProviderShape> &
        DiagnosticFeatureShape;
    (request: any): DynamicFeature<NotebookDocumentSyncRegistrationOptions> &
        NotebookDocumentProviderShape;
    (request: any): DynamicFeature<InlineCompletionRegistrationOptions> &
        TextDocumentProviderFeature<InlineCompletionItemProvider>;
    (request: any): DynamicFeature<ExecuteCommandOptions>;
};

method handleFailedRequest

handleFailedRequest: <T>(
    type: MessageSignature,
    token: CancellationToken | undefined,
    error: any,
    defaultValue: T,
    showNotification?: boolean,
    throwOnCancel?: boolean
) => T;

method hasDedicatedTextSynchronizationFeature

hasDedicatedTextSynchronizationFeature: (textDocument: TextDocument) => boolean;

method info

info: (message: string, data?: any, showNotification?: boolean) => void;

method isRunning

isRunning: () => boolean;

method onNotification

onNotification: {
    <RO>(
        type: ProtocolNotificationType0<RO>,
        handler: NotificationHandler0
    ): Disposable;
    <P, RO>(
        type: ProtocolNotificationType<P, RO>,
        handler: NoInfer<NotificationHandler<P>>
    ): Disposable;
    (type: NotificationType0, handler: NotificationHandler0): Disposable;
    <P>(
        type: NotificationType<P>,
        handler: NoInfer<NotificationHandler<P>>
    ): Disposable;
    (method: string, handler: GenericNotificationHandler): Disposable;
};

method onProgress

onProgress: <P>(
    type: ProgressType<P>,
    token: string | number,
    handler: NoInfer<NotificationHandler<P>>
) => Disposable;

method onRequest

onRequest: {
    <R, PR, E, RO>(
        type: ProtocolRequestType0<R, PR, E, RO>,
        handler: NoInfer<RequestHandler0<R, E>>
    ): Disposable;
    <P, R, PR, E, RO>(
        type: ProtocolRequestType<P, R, PR, E, RO>,
        handler: NoInfer<RequestHandler<P, R, E>>
    ): Disposable;
    <R, E>(
        type: RequestType0<R, E>,
        handler: NoInfer<RequestHandler0<R, E>>
    ): Disposable;
    <P, R, E>(
        type: RequestType<P, R, E>,
        handler: NoInfer<RequestHandler<P, R, E>>
    ): Disposable;
    <R, E>(method: string, handler: GenericRequestHandler<R, E>): Disposable;
};

method sendNotification

sendNotification: {
    <RO>(type: ProtocolNotificationType0<RO>): Promise<void>;
    <P, RO>(
        type: ProtocolNotificationType<P, RO>,
        params?: NoInfer<RequestParam<P>>
    ): Promise<void>;
    (type: NotificationType0): Promise<void>;
    <P>(
        type: NotificationType<P>,
        params?: NoInfer<RequestParam<P>>
    ): Promise<void>;
    (method: string): Promise<void>;
    (method: string, params: any): Promise<void>;
};

method sendRequest

sendRequest: {
    <R, PR, E, RO>(
        type: ProtocolRequestType0<R, PR, E, RO>,
        token?: CancellationToken
    ): Promise<R>;
    <P, R, PR, E, RO>(
        type: ProtocolRequestType<P, R, PR, E, RO>,
        params: NoInfer<RequestParam<P>>,
        token?: CancellationToken
    ): Promise<R>;
    <R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
    <P, R, E>(
        type: RequestType<P, R, E>,
        params: NoInfer<RequestParam<P>>,
        token?: CancellationToken
    ): Promise<R>;
    <R>(method: string, token?: CancellationToken): Promise<R>;
    <R>(method: string, param: any, token?: CancellationToken): Promise<R>;
};

method start

start: () => Promise<void>;

method stop

stop: () => Promise<void>;

method validateWorkspaceEdit

validateWorkspaceEdit: (workspaceEdit: WorkspaceEdit) => boolean;

method warn

warn: (message: string, data?: any, showNotification?: boolean) => void;

interface FileFormattingOptions

interface FileFormattingOptions {}

property insertFinalNewline

insertFinalNewline?: boolean;

property trimFinalNewlines

trimFinalNewlines?: boolean;

property trimTrailingWhitespace

trimTrailingWhitespace?: boolean;

interface FileOperationsMiddleware

interface FileOperationsMiddleware {}

File operation middleware
3.16.0

property didCreateFiles

didCreateFiles?: NextSignature<code.FileCreateEvent, Promise<void>>;

property didDeleteFiles

didDeleteFiles?: NextSignature<code.FileDeleteEvent, Promise<void>>;

property didRenameFiles

didRenameFiles?: NextSignature<code.FileRenameEvent, Promise<void>>;

property willCreateFiles

willCreateFiles?: NextSignature<
    code.FileWillCreateEvent,
    Thenable<code.WorkspaceEdit | null | undefined>
>;

property willDeleteFiles

willDeleteFiles?: NextSignature<
    code.FileWillDeleteEvent,
    Thenable<code.WorkspaceEdit | null | undefined>
>;

property willRenameFiles

willRenameFiles?: NextSignature<
    code.FileWillRenameEvent,
    Thenable<code.WorkspaceEdit | null | undefined>
>;

interface FoldingRangeProviderMiddleware

interface FoldingRangeProviderMiddleware {}

property provideFoldingRanges

provideFoldingRanges?: (
    this: void,
    document: TextDocument,
    context: FoldingContext,
    token: CancellationToken,
    next: ProvideFoldingRangeSignature
) => ProviderResult<VFoldingRange[]>;

interface FormattingMiddleware

interface FormattingMiddleware {}

property provideDocumentFormattingEdits

provideDocumentFormattingEdits?: (
    this: void,
    document: TextDocument,
    options: VFormattingOptions,
    token: CancellationToken,
    next: ProvideDocumentFormattingEditsSignature
) => ProviderResult<VTextEdit[]>;

property provideDocumentRangeFormattingEdits

provideDocumentRangeFormattingEdits?: (
    this: void,
    document: TextDocument,
    range: VRange,
    options: VFormattingOptions,
    token: CancellationToken,
    next: ProvideDocumentRangeFormattingEditsSignature
) => ProviderResult<VTextEdit[]>;

property provideDocumentRangesFormattingEdits

provideDocumentRangesFormattingEdits?: (
    this: void,
    document: TextDocument,
    range: VRange[],
    options: VFormattingOptions,
    token: CancellationToken,
    next: ProvideDocumentRangesFormattingEditsSignature
) => ProviderResult<VTextEdit[]>;

property provideOnTypeFormattingEdits

provideOnTypeFormattingEdits?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    ch: string,
    options: VFormattingOptions,
    token: CancellationToken,
    next: ProvideOnTypeFormattingEditsSignature
) => ProviderResult<VTextEdit[]>;

interface HandleDiagnosticsSignature

interface HandleDiagnosticsSignature {}

call signature

(this: void, uri: Uri, diagnostics: VDiagnostic[]): void;

interface HandleWorkDoneProgressSignature

interface HandleWorkDoneProgressSignature {}

call signature

(
    this: void,
    token: ProgressToken,
    params: WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd
): void;

interface HoverMiddleware

interface HoverMiddleware {}

property provideHover

provideHover?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: ProvideHoverSignature
) => ProviderResult<VHover>;

interface ImplementationMiddleware

interface ImplementationMiddleware {}

property provideImplementation

provideImplementation?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: ProvideImplementationSignature
) => ProviderResult<VDefinition | VDefinitionLink[]>;

interface LinkedEditingRangeMiddleware

interface LinkedEditingRangeMiddleware {}

Linked editing middleware
3.16.0

property provideLinkedEditingRange

provideLinkedEditingRange?: (
    this: void,
    document: code.TextDocument,
    position: code.Position,
    token: code.CancellationToken,
    next: ProvideLinkedEditingRangeSignature
) => code.ProviderResult<code.LinkedEditingRanges>;

interface MessageTransports

interface MessageTransports {}

property detached

detached?: boolean;

property reader

reader: MessageReader;

property writer

writer: MessageWriter;

interface NextSignature

interface NextSignature<P, R> {}

call signature

(this: void, data: P, next: (data: P) => R): R;

interface NotebookDocumentSyncFeatureShape

interface NotebookDocumentSyncFeatureShape {}

method getSynchronizedCells

getSynchronizedCells: (
    notebookDocument: vscode.NotebookDocument
) => vscode.NotebookCell[] | undefined;

method sendDidChangeNotebookDocument

sendDidChangeNotebookDocument: (
    event: VNotebookDocumentChangeEvent
) => Promise<void>;

method sendDidCloseNotebookDocument

sendDidCloseNotebookDocument: (
    notebookDocument: vscode.NotebookDocument
) => Promise<void>;

method sendDidOpenNotebookDocument

sendDidOpenNotebookDocument: (
    notebookDocument: vscode.NotebookDocument
) => Promise<void>;

method sendDidSaveNotebookDocument

sendDidSaveNotebookDocument: (
    notebookDocument: vscode.NotebookDocument
) => Promise<void>;

interface NotificationSendEvent

interface NotificationSendEvent<
    P extends {
        textDocument: TextDocumentIdentifier;
    }
> extends NotificationSentEvent<P> {}

Deprecated
Use NotificationSentEvent instead.

interface NotificationSentEvent

interface NotificationSentEvent<
    P extends {
        textDocument: TextDocumentIdentifier;
    }
> extends NotificationEvent<P> {}

interface NotifyingFeature

interface NotifyingFeature<
    P extends {
        textDocument: TextDocumentIdentifier;
    }
> {}

property onAboutToSendNotification

onAboutToSendNotification: VEvent<AboutToSendNotificationEvent<P>>;

property onNotificationSent

onNotificationSent: VEvent<NotificationSentEvent<P>>;

interface PrepareCallHierarchySignature

interface PrepareCallHierarchySignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VCallHierarchyItem | VCallHierarchyItem[]>;

interface PrepareRenameSignature

interface PrepareRenameSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<
    | VRange
    | {
          range: VRange;
          placeholder: string;
      }
>;

interface Protocol2CodeConverter

interface Converter {}

method asCallHierarchyIncomingCall

asCallHierarchyIncomingCall: (
    item: ls.CallHierarchyIncomingCall,
    token?: code.CancellationToken
) => Promise<code.CallHierarchyIncomingCall>;

method asCallHierarchyIncomingCalls

asCallHierarchyIncomingCalls: {
    (items: null, token?: code.CancellationToken): Promise<undefined>;
    (
        items: readonly ls.CallHierarchyIncomingCall[],
        token?: code.CancellationToken
    ): Promise<code.CallHierarchyIncomingCall[]>;
    (
        items: readonly ls.CallHierarchyIncomingCall[],
        token?: code.CancellationToken
    ): Promise<code.CallHierarchyIncomingCall[]>;
};

method asCallHierarchyItem

asCallHierarchyItem: {
    (item: null): undefined;
    (item: ls.CallHierarchyItem): code.CallHierarchyItem;
    (item: any): any;
};

method asCallHierarchyItems

asCallHierarchyItems: {
    (items: null, token?: code.CancellationToken): Promise<undefined>;
    (items: ls.CallHierarchyItem[], token?: code.CancellationToken): Promise<
        code.CallHierarchyItem[]
    >;
    (items: ls.CallHierarchyItem[], token?: code.CancellationToken): Promise<
        code.CallHierarchyItem[]
    >;
};

method asCallHierarchyOutgoingCall

asCallHierarchyOutgoingCall: (
    item: ls.CallHierarchyOutgoingCall,
    token?: code.CancellationToken
) => Promise<code.CallHierarchyOutgoingCall>;

method asCallHierarchyOutgoingCalls

asCallHierarchyOutgoingCalls: {
    (items: null, token?: code.CancellationToken): Promise<undefined>;
    (
        items: readonly ls.CallHierarchyOutgoingCall[],
        token?: code.CancellationToken
    ): Promise<code.CallHierarchyOutgoingCall[]>;
    (
        items: readonly ls.CallHierarchyOutgoingCall[],
        token?: code.CancellationToken
    ): Promise<code.CallHierarchyOutgoingCall[]>;
};

method asCodeAction

asCodeAction: {
    (item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
    (
        item: ls.CodeAction,
        token?: code.CancellationToken
    ): Promise<code.CodeAction>;
    (item: any, token?: code.CancellationToken): Promise<code.CodeAction>;
};

method asCodeActionDocumentations

asCodeActionDocumentations: {
    (items: null | undefined): undefined;
    (items: ls.CodeActionKindDocumentation[]): code.CodeActionProviderMetadata;
    (items: ls.CodeActionKindDocumentation[]): any;
};

method asCodeActionKind

asCodeActionKind: {
    (item: null | undefined): undefined;
    (item: ls.CodeActionKind): code.CodeActionKind;
    (item: any): any;
};

method asCodeActionKinds

asCodeActionKinds: {
    (item: null | undefined): undefined;
    (items: ls.CodeActionKind[]): code.CodeActionKind[];
    (item: ls.CodeActionKind[]): code.CodeActionKind[];
};

method asCodeActionResult

asCodeActionResult: (
    items: (ls.Command | ls.CodeAction)[],
    token?: code.CancellationToken
) => Promise<(code.Command | code.CodeAction)[]>;

method asCodeLens

asCodeLens: {
    (item: ls.CodeLens): code.CodeLens;
    (item: null): undefined;
    (item: any): any;
};

method asCodeLenses

asCodeLenses: {
    (
        items: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (items: ls.CodeLens[], token?: code.CancellationToken): Promise<
        code.CodeLens[]
    >;
    (items: ls.CodeLens[], token?: code.CancellationToken): Promise<
        code.CodeLens[]
    >;
};

method asColor

asColor: (color: ls.Color) => code.Color;

method asColorInformation

asColorInformation: (ci: ls.ColorInformation) => code.ColorInformation;

method asColorInformations

asColorInformations: {
    (
        colorPresentations: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        colorPresentations: ls.ColorInformation[],
        token?: code.CancellationToken
    ): Promise<code.ColorInformation[]>;
    (
        colorInformation: ls.ColorInformation[],
        token?: code.CancellationToken
    ): Promise<code.ColorInformation[]>;
};

method asColorPresentation

asColorPresentation: (cp: ls.ColorPresentation) => code.ColorPresentation;

method asColorPresentations

asColorPresentations: {
    (
        colorPresentations: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        colorPresentations: ls.ColorPresentation[],
        token?: code.CancellationToken
    ): Promise<code.ColorPresentation[]>;
    (
        colorPresentations: ls.ColorPresentation[],
        token?: code.CancellationToken
    ): Promise<code.ColorPresentation[]>;
};

method asCommand

asCommand: (item: ls.Command) => code.Command;

method asCommands

asCommands: {
    (
        items: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (items: ls.Command[], token?: code.CancellationToken): Promise<
        code.Command[]
    >;
    (items: ls.Command[], token?: code.CancellationToken): Promise<
        code.Command[]
    >;
};

method asCompletionItem

asCompletionItem: (
    item: ls.CompletionItem,
    defaultCommitCharacters?: string[]
) => ProtocolCompletionItem;

method asCompletionResult

asCompletionResult: {
    (
        value: undefined | null,
        allCommitCharacters?: string[],
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        value: ls.CompletionList,
        allCommitCharacters?: string[],
        token?: code.CancellationToken
    ): Promise<code.CompletionList>;
    (
        value: ls.CompletionItem[],
        allCommitCharacters?: string[],
        token?: code.CancellationToken
    ): Promise<code.CompletionItem[]>;
    (
        value: any,
        allCommitCharacters?: string[],
        token?: code.CancellationToken
    ): Promise<any>;
};

method asDeclarationResult

asDeclarationResult: {
    (item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
    (item: ls.Declaration, token?: code.CancellationToken): Promise<any>;
    (item: ls.DeclarationLink[], token?: code.CancellationToken): Promise<
        code.LocationLink[]
    >;
    (item: any, token?: code.CancellationToken): Promise<any>;
};

method asDefinitionResult

asDefinitionResult: {
    (item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
    (
        item: ls.Definition,
        token?: code.CancellationToken
    ): Promise<code.Definition>;
    (item: ls.DefinitionLink[], token?: code.CancellationToken): Promise<
        code.DefinitionLink[]
    >;
    (item: any, token?: code.CancellationToken): Promise<any>;
};

method asDiagnostic

asDiagnostic: (diagnostic: ls.Diagnostic) => code.Diagnostic;

method asDiagnostics

asDiagnostics: (
    diagnostics: ls.Diagnostic[],
    token?: code.CancellationToken
) => Promise<code.Diagnostic[]>;

method asDiagnosticSeverity

asDiagnosticSeverity: (
    value: number | undefined | null
) => code.DiagnosticSeverity;

method asDiagnosticTag

asDiagnosticTag: (tag: ls.DiagnosticTag) => code.DiagnosticTag | undefined;

method asDocumentHighlight

asDocumentHighlight: (item: ls.DocumentHighlight) => code.DocumentHighlight;

method asDocumentHighlightKind

asDocumentHighlightKind: (item: number) => code.DocumentHighlightKind;

method asDocumentHighlights

asDocumentHighlights: {
    (
        values: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (values: ls.DocumentHighlight[], token?: code.CancellationToken): Promise<
        code.DocumentHighlight[]
    >;
    (values: ls.DocumentHighlight[], token?: code.CancellationToken): Promise<
        code.DocumentHighlight[]
    >;
};

method asDocumentLink

asDocumentLink: (item: ls.DocumentLink) => code.DocumentLink;

method asDocumentLinks

asDocumentLinks: {
    (
        items: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (items: ls.DocumentLink[], token?: code.CancellationToken): Promise<
        code.DocumentLink[]
    >;
    (items: ls.DocumentLink[], token?: code.CancellationToken): Promise<
        code.DocumentLink[]
    >;
};

method asDocumentSelector

asDocumentSelector: (value: ls.DocumentSelector) => code.DocumentSelector;

method asDocumentSymbol

asDocumentSymbol: (
    value: ls.DocumentSymbol,
    token?: code.CancellationToken
) => code.DocumentSymbol;

method asDocumentSymbols

asDocumentSymbols: {
    (
        value: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (value: ls.DocumentSymbol[], token?: code.CancellationToken): Promise<
        code.DocumentSymbol[]
    >;
    (value: ls.DocumentSymbol[], token?: code.CancellationToken): Promise<
        code.DocumentSymbol[]
    >;
};

method asFoldingRange

asFoldingRange: (r: ls.FoldingRange) => code.FoldingRange;

method asFoldingRangeKind

asFoldingRangeKind: (
    kind: string | undefined
) => code.FoldingRangeKind | undefined;

method asFoldingRanges

asFoldingRanges: {
    (
        foldingRanges: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (foldingRanges: ls.FoldingRange[], token?: code.CancellationToken): Promise<
        code.FoldingRange[]
    >;
    (foldingRanges: ls.FoldingRange[], token?: code.CancellationToken): Promise<
        code.FoldingRange[]
    >;
};

method asGlobPattern

asGlobPattern: {
    (pattern: undefined | null): undefined;
    (pattern: ls.GlobPattern): any;
};

method asHover

asHover: {
    (hover: undefined | null): undefined;
    (hover: ls.Hover): code.Hover;
    (hover: any): any;
};

method asInlayHint

asInlayHint: (
    value: ls.InlayHint,
    token?: code.CancellationToken
) => Promise<code.InlayHint>;

method asInlayHints

asInlayHints: {
    (
        values: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (values: ls.InlayHint[], token?: code.CancellationToken): Promise<
        code.InlayHint[]
    >;
    (values: ls.InlayHint[], token?: code.CancellationToken): Promise<
        code.InlayHint[]
    >;
};

method asInlineCompletionItem

asInlineCompletionItem: (
    item: ls.InlineCompletionItem
) => code.InlineCompletionItem;

method asInlineCompletionResult

asInlineCompletionResult: {
    (
        value: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        value: ls.InlineCompletionList,
        token?: code.CancellationToken
    ): Promise<code.InlineCompletionList>;
    (value: ls.InlineCompletionItem[], token?: code.CancellationToken): Promise<
        code.InlineCompletionItem[]
    >;
    (value: any, token?: code.CancellationToken): Promise<any>;
};

method asInlineValue

asInlineValue: (value: ls.InlineValue) => code.InlineValue;

method asInlineValues

asInlineValues: {
    (
        values: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (values: ls.InlineValue[], token?: code.CancellationToken): Promise<
        code.InlineValue[]
    >;
    (values: ls.InlineValue[], token?: code.CancellationToken): Promise<
        code.InlineValue[]
    >;
};

method asLinkedEditingRanges

asLinkedEditingRanges: {
    (
        value: null | undefined,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        value: ls.LinkedEditingRanges,
        token?: code.CancellationToken
    ): Promise<code.LinkedEditingRanges>;
    (value: any, token?: code.CancellationToken): Promise<any>;
};

method asLocation

asLocation: {
    (item: ls.Location): code.Location;
    (item: null): undefined;
    (item: any): any;
};

method asParameterInformation

asParameterInformation: (
    item: ls.ParameterInformation
) => code.ParameterInformation;

method asParameterInformations

asParameterInformations: (
    item: ls.ParameterInformation[],
    token?: code.CancellationToken
) => Promise<code.ParameterInformation[]>;

method asPosition

asPosition: {
    (value: undefined | null): undefined;
    (value: ls.Position): code.Position;
    (value: any): any;
};

method asRange

asRange: {
    (value: undefined | null): undefined;
    (value: ls.Range): code.Range;
    (value: any): any;
};

method asRanges

asRanges: (
    items: ReadonlyArray<ls.Range>,
    token?: code.CancellationToken
) => Promise<code.Range[]>;

method asReferences

asReferences: {
    (
        values: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (values: ls.Location[], token?: code.CancellationToken): Promise<
        code.Location[]
    >;
    (values: ls.Location[], token?: code.CancellationToken): Promise<
        code.Location[]
    >;
};

method asSelectionRange

asSelectionRange: (selectionRange: ls.SelectionRange) => code.SelectionRange;

method asSelectionRanges

asSelectionRanges: {
    (
        selectionRanges: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        selectionRanges: ls.SelectionRange[],
        token?: code.CancellationToken
    ): Promise<code.SelectionRange[]>;
    (
        selectionRanges: ls.SelectionRange[],
        token?: code.CancellationToken
    ): Promise<code.SelectionRange[]>;
};

method asSemanticTokens

asSemanticTokens: {
    (
        value: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        value: ls.SemanticTokens,
        token?: code.CancellationToken
    ): Promise<code.SemanticTokens>;
    (value: any, token?: code.CancellationToken): Promise<any>;
};

method asSemanticTokensEdit

asSemanticTokensEdit: (value: ls.SemanticTokensEdit) => code.SemanticTokensEdit;

method asSemanticTokensEdits

asSemanticTokensEdits: {
    (
        value: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        value: ls.SemanticTokensDelta,
        token?: code.CancellationToken
    ): Promise<code.SemanticTokensEdits>;
    (value: any, token?: code.CancellationToken): Promise<any>;
};

method asSemanticTokensLegend

asSemanticTokensLegend: (
    value: ls.SemanticTokensLegend
) => code.SemanticTokensLegend;

method asSignatureHelp

asSignatureHelp: {
    (item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
    (
        item: ls.SignatureHelp,
        token?: code.CancellationToken
    ): Promise<code.SignatureHelp>;
    (item: any, token?: code.CancellationToken): Promise<any>;
};

method asSignatureInformation

asSignatureInformation: (
    item: ls.SignatureInformation,
    token?: code.CancellationToken
) => Promise<code.SignatureInformation>;

method asSignatureInformations

asSignatureInformations: (
    items: ls.SignatureInformation[],
    token?: code.CancellationToken
) => Promise<code.SignatureInformation[]>;

method asSymbolInformation

asSymbolInformation: (
    item: ls.SymbolInformation | ls.WorkspaceSymbol
) => code.SymbolInformation;

method asSymbolInformations

asSymbolInformations: {
    (
        values: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (
        values: ls.SymbolInformation[] | ls.WorkspaceSymbol[],
        token?: code.CancellationToken
    ): Promise<code.SymbolInformation[]>;
    (
        values: ls.SymbolInformation[] | ls.WorkspaceSymbol[],
        token?: code.CancellationToken
    ): Promise<code.SymbolInformation[]>;
};

method asSymbolKind

asSymbolKind: (item: ls.SymbolKind) => code.SymbolKind;

method asSymbolTag

asSymbolTag: (item: ls.SymbolTag) => code.SymbolTag | undefined;

method asSymbolTags

asSymbolTags: {
    (items: undefined | null): undefined;
    (items: readonly ls.SymbolTag[]): code.SymbolTag[];
    (items: readonly ls.SymbolTag[]): code.SymbolTag[];
};

method asTextEdit

asTextEdit: {
    (edit: undefined | null): undefined;
    (edit: ls.TextEdit): code.TextEdit;
    (edit: any): any;
};

method asTextEdits

asTextEdits: {
    (
        items: undefined | null,
        token?: code.CancellationToken
    ): Promise<undefined>;
    (items: ls.TextEdit[], token?: code.CancellationToken): Promise<
        code.TextEdit[]
    >;
    (items: ls.TextEdit[], token?: code.CancellationToken): Promise<
        code.TextEdit[]
    >;
};

method asTypeHierarchyItem

asTypeHierarchyItem: {
    (item: null): undefined;
    (item: ls.TypeHierarchyItem): code.TypeHierarchyItem;
    (item: any): any;
};

method asTypeHierarchyItems

asTypeHierarchyItems: {
    (items: null, token?: code.CancellationToken): Promise<undefined>;
    (items: ls.TypeHierarchyItem[], token?: code.CancellationToken): Promise<
        code.TypeHierarchyItem[]
    >;
    (items: ls.TypeHierarchyItem[], token?: code.CancellationToken): Promise<
        code.TypeHierarchyItem[]
    >;
};

method asUri

asUri: (value: string) => code.Uri;

method asWorkspaceEdit

asWorkspaceEdit: {
    (item: undefined | null, token?: code.CancellationToken): Promise<undefined>;
    (
        item: ls.WorkspaceEdit,
        token?: code.CancellationToken
    ): Promise<code.WorkspaceEdit>;
    (item: any, token?: code.CancellationToken): Promise<any>;
};

interface ProvideCodeActionsSignature

interface ProvideCodeActionsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    range: VRange,
    context: VCodeActionContext,
    token: CancellationToken
): ProviderResult<(VCommand | VCodeAction)[]>;

interface ProvideCodeLensesSignature

interface ProvideCodeLensesSignature {}

call signature

(this: void, document: TextDocument, token: CancellationToken): ProviderResult<
    VCodeLens[]
>;

interface ProvideColorPresentationSignature

interface ProvideColorPresentationSignature {}

call signature

(
    color: VColor,
    context: {
        document: TextDocument;
        range: VRange;
    },
    token: CancellationToken
): ProviderResult<VColorPresentation[]>;

interface ProvideCompletionItemsSignature

interface ProvideCompletionItemsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    context: VCompletionContext,
    token: CancellationToken
): ProviderResult<VCompletionItem[] | VCompletionList>;

interface ProvideDeclarationSignature

interface ProvideDeclarationSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VDeclaration>;

interface ProvideDefinitionSignature

interface ProvideDefinitionSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VDefinition | VDefinitionLink[]>;

interface ProvideDocumentColorsSignature

interface ProvideDocumentColorsSignature {}

call signature

(document: TextDocument, token: CancellationToken): ProviderResult<
    VColorInformation[]
>;

interface ProvideDocumentFormattingEditsSignature

interface ProvideDocumentFormattingEditsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    options: VFormattingOptions,
    token: CancellationToken
): ProviderResult<VTextEdit[]>;

interface ProvideDocumentHighlightsSignature

interface ProvideDocumentHighlightsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VDocumentHighlight[]>;

interface ProvideDocumentLinksSignature

interface ProvideDocumentLinksSignature {}

call signature

(this: void, document: TextDocument, token: CancellationToken): ProviderResult<
    VDocumentLink[]
>;

interface ProvideDocumentRangeFormattingEditsSignature

interface ProvideDocumentRangeFormattingEditsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    range: VRange,
    options: VFormattingOptions,
    token: CancellationToken
): ProviderResult<VTextEdit[]>;

interface ProvideDocumentSymbolsSignature

interface ProvideDocumentSymbolsSignature {}

call signature

(this: void, document: TextDocument, token: CancellationToken): ProviderResult<
    VSymbolInformation[] | VDocumentSymbol[]
>;

interface ProvideFoldingRangeSignature

interface ProvideFoldingRangeSignature {}

call signature

(
    this: void,
    document: TextDocument,
    context: FoldingContext,
    token: CancellationToken
): ProviderResult<VFoldingRange[]>;

interface ProvideHoverSignature

interface ProvideHoverSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VHover>;

interface ProvideImplementationSignature

interface ProvideImplementationSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VDefinition | VDefinitionLink[]>;

interface ProvideLinkedEditingRangeSignature

interface ProvideLinkedEditingRangeSignature {}

call signature

(
    this: void,
    document: code.TextDocument,
    position: code.Position,
    token: code.CancellationToken
): code.ProviderResult<code.LinkedEditingRanges>;

interface ProvideOnTypeFormattingEditsSignature

interface ProvideOnTypeFormattingEditsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    ch: string,
    options: VFormattingOptions,
    token: CancellationToken
): ProviderResult<VTextEdit[]>;

interface ProvideReferencesSignature

interface ProvideReferencesSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    options: {
        includeDeclaration: boolean;
    },
    token: CancellationToken
): ProviderResult<VLocation[]>;

interface ProvideRenameEditsSignature

interface ProvideRenameEditsSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    newName: string,
    token: CancellationToken
): ProviderResult<VWorkspaceEdit>;

interface ProvideSelectionRangeSignature

interface ProvideSelectionRangeSignature {}

call signature

(
    this: void,
    document: TextDocument,
    positions: readonly VPosition[],
    token: CancellationToken
): ProviderResult<VSelectionRange[]>;

interface ProvideSignatureHelpSignature

interface ProvideSignatureHelpSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    context: VSignatureHelpContext,
    token: CancellationToken
): ProviderResult<VSignatureHelp>;

interface ProvideTypeDefinitionSignature

interface ProvideTypeDefinitionSignature {}

call signature

(
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
): ProviderResult<VDefinition | VDefinitionLink[]>;

interface ProvideWorkspaceSymbolsSignature

interface ProvideWorkspaceSymbolsSignature {}

call signature

(this: void, query: string, token: CancellationToken): ProviderResult<
    VSymbolInformation[]
>;

interface ReferencesMiddleware

interface ReferencesMiddleware {}

property provideReferences

provideReferences?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    options: {
        includeDeclaration: boolean;
    },
    token: CancellationToken,
    next: ProvideReferencesSignature
) => ProviderResult<VLocation[]>;

interface RegistrationData

interface RegistrationData<T> {}

property id

id: string;

property registerOptions

registerOptions: T;

interface RenameMiddleware

interface RenameMiddleware {}

property prepareRename

prepareRename?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: PrepareRenameSignature
) => ProviderResult<
    | VRange
    | {
          range: VRange;
          placeholder: string;
      }
>;

property provideRenameEdits

provideRenameEdits?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    newName: string,
    token: CancellationToken,
    next: ProvideRenameEditsSignature
) => ProviderResult<VWorkspaceEdit>;

interface ResolveCodeActionSignature

interface ResolveCodeActionSignature {}

call signature

(
    this: void,
    item: VCodeAction,
    token: CancellationToken
): ProviderResult<VCodeAction>;

interface ResolveCodeLensSignature

interface ResolveCodeLensSignature {}

call signature

(
    this: void,
    codeLens: VCodeLens,
    token: CancellationToken
): ProviderResult<VCodeLens>;

interface ResolveCompletionItemSignature

interface ResolveCompletionItemSignature {}

call signature

(
    this: void,
    item: VCompletionItem,
    token: CancellationToken
): ProviderResult<VCompletionItem>;

interface ResolveDocumentLinkSignature

interface ResolveDocumentLinkSignature {}

call signature

(
    this: void,
    link: VDocumentLink,
    token: CancellationToken
): ProviderResult<VDocumentLink>;

interface ResolveWorkspaceSymbolSignature

interface ResolveWorkspaceSymbolSignature {}

call signature

(
    this: void,
    item: VSymbolInformation,
    token: CancellationToken
): ProviderResult<VSymbolInformation>;

interface SelectionRangeProviderMiddleware

interface SelectionRangeProviderMiddleware {}

property provideSelectionRanges

provideSelectionRanges?: (
    this: void,
    document: TextDocument,
    positions: readonly VPosition[],
    token: CancellationToken,
    next: ProvideSelectionRangeSignature
) => ProviderResult<VSelectionRange[]>;

interface SemanticTokensMiddleware

interface SemanticTokensMiddleware {}

The semantic token middleware
3.16.0

property provideDocumentRangeSemanticTokens

provideDocumentRangeSemanticTokens?: (
    this: void,
    document: vscode.TextDocument,
    range: vscode.Range,
    token: vscode.CancellationToken,
    next: DocumentRangeSemanticTokensSignature
) => vscode.ProviderResult<vscode.SemanticTokens>;

property provideDocumentSemanticTokens

provideDocumentSemanticTokens?: (
    this: void,
    document: vscode.TextDocument,
    token: vscode.CancellationToken,
    next: DocumentSemanticsTokensSignature
) => vscode.ProviderResult<vscode.SemanticTokens>;

property provideDocumentSemanticTokensEdits

provideDocumentSemanticTokensEdits?: (
    this: void,
    document: vscode.TextDocument,
    previousResultId: string,
    token: vscode.CancellationToken,
    next: DocumentSemanticsTokensEditsSignature
) => vscode.ProviderResult<vscode.SemanticTokensEdits | vscode.SemanticTokens>;

interface SemanticTokensProviderShape

interface SemanticTokensProviderShape {}

property full

full?: vscode.DocumentSemanticTokensProvider;

property onDidChangeSemanticTokensEmitter

onDidChangeSemanticTokensEmitter: vscode.EventEmitter<void>;

property range

range?: vscode.DocumentRangeSemanticTokensProvider;

interface SignatureHelpMiddleware

interface SignatureHelpMiddleware {}

property provideSignatureHelp

provideSignatureHelp?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    context: VSignatureHelpContext,
    token: CancellationToken,
    next: ProvideSignatureHelpSignature
) => ProviderResult<VSignatureHelp>;

interface StateChangeEvent

interface StateChangeEvent {}

An event signaling a state change.

property newState

newState: State;

property oldState

oldState: State;

interface StaticFeature

interface StaticFeature {}

A static feature. A static feature can't be dynamically activated via the server. It is wired during the initialize sequence.

property fillInitializeParams

fillInitializeParams?: (params: InitializeParams) => void;

Called to fill the initialize params.
the initialize params.

property preInitialize

preInitialize?: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector | undefined
) => void;

A preflight where the server capabilities are shown to all features before a feature is actually initialized. This allows feature to capture some state if they are a pre-requisite for other features.
Parameter capabilities
the server capabilities
Parameter documentSelector
the document selector pass to the client's constructor. May be undefined if the client was created without a selector.

method clear

clear: () => void;

Called when the client is stopped or re-started to clear this feature. Usually a feature un-registers listeners registered hooked up with the VS Code extension host.

method fillClientCapabilities

fillClientCapabilities: (capabilities: ClientCapabilities) => void;

Called to fill in the client capabilities this feature implements.
Parameter capabilities
The client capabilities to fill.

method getState

getState: () => FeatureState;

Returns the state the feature is in.

method initialize

initialize: (
    capabilities: ServerCapabilities,
    documentSelector: DocumentSelector | undefined
) => void;

Initialize the feature. This method is called on a feature instance when the client has successfully received the initialize request from the server and before the client sends the initialized notification to the server.
Parameter capabilities
the server capabilities
Parameter documentSelector
the document selector pass to the client's constructor. May be undefined if the client was created without a selector.

interface TextDocumentProviderFeature

interface TextDocumentProviderFeature<T> {}

A mixin type to access a provider that is registered for a given text document / document selector.

method getProvider

getProvider: (textDocument: TextDocument) => T | undefined;

Triggers the corresponding RPC method.

interface TextDocumentSendFeature

interface TextDocumentSendFeature<T extends Function> {}

A mixin type that allows to send notification or requests using a registered provider.

method getProvider

getProvider: (document: TextDocument) => { send: T } | undefined;

Returns a provider for the given text document.

interface TextDocumentSynchronizationMiddleware

interface TextDocumentSynchronizationMiddleware {}

property didChange

didChange?: NextSignature<TextDocumentChangeEvent, Promise<void>>;

property didClose

didClose?: NextSignature<TextDocument, Promise<void>>;

property didOpen

didOpen?: NextSignature<TextDocument, Promise<void>>;

property didSave

didSave?: NextSignature<TextDocument, Promise<void>>;

property willSave

willSave?: NextSignature<TextDocumentWillSaveEvent, Promise<void>>;

property willSaveWaitUntil

willSaveWaitUntil?: NextSignature<
    TextDocumentWillSaveEvent,
    Thenable<VTextEdit[]>
>;

interface TypeDefinitionMiddleware

interface TypeDefinitionMiddleware {}

property provideTypeDefinition

provideTypeDefinition?: (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken,
    next: ProvideTypeDefinitionSignature
) => ProviderResult<VDefinition | VDefinitionLink[]>;

interface VisibleDocuments

interface VisibleDocuments {}

property onClose

onClose: Event<Set<Uri>>;

property onOpen

onOpen: Event<Set<Uri>>;

method getResources

getResources: () => Set<Uri>;

method isActive

isActive: (document: TextDocument | Uri) => boolean;

method isVisible

isVisible: (document: TextDocument | Uri) => boolean;

interface WorkspaceProviderFeature

interface WorkspaceProviderFeature<PR> {}

method getProviders

getProviders: () => PR[] | undefined;

interface WorkspaceSymbolMiddleware

interface WorkspaceSymbolMiddleware {}

property provideWorkspaceSymbols

provideWorkspaceSymbols?: (
    this: void,
    query: string,
    token: CancellationToken,
    next: ProvideWorkspaceSymbolsSignature
) => ProviderResult<VSymbolInformation[]>;

property resolveWorkspaceSymbol

resolveWorkspaceSymbol?: (
    this: void,
    item: VSymbolInformation,
    token: CancellationToken,
    next: ResolveWorkspaceSymbolSignature
) => ProviderResult<VSymbolInformation>;

Enums

enum CloseAction

enum CloseAction {
    DoNotRestart = 1,
    Restart = 2,
}

An action to be performed when the connection to a server got closed.

member DoNotRestart

DoNotRestart = 1

Don't restart the server. The connection stays closed.

member Restart

Restart = 2

Restart the server.

enum DiagnosticCollectionSource

enum DiagnosticCollectionSource {
    push = 'push',
    pull = 'pull',
}

member pull

pull = 'pull'

member push

push = 'push'

enum DiagnosticPullMode

enum DiagnosticPullMode {
    onType = 'onType',
    onSave = 'onSave',
    onFocus = 'onFocus',
}

member onFocus

onFocus = 'onFocus'

member onSave

onSave = 'onSave'

member onType

onType = 'onType'

enum ErrorAction

enum ErrorAction {
    Continue = 1,
    Shutdown = 2,
}

An action to be performed when the connection is producing errors.

member Continue

Continue = 1

Continue running the server.

member Shutdown

Shutdown = 2

Shutdown the server.

enum RevealOutputChannelOn

enum RevealOutputChannelOn {
    Debug = 0,
    Info = 1,
    Warn = 2,
    Error = 3,
    Never = 4,
}

Controls when the output channel is revealed.

member Debug

Debug = 0

member Error

Error = 3

member Info

Info = 1

member Never

Never = 4

member Warn

Warn = 2

enum ShutdownMode

enum ShutdownMode {
    Restart = 'restart',
    Stop = 'stop',
}

member Restart

Restart = 'restart'

member Stop

Stop = 'stop'

enum State

enum State {
    Stopped = 1,
    Starting = 3,
    StartFailed = 4,
    Running = 2,
}

Signals in which state the language client is in.

member Running

Running = 2

The client is running and ready.

member StartFailed

StartFailed = 4

The start has failed.

member Starting

Starting = 3

The client is starting but not ready yet.

member Stopped

Stopped = 1

The client is stopped or got never started.

enum SuspendMode

enum SuspendMode {
    off = 'off',
    on = 'on',
}

member off

off = 'off'

Don't allow suspend mode.

member on

on = 'on'

Support suspend mode even if not all registered providers have a corresponding activation listener.

Type Aliases

type CloseHandlerResult

type CloseHandlerResult = {
    /**
     * The action to take.
     */
    action: CloseAction;
    /**
     * An optional message to be presented to the user.
     */
    message?: string;
    /**
     * If set to true the client assumes that the corresponding
     * close handler has presented an appropriate message to the
     * user and the message will only be log to the client's
     * output channel.
     */
    handled?: boolean;
};

type CodeLensProviderShape

type CodeLensProviderShape = {
    provider?: CodeLensProvider;
    onDidChangeCodeLensEmitter: EventEmitter<void>;
};

type DiagnosticProviderMiddleware

type DiagnosticProviderMiddleware = {
    provideDiagnostics?: (
        this: void,
        document: TextDocument | Uri,
        previousResultId: string | undefined,
        token: CancellationToken,
        next: ProvideDiagnosticSignature
    ) => ProviderResult<vsdiag.DocumentDiagnosticReport>;
    provideWorkspaceDiagnostics?: (
        this: void,
        resultIds: vsdiag.PreviousResultId[],
        token: CancellationToken,
        resultReporter: vsdiag.ResultReporter,
        next: ProvideWorkspaceDiagnosticSignature
    ) => ProviderResult<vsdiag.WorkspaceDiagnosticReport>;
};

type DiagnosticProviderShape

type DiagnosticProviderShape = {
    /**
     * An event that signals that the diagnostics should be refreshed for
     * all documents.
     */
    onDidChangeDiagnosticsEmitter: EventEmitter<void>;
    /**
     * The provider of diagnostics.
     */
    diagnostics: vsdiag.DiagnosticProvider;
    /**
     * Forget the given document and remove all diagnostics.
     *
     * @param document The document to forget.
     */
    forget(document: TextDocument): void;
};

type DiagnosticPullOptions

type DiagnosticPullOptions = {
    /**
     * Whether to pull for diagnostics on document change.
     */
    onChange?: boolean;
    /**
     * Whether to pull for diagnostics on document save.
     */
    onSave?: boolean;
    /**
     * Whether to pull for diagnostics on editor focus.
     */
    onFocus?: boolean;
    /**
     * An optional filter method that is consulted when triggering a
     * diagnostic pull during document change, document save or editor
     * focus.
     *
     * The document gets filtered if the method returns `true`.
     *
     * @param document The document that changed or got saved.
     * @param mode The pull mode.
     * @returns whether the document should be filtered (`true`) or not.
     */
    filter?(document: TextDocument, mode: DiagnosticPullMode): boolean;
    /**
     * Whether to pull for diagnostics on resources of non instantiated
     * tabs. If it is set to true it is highly recommended to provide
     * a match method as well. Otherwise the client will not pull for
     * tabs if the used document selector specifies a language property
     * since the language value is not known for resources.
     */
    onTabs?: boolean;
    /**
     * An optional match method that is consulted when pulling for diagnostics
     * when only a URI is known (e.g. for not instantiated tabs)
     *
     * The method should return `true` if the document selector matches the
     * given resource. See also the `vscode.languages.match` function.
     *
     * @param documentSelector The document selector.
     * @param resource The resource.
     * @returns whether the resource is matched by the given document selector.
     */
    match?(documentSelector: DocumentSelector, resource: Uri): boolean;
};

type DocumentSelectorOptions

type DocumentSelectorOptions = {
    documentSelector: DocumentSelector;
};

type ErrorHandlerResult

type ErrorHandlerResult = {
    /**
     * The action to take.
     */
    action: ErrorAction;
    /**
     * An optional message to be presented to the user.
     */
    message?: string;
    /**
     * If set to true the client assumes that the corresponding
     * error handler has presented an appropriate message to the
     * user and the message will only be log to the client's
     * output channel.
     */
    handled?: boolean;
};

type FeatureState

type FeatureState =
    | {
          kind: 'document';
          /**
           * The features's id. This is usually the method names used during
           * registration.
           */
          id: string;
          /**
           * Has active registrations.
           */
          registrations: boolean;
          /**
           * A registration matches an open document.
           */
          matches: boolean;
      }
    | {
          kind: 'workspace';
          /**
           * The features's id. This is usually the method names used during
           * registration.
           */
          id: string;
          /**
           * Has active registrations.
           */
          registrations: boolean;
      }
    | {
          kind: 'window';
          /**
           * The features's id. This is usually the method names used during
           * registration.
           */
          id: string;
          /**
           * Has active registrations.
           */
          registrations: boolean;
      }
    | {
          kind: 'static';
      };

type FeatureStateKind

type FeatureStateKind = 'document' | 'workspace' | 'static' | 'window';

type InitializationFailedHandler

type InitializationFailedHandler =
    /**
     * @param error The error returned from the server
     * @returns if true is returned the client tries to reinitialize the server.
     *  Implementors of a handler are responsible to not initialize the server
     *  infinitely. Return false if initialization should stop and an error
     *  should be reported.
     */
    (error: ResponseError<InitializeError> | Error | any) => boolean;

A handler that is invoked when the initialization of the server failed.

type InlayHintsMiddleware

type InlayHintsMiddleware = {
    provideInlayHints?: (
        this: void,
        document: TextDocument,
        viewPort: VRange,
        token: CancellationToken,
        next: ProvideInlayHintsSignature
    ) => ProviderResult<VInlayHint[]>;
    resolveInlayHint?: (
        this: void,
        item: VInlayHint,
        token: CancellationToken,
        next: ResolveInlayHintSignature
    ) => ProviderResult<VInlayHint>;
};

type InlayHintsProviderShape

type InlayHintsProviderShape = {
    provider: InlayHintsProvider;
    onDidChangeInlayHints: EventEmitter<void>;
};

type InlineValueMiddleware

type InlineValueMiddleware = {
    provideInlineValues?: (
        this: void,
        document: TextDocument,
        viewPort: VRange,
        context: VInlineValueContext,
        token: CancellationToken,
        next: ProvideInlineValuesSignature
    ) => ProviderResult<VInlineValue[]>;
};

type InlineValueProviderShape

type InlineValueProviderShape = {
    provider: InlineValuesProvider;
    onDidChangeInlineValues: EventEmitter<void>;
};

type LanguageClientOptions

type LanguageClientOptions = {
    documentSelector?: DocumentSelector | string[];
    /**
     * The name of the diagnostic collection that is created by the client.
     * If omitted the name of the client is used.
     *
     * **Note:** the name is only used if the server uses the old
     * `textDocument/publishDiagnostics` notification. If the server uses the
     * new `textDocument/diagnostic` request the name of the collection is
     * defined by the server using the `identifier` property of the
     * `DiagnosticOptions` during registration.
     */
    diagnosticCollectionName?: string;
    outputChannel?: LogOutputChannel;
    outputChannelName?: string;
    traceOutputChannel?: LogOutputChannel;
    revealOutputChannelOn?: RevealOutputChannelOn;
    /**
     * The encoding use to read stdout and stderr. Defaults
     * to 'utf8' if omitted.
     */
    stdioEncoding?: string;
    initializationOptions?: any | (() => any);
    initializationFailedHandler?: InitializationFailedHandler;
    progressOnInitialization?: boolean;
    errorHandler?: ErrorHandler;
    middleware?: Middleware;
    uriConverters?: {
        code2Protocol: c2p.URIConverter;
        protocol2Code: p2c.URIConverter;
    };
    workspaceFolder?: VWorkspaceFolder;
    connectionOptions?: {
        cancellationStrategy?: CancellationStrategy;
        messageStrategy?: MessageStrategy;
        maxRestartCount?: number;
    };
    markdown?: {
        isTrusted?:
            | boolean
            | {
                  readonly enabledCommands: readonly string[];
              };
        supportHtml?: boolean;
        supportThemeIcons?: boolean;
    };
    textSynchronization?: {
        /**
         * Delays sending the open notification until one of the following
         * conditions becomes `true`:
         * - document is visible in the editor.
         * - any of the other notifications or requests is sent to the server, except
         *   a closed notification for the pending document.
         */
        delayOpenNotifications?: boolean;
    };
} & $NotebookDocumentOptions &
    $DiagnosticPullOptions &
    $ConfigurationOptions;

type Middleware

type Middleware = _Middleware &
    TextDocumentSynchronizationMiddleware &
    CompletionMiddleware &
    HoverMiddleware &
    DefinitionMiddleware &
    SignatureHelpMiddleware &
    DocumentHighlightMiddleware &
    DocumentSymbolMiddleware &
    WorkspaceSymbolMiddleware &
    ReferencesMiddleware &
    TypeDefinitionMiddleware &
    ImplementationMiddleware &
    ColorProviderMiddleware &
    CodeActionMiddleware &
    CodeLensMiddleware &
    FormattingMiddleware &
    RenameMiddleware &
    DocumentLinkMiddleware &
    ExecuteCommandMiddleware &
    FoldingRangeProviderMiddleware &
    DeclarationMiddleware &
    SelectionRangeProviderMiddleware &
    CallHierarchyMiddleware &
    SemanticTokensMiddleware &
    LinkedEditingRangeMiddleware &
    TypeHierarchyMiddleware &
    InlineValueMiddleware &
    InlayHintsMiddleware &
    NotebookDocumentMiddleware &
    DiagnosticProviderMiddleware &
    InlineCompletionMiddleware &
    TextDocumentContentMiddleware &
    GeneralMiddleware;

The Middleware lets extensions intercept the request and notifications send and received from the server

type NotebookDocumentMiddleware

type NotebookDocumentMiddleware = {
    notebooks?: {
        didOpen?: (
            this: void,
            notebookDocument: vscode.NotebookDocument,
            cells: vscode.NotebookCell[],
            next: (
                this: void,
                notebookDocument: vscode.NotebookDocument,
                cells: vscode.NotebookCell[]
            ) => Promise<void>
        ) => Promise<void>;
        didSave?: (
            this: void,
            notebookDocument: vscode.NotebookDocument,
            next: (
                this: void,
                notebookDocument: vscode.NotebookDocument
            ) => Promise<void>
        ) => Promise<void>;
        didChange?: (
            this: void,
            event: VNotebookDocumentChangeEvent,
            next: (this: void, event: VNotebookDocumentChangeEvent) => Promise<void>
        ) => Promise<void>;
        didClose?: (
            this: void,
            notebookDocument: vscode.NotebookDocument,
            cells: vscode.NotebookCell[],
            next: (
                this: void,
                notebookDocument: vscode.NotebookDocument,
                cells: vscode.NotebookCell[]
            ) => Promise<void>
        ) => Promise<void>;
    };
};

type NotebookDocumentOptions

type NotebookDocumentOptions = {
    filterCells?(
        notebookDocument: vscode.NotebookDocument,
        cells: vscode.NotebookCell[]
    ): vscode.NotebookCell[];
};

type PrepareTypeHierarchySignature

type PrepareTypeHierarchySignature = (
    this: void,
    document: TextDocument,
    position: VPosition,
    token: CancellationToken
) => ProviderResult<VTypeHierarchyItem[]>;

type ProvideDiagnosticSignature

type ProvideDiagnosticSignature = (
    this: void,
    document: TextDocument | Uri,
    previousResultId: string | undefined,
    token: CancellationToken
) => ProviderResult<vsdiag.DocumentDiagnosticReport>;

type ProvideInlayHintsSignature

type ProvideInlayHintsSignature = (
    this: void,
    document: TextDocument,
    viewPort: VRange,
    token: CancellationToken
) => ProviderResult<VInlayHint[]>;

type ProvideInlineValuesSignature

type ProvideInlineValuesSignature = (
    this: void,
    document: TextDocument,
    viewPort: VRange,
    context: VInlineValueContext,
    token: CancellationToken
) => ProviderResult<VInlineValue[]>;

type ProvideWorkspaceDiagnosticSignature

type ProvideWorkspaceDiagnosticSignature = (
    this: void,
    resultIds: vsdiag.PreviousResultId[],
    token: CancellationToken,
    resultReporter: vsdiag.ResultReporter
) => ProviderResult<vsdiag.WorkspaceDiagnosticReport>;

type ResolveInlayHintSignature

type ResolveInlayHintSignature = (
    this: void,
    item: VInlayHint,
    token: CancellationToken
) => ProviderResult<VInlayHint>;

type ServerOptions

type ServerOptions = Worker | (() => Promise<Worker | MessageTransports>);

type SuspendOptions

type SuspendOptions = {
    /**
     * Whether suspend mode is supported. If suspend mode is allowed
     * the client will stop a running server when going into suspend mode.
     * If omitted defaults to SuspendMode.off;
     */
    mode?: SuspendMode;
    /**
     * A callback that is invoked before actually suspending
     * the server. If `false` is returned the client will not continue
     * suspending the server.
     */
    callback?: () => Promise<boolean>;
    /**
     * The interval in milliseconds used to check if the server
     * can be suspended. If the check passes three times in a row
     * (e.g. the server can be suspended for 3 * interval ms) the
     * server is suspended. Defaults to 60000ms, which is also the
     * minimum allowed value.
     */
    interval?: number;
};

type SynchronizeOptions

type SynchronizeOptions = {
    /**
     * The configuration sections to synchronize. Pushing settings from the
     * client to the server is deprecated in favour of the new pull model
     * that allows servers to query settings scoped on resources. In this
     * model the client can only deliver an empty change event since the
     * actually setting value can vary on the provided resource scope.
     *
     * @deprecated Use the new pull model (`workspace/configuration` request)
     */
    configurationSection?: string | string[];
    /**
     * Asks the client to send file change events to the server. Watchers
     * operate on workspace folders. The LSP client doesn't support watching
     * files outside a workspace folder.
     */
    fileEvents?: VFileSystemWatcher | VFileSystemWatcher[];
};

type TypeHierarchyMiddleware

type TypeHierarchyMiddleware = {
    prepareTypeHierarchy?: (
        this: void,
        document: TextDocument,
        positions: VPosition,
        token: CancellationToken,
        next: PrepareTypeHierarchySignature
    ) => ProviderResult<VTypeHierarchyItem[]>;
    provideTypeHierarchySupertypes?: (
        this: void,
        item: VTypeHierarchyItem,
        token: CancellationToken,
        next: TypeHierarchySupertypesSignature
    ) => ProviderResult<VTypeHierarchyItem[]>;
    provideTypeHierarchySubtypes?: (
        this: void,
        item: VTypeHierarchyItem,
        token: CancellationToken,
        next: TypeHierarchySubtypesSignature
    ) => ProviderResult<VTypeHierarchyItem[]>;
};

Type hierarchy middleware
3.17.0

type TypeHierarchySubtypesSignature

type TypeHierarchySubtypesSignature = (
    this: void,
    item: VTypeHierarchyItem,
    token: CancellationToken
) => ProviderResult<VTypeHierarchyItem[]>;

type TypeHierarchySupertypesSignature

type TypeHierarchySupertypesSignature = (
    this: void,
    item: VTypeHierarchyItem,
    token: CancellationToken
) => ProviderResult<VTypeHierarchyItem[]>;

type VNotebookDocumentChangeEvent

type VNotebookDocumentChangeEvent = {
    /**
     * The notebook document
     */
    notebook: vscode.NotebookDocument;
    /**
     * The changed meta data if any.
     */
    metadata?: {
        [key: string]: any;
    };
    /**
     * Changes to cells.
     */
    cells?: {
        /**
         * Changes to the cell structure to add or
         * remove cells.
         */
        structure?: {
            /**
             * The change to the cell array.
             */
            array: {
                start: number;
                deleteCount: number;
                cells?: vscode.NotebookCell[];
            };
            /**
             * Additional opened cell text documents.
             */
            didOpen?: vscode.NotebookCell[];
            /**
             * Additional closed cell text documents.
             */
            didClose?: vscode.NotebookCell[];
        };
        /**
         * Changes to notebook cells properties like its
         * kind or metadata.
         */
        data?: vscode.NotebookCell[];
        /**
         * Changes to the text content of notebook cells.
         */
        textContent?: vscode.TextDocumentChangeEvent[];
    };
};

type WindowMiddleware

type WindowMiddleware = _WindowMiddleware;

type WorkspaceFolderMiddleware

type WorkspaceFolderMiddleware = {
    workspaceFolders?: WorkspaceFoldersRequest.MiddlewareSignature;
    didChangeWorkspaceFolders?: NextSignature<
        VWorkspaceFoldersChangeEvent,
        Promise<void>
    >;
};

type WorkspaceMiddleware

type WorkspaceMiddleware = _WorkspaceMiddleware &
    ConfigurationMiddleware &
    DidChangeConfigurationMiddleware &
    WorkspaceFolderMiddleware &
    FileOperationsMiddleware;

Namespaces

namespace DynamicFeature

namespace DynamicFeature {}

function is

is: <T>(value: any) => value is DynamicFeature<T>;

namespace MessageTransports

namespace MessageTransports {}

function is

is: (value: any) => value is MessageTransports;

namespace ProposedFeatures

namespace ProposedFeatures {}

function createAll

createAll: (
    _client: FeatureClient<Middleware, LanguageClientOptions>
) => (StaticFeature | DynamicFeature<any>)[];

namespace StaticFeature

namespace StaticFeature {}

function is

is: (value: any) => value is StaticFeature;

namespace vscode

module 'vscode' {}

interface CodeAction

interface CodeAction {}

property isAI

isAI?: boolean;

Marks this as an AI action.
Ex: A quick fix should be marked AI if it invokes AI.

namespace vsdiag

namespace vsdiag {}

interface DiagnosticProvider

interface DiagnosticProvider {}

property onDidChangeDiagnostics

onDidChangeDiagnostics: VEvent<void>;

method provideDiagnostics

provideDiagnostics: (
    document: TextDocument | Uri,
    previousResultId: string | undefined,
    token: CancellationToken
) => ProviderResult<DocumentDiagnosticReport>;

method provideWorkspaceDiagnostics

provideWorkspaceDiagnostics: (
    resultIds: PreviousResultId[],
    token: CancellationToken,
    resultReporter: ResultReporter
) => ProviderResult<WorkspaceDiagnosticReport>;

interface FullDocumentDiagnosticReport

interface FullDocumentDiagnosticReport {}

property items

items: VDiagnostic[];

property kind

kind: DocumentDiagnosticReportKind.full;

property resultId

resultId?: string;

interface RelatedFullDocumentDiagnosticReport

interface RelatedFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport {}

property relatedDocuments

relatedDocuments?: {
    [uri: string /** DocumentUri */]:
        | FullDocumentDiagnosticReport
        | UnchangedDocumentDiagnosticReport;
};

interface RelatedUnchangedDocumentDiagnosticReport

interface RelatedUnchangedDocumentDiagnosticReport
    extends UnchangedDocumentDiagnosticReport {}

property relatedDocuments

relatedDocuments?: {
    [uri: string /** DocumentUri */]:
        | FullDocumentDiagnosticReport
        | UnchangedDocumentDiagnosticReport;
};

interface ResultReporter

interface ResultReporter {}

call signature

(chunk: WorkspaceDiagnosticReportPartialResult | null): void;

interface UnchangedDocumentDiagnosticReport

interface UnchangedDocumentDiagnosticReport {}

property kind

kind: DocumentDiagnosticReportKind.unChanged;

property resultId

resultId: string;

interface WorkspaceDiagnosticReport

interface WorkspaceDiagnosticReport {}

property items

items: WorkspaceDocumentDiagnosticReport[];

interface WorkspaceDiagnosticReportPartialResult

interface WorkspaceDiagnosticReportPartialResult {}

property items

items: WorkspaceDocumentDiagnosticReport[];

interface WorkspaceFullDocumentDiagnosticReport

interface WorkspaceFullDocumentDiagnosticReport
    extends FullDocumentDiagnosticReport {}

property uri

uri: Uri;

property version

version: number | null;

interface WorkspaceUnchangedDocumentDiagnosticReport

interface WorkspaceUnchangedDocumentDiagnosticReport
    extends UnchangedDocumentDiagnosticReport {}

property uri

uri: Uri;

property version

version: number | null;

enum DocumentDiagnosticReportKind

enum DocumentDiagnosticReportKind {
    full = 'full',
    unChanged = 'unChanged',
}

member full

full = 'full'

member unChanged

unChanged = 'unChanged'

type DocumentDiagnosticReport

type DocumentDiagnosticReport =
    | RelatedFullDocumentDiagnosticReport
    | RelatedUnchangedDocumentDiagnosticReport;

type PreviousResultId

type PreviousResultId = {
    uri: Uri;
    value: string;
};

type WorkspaceDocumentDiagnosticReport

type WorkspaceDocumentDiagnosticReport =
    | WorkspaceFullDocumentDiagnosticReport
    | WorkspaceUnchangedDocumentDiagnosticReport;

Package Files (38)

Dependencies (4)

Dev Dependencies (4)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/vscode-languageclient.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/vscode-languageclient)

HTML

<a href="https://www.jsdocs.io/package/vscode-languageclient"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 second ago.
Package analyzed in 9544 ms.
Missing or incorrect documentation? Open an issue for this package.