vscode-languageclient

vscode-languageclient

Version 9.0.1
Published 10 months ago
653 kB
3 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: OutputChannel;

property protocol2CodeConverter

readonly protocol2CodeConverter: p2c.Converter;

property state

readonly state: State;

property traceOutputChannel

readonly traceOutputChannel: OutputChannel;

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>;
    (request: any): DynamicFeature<NotebookDocumentSyncRegistrationOptions> &
        NotebookDocumentProviderShape;
    (request: any): DynamicFeature<InlineCompletionRegistrationOptions> &
        TextDocumentProviderFeature<InlineCompletionItemProvider>;
    (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
) => 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: NotificationHandler<P>
    ): Disposable;
    (type: NotificationType0, handler: NotificationHandler0): Disposable;
    <P>(type: NotificationType<P>, handler: NotificationHandler<P>): Disposable;
    (method: string, handler: GenericNotificationHandler): Disposable;
};

method onProgress

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

method onRequest

onRequest: {
    <R, PR, E, RO>(
        type: ProtocolRequestType0<R, PR, E, RO>,
        handler: RequestHandler0<R, E>
    ): Disposable;
    <P, R, PR, E, RO>(
        type: ProtocolRequestType<P, R, PR, E, RO>,
        handler: RequestHandler<P, R, E>
    ): Disposable;
    <R, E>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable;
    <P, R, E>(
        type: RequestType<P, R, E>,
        handler: 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?: P): Promise<void>;
    (type: NotificationType0): Promise<void>;
    <P>(type: NotificationType<P>, params?: P): Promise<void>;
    (method: string): Promise<void>;
    (method: string, params: any): Promise<void>;
};

method sendProgress

sendProgress: <P>(
    type: ProgressType<P>,
    token: string | number,
    value: 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: P,
        token?: CancellationToken
    ): Promise<R>;
    <R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
    <P, R, E>(
        type: RequestType<P, R, E>,
        params: 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 start

start: () => Promise<void>;

method stop

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

method warn

warn: (message: string, data?: any, showNotification?: boolean) => 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 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: CreateParamsSignature<E, P>,
    textDocument: (data: E) => TextDocument,
    selectorFilter?: (
        selectors: IterableIterator<VDocumentSelector>,
        data: E
    ) => boolean
);

property onNotificationSent

readonly onNotificationSent: VEvent<NotificationSendEvent<P>>;

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 notificationSent

protected notificationSent: (
    textDocument: TextDocument,
    type: ProtocolNotificationType<P, TextDocumentRegistrationOptions>,
    params: 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 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 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 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;

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>;
    (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
) => 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: NotificationHandler<P>
    ): Disposable;
    (type: NotificationType0, handler: NotificationHandler0): Disposable;
    <P>(type: NotificationType<P>, handler: NotificationHandler<P>): Disposable;
    (method: string, handler: GenericNotificationHandler): Disposable;
};

method onProgress

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

method onRequest

onRequest: {
    <R, PR, E, RO>(
        type: ProtocolRequestType0<R, PR, E, RO>,
        handler: RequestHandler0<R, E>
    ): Disposable;
    <P, R, PR, E, RO>(
        type: ProtocolRequestType<P, R, PR, E, RO>,
        handler: RequestHandler<P, R, E>
    ): Disposable;
    <R, E>(type: RequestType0<R, E>, handler: RequestHandler0<R, E>): Disposable;
    <P, R, E>(
        type: RequestType<P, R, E>,
        handler: 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?: P): Promise<void>;
    (type: NotificationType0): Promise<void>;
    <P>(type: NotificationType<P>, params?: 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: P,
        token?: CancellationToken
    ): Promise<R>;
    <R, E>(type: RequestType0<R, E>, token?: CancellationToken): Promise<R>;
    <P, R, E>(
        type: RequestType<P, R, E>,
        params: 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 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 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;
    }
> {}

property params

params: P;

property textDocument

textDocument: TextDocument;

property type

type: ProtocolNotificationType<P, TextDocumentRegistrationOptions>;

interface NotifyingFeature

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

property onNotificationSent

onNotificationSent: VEvent<NotificationSendEvent<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<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: ls.GlobPattern) => code.GlobPattern | undefined;

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

vscode-languageclient

Install

Overview

Index

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Functions

function ensure

Classes

class BaseLanguageClient

property clientOptions

property code2ProtocolConverter

property diagnostics

property initializeResult

property middleware

property name

property onDidChangeState

property onTelemetry

property outputChannel

property protocol2CodeConverter

property state

property traceOutputChannel

method createDefaultErrorHandler

method createMessageTransports

method debug

method dispose

method error

method fillInitializeParams

method getFeature

method getLocale

method handleConnectionClosed

method handleFailedRequest

method hasDedicatedTextSynchronizationFeature

method info

method isRunning

method needsStart

method needsStop

method onNotification

method onProgress

method onRequest

method registerBuiltinFeatures

method registerFeature

method registerFeatures

method registerProposedFeatures

method sendNotification

method sendProgress

method sendRequest

method setTrace

method start

method stop

method warn

class DynamicDocumentFeature

property registrationType

method clear

method fillClientCapabilities

method getDocumentSelectors

method getState

method initialize

method register

method unregister

class LSPCancellationError

property data

class TextDocumentEventFeature

property onNotificationSent

method callback

method clear

method getDocumentSelectors

method getProvider

method getStateInfo

method getTextDocument

method notificationSent

method register

method textDocumentFilter

method unregister

class TextDocumentLanguageFeature

property registrationType