@adecore/lsp 0.41.1 → 0.43.0

package/dist/connection.d.ts

@@ -34,6 +34,7 @@ export declare class JsonRpcConnection {
     constructor(transport: LspTransport, timeoutMs?: number);
     get isClosed(): boolean;
     request<T = unknown>(method: string, params?: unknown, options?: RequestOptions): Promise<T>;
+    private progressOf;
     notify(method: string, params?: unknown): Promise<void>;
     onRequest(method: string, handler: RequestHandler): Disposable;
     onNotification(method: string, listener: NotificationHandler): Disposable;

package/dist/connection.js

@@ -66,6 +66,7 @@ export class JsonRpcConnection {
             return Promise.reject(cancelledError());
         }
         const id = ++this.nextId;
+        const progress = this.progressOf(id, params, options);
         return new Promise((resolve, reject) => {
             let timer;
             const cancel = (error) => {
@@ -82,6 +83,7 @@ export class JsonRpcConnection {
                 cleanup: () => {
                     clearTimeout(timer);
                     options.signal?.removeEventListener('abort', abort);
+                    progress.listening?.dispose();
                 }
             });
             options.signal?.addEventListener('abort', abort, { once: true });
@@ -89,9 +91,35 @@ export class JsonRpcConnection {
             if (timeout > 0) {
                 timer = setTimeout(() => cancel(new LspError(`LSP request timed out: ${method}`, ErrorCodes.RequestCancelled)), timeout);
             }
-            void this.send({ jsonrpc: '2.0', id, method, params }).catch((error) => this.settle(id, undefined, error));
+            void this.send({ jsonrpc: '2.0', id, method, params: progress.params }).catch((error) => this.settle(id, undefined, error));
         });
     }
+    /* Adds the tokens of partial results and work-done progress to the params of a request, and hears `$/progress` for them. */
+    progressOf(id, params, options) {
+        const { onPartialResult, onWorkDoneProgress } = options;
+        if ((onPartialResult === undefined && onWorkDoneProgress === undefined) || params === null || typeof params !== 'object' || Array.isArray(params)) {
+            return { params };
+        }
+        const partialResultToken = onPartialResult === undefined ? undefined : `adecore-partial-${id}`;
+        const workDoneToken = onWorkDoneProgress === undefined ? undefined : `adecore-work-${id}`;
+        const listening = this.onNotification('$/progress', (value) => {
+            const { token, value: report } = value;
+            if (token === partialResultToken) {
+                onPartialResult?.(report);
+            }
+            else if (token === workDoneToken) {
+                onWorkDoneProgress?.(report);
+            }
+        });
+        return {
+            params: {
+                ...params,
+                ...(partialResultToken === undefined ? {} : { partialResultToken }),
+                ...(workDoneToken === undefined ? {} : { workDoneToken })
+            },
+            listening
+        };
+    }
     notify(method, params) {
         return this.send({ jsonrpc: '2.0', method, params });
     }

package/dist/document.d.ts

@@ -1,5 +1,5 @@
 import type { LspSession } from './session.ts';
-import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, CodeAction, CodeActionContext, CodeLens, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, DocumentDiagnosticReport, DocumentHighlight, DocumentItem, DocumentRequestOptions, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, Location, NavigationResult, Position, PrepareRenameResult, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextEdit, WorkspaceEdit } from './protocol.ts';
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, CodeAction, CodeActionContext, CodeLens, Color, ColorInformation, ColorPresentation, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, DocumentDiagnosticReport, DocumentHighlight, DocumentItem, DocumentLink, DocumentRequestOptions, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, InlineCompletionContext, InlineCompletionResult, InlineValue, InlineValueContext, LinkedEditingRanges, Location, Moniker, NavigationResult, Position, PrepareRenameResult, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextDocumentSaveReason, TextEdit, TypeHierarchyItem, WorkspaceEdit } from './protocol.ts';
 export declare class LspDocument {
     readonly session: LspSession;
     readonly uri: string;
@@ -52,6 +52,20 @@ export declare class LspDocument {
     incomingCalls(item: CallHierarchyItem, options?: DocumentRequestOptions): Promise<CallHierarchyIncomingCall[] | null>;
     outgoingCalls(item: CallHierarchyItem, options?: DocumentRequestOptions): Promise<CallHierarchyOutgoingCall[] | null>;
     diagnostics(previousResultId?: string, identifier?: string, options?: DocumentRequestOptions): Promise<DocumentDiagnosticReport>;
+    documentLinks(options?: DocumentRequestOptions): Promise<DocumentLink[] | null>;
+    resolveDocumentLink(link: DocumentLink, options?: DocumentRequestOptions): Promise<DocumentLink>;
+    documentColors(options?: DocumentRequestOptions): Promise<ColorInformation[] | null>;
+    colorPresentations(color: Color, range: Range, options?: DocumentRequestOptions): Promise<ColorPresentation[] | null>;
+    linkedEditingRanges(position: Position, options?: DocumentRequestOptions): Promise<LinkedEditingRanges | null>;
+    monikers(position: Position, options?: DocumentRequestOptions): Promise<Moniker[] | null>;
+    prepareTypeHierarchy(position: Position, options?: DocumentRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    supertypes(item: TypeHierarchyItem, options?: DocumentRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    subtypes(item: TypeHierarchyItem, options?: DocumentRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    inlineValues(range: Range, context: InlineValueContext, options?: DocumentRequestOptions): Promise<InlineValue[] | null>;
+    inlineCompletions(position: Position, context: InlineCompletionContext, options?: DocumentRequestOptions): Promise<InlineCompletionResult>;
+    rangesFormatting(ranges: readonly Range[], formatting: FormattingOptions, options?: DocumentRequestOptions): Promise<TextEdit[] | null>;
+    willSave(reason?: TextDocumentSaveReason): Promise<void>;
+    willSaveWaitUntil(reason?: TextDocumentSaveReason, options?: DocumentRequestOptions): Promise<TextEdit[] | null>;
     request<T = unknown>(method: string, params: object, options?: DocumentRequestOptions): Promise<T>;
     close(): Promise<void>;
     disconnect(): void;

package/dist/document.js

@@ -195,6 +195,58 @@ export class LspDocument {
     diagnostics(previousResultId, identifier, options) {
         return this.feature('textDocument/diagnostic', { previousResultId, identifier }, options);
     }
+    documentLinks(options) {
+        return this.feature('textDocument/documentLink', {}, options);
+    }
+    resolveDocumentLink(link, options) {
+        return this.resolve('documentLink/resolve', link, options);
+    }
+    documentColors(options) {
+        return this.feature('textDocument/documentColor', {}, options);
+    }
+    colorPresentations(color, range, options) {
+        return this.feature('textDocument/colorPresentation', { color, range }, options);
+    }
+    linkedEditingRanges(position, options) {
+        return this.feature('textDocument/linkedEditingRange', { position }, options);
+    }
+    monikers(position, options) {
+        return this.feature('textDocument/moniker', { position }, options);
+    }
+    prepareTypeHierarchy(position, options) {
+        return this.feature('textDocument/prepareTypeHierarchy', { position }, options);
+    }
+    /* Like the calls of a call hierarchy, expansions of the tree run beside each other unless `cancelPrevious` says otherwise. */
+    supertypes(item, options) {
+        return this.perform('typeHierarchy/supertypes', { item }, { cancelPrevious: false, ...options });
+    }
+    subtypes(item, options) {
+        return this.perform('typeHierarchy/subtypes', { item }, { cancelPrevious: false, ...options });
+    }
+    inlineValues(range, context, options) {
+        return this.feature('textDocument/inlineValue', { range, context }, options);
+    }
+    inlineCompletions(position, context, options) {
+        return this.feature('textDocument/inlineCompletion', { position, context }, options);
+    }
+    rangesFormatting(ranges, formatting, options) {
+        return this.feature('textDocument/rangesFormatting', { ranges: [...ranges], options: formatting }, options);
+    }
+    /* Tells the server a save is coming, when it asked to hear it. */
+    async willSave(reason = 1) {
+        this.assertOpen();
+        if (this.session.syncOptions.willSave) {
+            await this.session.notify('textDocument/willSave', { textDocument: { uri: this.uri }, reason });
+        }
+    }
+    /* The edits the server wants in the text before it is saved, or null when it did not ask to be told. Apply them, then save. */
+    async willSaveWaitUntil(reason = 1, options) {
+        this.assertOpen();
+        if (!this.session.syncOptions.willSaveWaitUntil) {
+            return null;
+        }
+        return this.perform('textDocument/willSaveWaitUntil', { textDocument: { uri: this.uri }, reason }, options);
+    }
     /* Any feature by its LSP method, for a caller that gets the method from elsewhere. `params` leave out `textDocument`; a resolve method takes the item. */
     request(method, params, options) {
         return method.endsWith('/resolve') ? this.resolve(method, params, options) : this.feature(method, params, options);
@@ -257,7 +309,14 @@ export class LspDocument {
             this.sendFullText?.();
             await this.synced;
             this.assertCurrent(version);
-            const result = await this.session.request(method, params, { signal: controller.signal, timeoutMs: options.timeoutMs });
+            const { onPartialResult, onWorkDoneProgress } = options;
+            const result = await this.session.request(method, params, {
+                signal: controller.signal,
+                timeoutMs: options.timeoutMs,
+                // A part for a text that moved on is as stale as the answer would be.
+                onPartialResult: onPartialResult && ((value) => this.version === version && !this.closed && onPartialResult(value)),
+                onWorkDoneProgress
+            });
             this.assertCurrent(version);
             this.remember(result, version);
             return result;

package/dist/index.d.ts

@@ -7,7 +7,8 @@ export { type CreatedFile, type DeletedFile, type RenamedFile } from './file-ope
 export { watchesFile, type FileChangeType } from './watched-files.ts';
 export { LspSession, type LspSessionOptions, type SessionState } from './session.ts';
 export { TextMirror } from './text-mirror.ts';
-export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService } from './service.ts';
+export type { DiagnosticsReport, LanguageDocument, LanguageRequestOptions, LanguageService, ServerMessage } from './service.ts';
+export { unservedLanguageService } from './unserved.ts';
 export { connectWebSocket, createStreamTransport, type ByteStream, type WebSocketTransportOptions } from './transport.ts';
 export { fileUriToPath, pathToFileUri } from './uris.ts';
 export { bridgeVueTypeScript, vueServerOrder, type VueServer } from './vue.ts';

package/dist/index.js

@@ -7,6 +7,7 @@ export {} from './file-operations.js';
 export { watchesFile } from './watched-files.js';
 export { LspSession } from './session.js';
 export { TextMirror } from './text-mirror.js';
+export { unservedLanguageService } from './unserved.js';
 export { connectWebSocket, createStreamTransport } from './transport.js';
 export { fileUriToPath, pathToFileUri } from './uris.js';
 export { bridgeVueTypeScript, vueServerOrder } from './vue.js';

package/dist/protocol.d.ts

@@ -33,6 +33,8 @@ export interface LspTransport {
 export interface RequestOptions {
     signal?: AbortSignal;
     timeoutMs?: number;
+    onPartialResult?: (value: unknown) => void;
+    onWorkDoneProgress?: (progress: WorkDoneProgress) => void;
 }
 export interface DocumentRequestOptions extends RequestOptions {
     cancelPrevious?: boolean;
@@ -430,6 +432,9 @@ export interface ProviderOptions {
     full?: boolean | {
         delta?: boolean;
     };
+    rangesSupport?: boolean;
+    workspaceDiagnostics?: boolean;
+    schemes?: string[];
     [option: string]: unknown;
 }
 export interface TextDocumentSyncOptions {
@@ -469,7 +474,30 @@ export interface ServerCapabilities {
     inlayHintProvider?: boolean | ProviderOptions;
     callHierarchyProvider?: boolean | ProviderOptions;
     documentOnTypeFormattingProvider?: ProviderOptions;
-    diagnosticProvider?: ProviderOptions;
+    diagnosticProvider?: ProviderOptions & {
+        interFileDependencies?: boolean;
+        workspaceDiagnostics?: boolean;
+    };
+    documentLinkProvider?: ProviderOptions;
+    colorProvider?: boolean | ProviderOptions;
+    linkedEditingRangeProvider?: boolean | ProviderOptions;
+    monikerProvider?: boolean | ProviderOptions;
+    typeHierarchyProvider?: boolean | ProviderOptions;
+    inlineValueProvider?: boolean | ProviderOptions;
+    inlineCompletionProvider?: boolean | ProviderOptions;
+    notebookDocumentSync?: NotebookDocumentSyncOptions;
+    workspace?: {
+        workspaceFolders?: {
+            supported?: boolean;
+            changeNotifications?: boolean | string;
+        };
+        fileOperations?: Partial<Record<FileOperation, {
+            filters: FileOperationFilter[];
+        }>>;
+        textDocumentContent?: {
+            schemes: string[];
+        };
+    };
     [capability: string]: unknown;
 }
 export interface InitializeResult {
@@ -497,3 +525,208 @@ export interface ProgressParams {
     token: string | number;
     value: unknown;
 }
+export type ProgressToken = string | number;
+export type WorkDoneProgress = {
+    kind: 'begin';
+    title: string;
+    cancellable?: boolean;
+    message?: string;
+    percentage?: number;
+} | {
+    kind: 'report';
+    cancellable?: boolean;
+    message?: string;
+    percentage?: number;
+} | {
+    kind: 'end';
+    message?: string;
+};
+export type TraceValue = 'off' | 'messages' | 'verbose';
+export interface LogTraceParams {
+    message: string;
+    verbose?: string;
+}
+export type MessageType = 1 | 2 | 3 | 4 | 5;
+export interface ShowMessageParams {
+    type: MessageType;
+    message: string;
+}
+export interface MessageActionItem {
+    title: string;
+    [property: string]: unknown;
+}
+export interface ShowMessageRequestParams extends ShowMessageParams {
+    actions?: MessageActionItem[];
+}
+export interface LogMessageParams {
+    type: MessageType;
+    message: string;
+}
+export interface ShowDocumentParams {
+    uri: string;
+    external?: boolean;
+    takeFocus?: boolean;
+    selection?: Range;
+}
+export interface ShowDocumentResult {
+    success: boolean;
+}
+export interface WorkspaceFoldersChangeEvent {
+    added: WorkspaceFolder[];
+    removed: WorkspaceFolder[];
+}
+export type TextDocumentSaveReason = 1 | 2 | 3;
+export interface DocumentLink {
+    range: Range;
+    target?: string;
+    tooltip?: string;
+    data?: unknown;
+}
+export interface Color {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+}
+export interface ColorInformation {
+    range: Range;
+    color: Color;
+}
+export interface ColorPresentation {
+    label: string;
+    textEdit?: TextEdit;
+    additionalTextEdits?: TextEdit[];
+}
+export interface LinkedEditingRanges {
+    ranges: Range[];
+    wordPattern?: string;
+}
+export type UniquenessLevel = 'document' | 'project' | 'group' | 'scheme' | 'global';
+export type MonikerKind = 'import' | 'export' | 'local';
+export interface Moniker {
+    scheme: string;
+    identifier: string;
+    unique: UniquenessLevel;
+    kind?: MonikerKind;
+}
+export interface TypeHierarchyItem {
+    name: string;
+    kind: SymbolKind;
+    tags?: 1[];
+    detail?: string;
+    uri: string;
+    range: Range;
+    selectionRange: Range;
+    data?: unknown;
+}
+export interface InlineValueContext {
+    frameId: number;
+    stoppedLocation: Range;
+}
+export type InlineValue = {
+    range: Range;
+    text: string;
+} | {
+    range: Range;
+    variableName?: string;
+    caseSensitiveLookup: boolean;
+} | {
+    range: Range;
+    expression?: string;
+};
+export interface InlineCompletionContext {
+    triggerKind: 1 | 2;
+    selectedCompletionInfo?: {
+        range: Range;
+        text: string;
+    };
+}
+export interface InlineCompletionItem {
+    insertText: string | {
+        kind: 'snippet';
+        value: string;
+    };
+    filterText?: string;
+    range?: Range;
+    command?: Command;
+}
+export type InlineCompletionResult = InlineCompletionItem[] | {
+    items: InlineCompletionItem[];
+} | null;
+export type WorkspaceDocumentDiagnosticReport = {
+    kind: 'full';
+    uri: string;
+    version: number | null;
+    resultId?: string;
+    items: Diagnostic[];
+} | {
+    kind: 'unchanged';
+    uri: string;
+    version: number | null;
+    resultId: string;
+};
+export interface WorkspaceDiagnosticReport {
+    items: WorkspaceDocumentDiagnosticReport[];
+}
+export interface PreviousResultId {
+    uri: string;
+    value: string;
+}
+export interface TextDocumentContentResult {
+    text: string;
+}
+export interface NotebookCell {
+    kind: 1 | 2;
+    document: string;
+    metadata?: Record<string, unknown>;
+    executionSummary?: {
+        executionOrder: number;
+        success?: boolean;
+    };
+}
+export interface NotebookDocument {
+    uri: string;
+    notebookType: string;
+    version: number;
+    metadata?: Record<string, unknown>;
+    cells: NotebookCell[];
+}
+export interface NotebookCellArrayChange {
+    start: number;
+    deleteCount: number;
+    cells?: NotebookCell[];
+}
+export interface NotebookDocumentChangeEvent {
+    metadata?: Record<string, unknown>;
+    cells?: {
+        structure?: {
+            array: NotebookCellArrayChange;
+            didOpen?: DocumentItem[];
+            didClose?: {
+                uri: string;
+            }[];
+        };
+        data?: NotebookCell[];
+        textContent?: {
+            document: {
+                uri: string;
+                version: number;
+            };
+            changes: ContentChange[];
+        }[];
+    };
+}
+export interface NotebookDocumentFilter {
+    notebookType?: string;
+    scheme?: string;
+    pattern?: string;
+}
+export interface NotebookDocumentSyncOptions {
+    notebookSelector: {
+        notebook?: string | NotebookDocumentFilter;
+        cells?: {
+            language: string;
+        }[];
+    }[];
+    save?: boolean;
+}

package/dist/service.d.ts

@@ -1,4 +1,4 @@
-import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, CodeAction, CodeActionContext, CodeLens, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, Diagnostic, Disposable, DocumentHighlight, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, Location, NavigationResult, Position, PrepareRenameResult, ProviderOptions, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, SignatureHelp, SignatureHelpContext, TextEdit, WorkspaceEdit, WorkspaceSymbolResult } from './protocol.ts';
+import type { CallHierarchyIncomingCall, CallHierarchyItem, CallHierarchyOutgoingCall, CodeAction, CodeActionContext, CodeLens, Color, ColorInformation, ColorPresentation, Command, CompletionContext, CompletionItem, CompletionResult, ContentChange, Diagnostic, Disposable, DocumentHighlight, DocumentLink, DocumentSymbolResult, FoldingRange, FormattingOptions, Hover, InlayHint, InlineCompletionContext, InlineCompletionResult, InlineValue, InlineValueContext, LinkedEditingRanges, Location, MessageType, Moniker, NavigationResult, Position, PrepareRenameResult, PreviousResultId, ProviderOptions, Range, SelectionRange, SemanticTokens, SemanticTokensDelta, ShowDocumentParams, ShowDocumentResult, SignatureHelp, SignatureHelpContext, TextDocumentSaveReason, TextEdit, TypeHierarchyItem, WorkspaceDiagnosticReport, WorkspaceEdit, WorkspaceSymbolResult } from './protocol.ts';
 import type { CreatedFile, DeletedFile } from './file-operations.ts';
 export interface LanguageDocument {
     uri: string;
@@ -60,4 +60,28 @@ export interface LanguageService {
     didDeleteFiles?(files: readonly DeletedFile[]): Promise<void>;
     codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
     resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
+    documentLinks?(uri: string, options?: LanguageRequestOptions): Promise<DocumentLink[] | null>;
+    resolveDocumentLink?(uri: string, link: DocumentLink, options?: LanguageRequestOptions): Promise<DocumentLink>;
+    documentColors?(uri: string, options?: LanguageRequestOptions): Promise<ColorInformation[] | null>;
+    colorPresentations?(uri: string, color: Color, range: Range, options?: LanguageRequestOptions): Promise<ColorPresentation[] | null>;
+    linkedEditingRanges?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<LinkedEditingRanges | null>;
+    monikers?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<Moniker[] | null>;
+    prepareTypeHierarchy?(uri: string, position: Position, options?: LanguageRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    supertypes?(uri: string, item: TypeHierarchyItem, options?: LanguageRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    subtypes?(uri: string, item: TypeHierarchyItem, options?: LanguageRequestOptions): Promise<TypeHierarchyItem[] | null>;
+    inlineValues?(uri: string, range: Range, context: InlineValueContext, options?: LanguageRequestOptions): Promise<InlineValue[] | null>;
+    inlineCompletions?(uri: string, position: Position, context: InlineCompletionContext, options?: LanguageRequestOptions): Promise<InlineCompletionResult>;
+    rangesFormatting?(uri: string, ranges: readonly Range[], formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    willSave?(uri: string, reason?: TextDocumentSaveReason): Promise<void>;
+    willSaveWaitUntil?(uri: string, reason?: TextDocumentSaveReason, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    workspaceDiagnostics?(uri: string, previousResultIds?: readonly PreviousResultId[], options?: LanguageRequestOptions): Promise<WorkspaceDiagnosticReport>;
+    textDocumentContent?(uri: string, options?: LanguageRequestOptions): Promise<string | null>;
+    onServerMessage?(listener: (message: ServerMessage) => void): Disposable;
+    onShowDocument?(handler: (params: ShowDocumentParams) => Promise<ShowDocumentResult>): Disposable;
+}
+export interface ServerMessage {
+    readonly kind: 'show' | 'log';
+    readonly type: MessageType;
+    readonly message: string;
+    readonly source?: string;
 }

package/dist/session.d.ts

@@ -2,7 +2,7 @@ import { JsonRpcConnection, type RequestHandler } from './connection.ts';
 import { LspDocument } from './document.ts';
 import { type CreatedFile, type DeletedFile, type RenamedFile } from './file-operations.ts';
 import type { ResourceOperationKind } from './workspace-operations.ts';
-import type { ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, Command, ConfigurationItem, Disposable, DocumentItem, FileEvent, FileOperation, FileOperationFilter, FileSystemWatcher, InitializeResult, LspTransport, ProgressParams, ProviderOptions, PublishDiagnosticsParams, RequestOptions, ServerCapabilities, TextDocumentSyncOptions, WorkspaceEdit, WorkspaceFolder, WorkspaceSymbol, WorkspaceSymbolResult } from './protocol.ts';
+import type { ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, Command, ConfigurationItem, Disposable, DocumentItem, FileEvent, FileOperation, FileOperationFilter, FileSystemWatcher, InitializeResult, LogMessageParams, LogTraceParams, LspTransport, MessageActionItem, NotebookDocument, NotebookDocumentChangeEvent, PreviousResultId, ProgressParams, ProgressToken, ProviderOptions, PublishDiagnosticsParams, RequestOptions, ServerCapabilities, ShowDocumentParams, ShowDocumentResult, ShowMessageParams, ShowMessageRequestParams, TextDocumentContentResult, TextDocumentSyncOptions, TraceValue, WorkspaceDiagnosticReport, WorkspaceEdit, WorkspaceFolder, WorkspaceFoldersChangeEvent, WorkspaceSymbol, WorkspaceSymbolResult } from './protocol.ts';
 export type SessionState = 'new' | 'initializing' | 'ready' | 'closing' | 'closed';
 export interface LspSessionOptions {
     rootUri?: string | null;
@@ -21,17 +21,14 @@ export interface LspSessionOptions {
     resourceOperations?: readonly ResourceOperationKind[];
     onConfiguration?: (item: ConfigurationItem) => unknown | Promise<unknown>;
     onApplyEdit?: (params: ApplyWorkspaceEditParams) => ApplyWorkspaceEditResult | Promise<ApplyWorkspaceEditResult>;
-    onShowMessage?: (params: {
-        type: number;
-        message: string;
-        actions?: {
-            title: string;
-        }[];
-    }) => {
-        title: string;
-    } | null | Promise<{
-        title: string;
-    } | null>;
+    onShowMessage?: (params: ShowMessageRequestParams) => MessageActionItem | null | Promise<MessageActionItem | null>;
+    onMessage?: (params: ShowMessageParams) => void;
+    onLog?: (params: LogMessageParams) => void;
+    onTrace?: (params: LogTraceParams) => void;
+    onTelemetry?: (data: unknown) => void;
+    onShowDocument?: (params: ShowDocumentParams) => ShowDocumentResult | Promise<ShowDocumentResult>;
+    trace?: TraceValue;
+    locale?: string;
 }
 export declare class LspSession {
     readonly connection: JsonRpcConnection;
@@ -46,6 +43,7 @@ export declare class LspSession {
     private readonly diagnosticListeners;
     private readonly capabilityListeners;
     private configuration;
+    private folders;
     constructor(transport: LspTransport, options?: LspSessionOptions);
     get state(): SessionState;
     get capabilities(): Readonly<ServerCapabilities>;
@@ -61,6 +59,16 @@ export declare class LspSession {
     executeCommand<T = unknown>(command: Command | string, args?: unknown[], options?: RequestOptions): Promise<T>;
     workspaceSymbols(query: string, options?: RequestOptions): Promise<WorkspaceSymbolResult>;
     resolveWorkspaceSymbol(symbol: WorkspaceSymbol, options?: RequestOptions): Promise<WorkspaceSymbol>;
+    workspaceDiagnostics(previousResultIds?: readonly PreviousResultId[], identifier?: string, options?: RequestOptions): Promise<WorkspaceDiagnosticReport>;
+    textDocumentContent(uri: string, options?: RequestOptions): Promise<TextDocumentContentResult>;
+    setTrace(value: TraceValue): Promise<void>;
+    cancelWorkDoneProgress(token: ProgressToken): Promise<void>;
+    changeWorkspaceFolders(event: WorkspaceFoldersChangeEvent): Promise<void>;
+    syncsNotebook(notebook: Pick<NotebookDocument, 'uri' | 'notebookType'>): boolean;
+    openNotebook(notebook: NotebookDocument, cellTextDocuments: readonly DocumentItem[]): Promise<void>;
+    changeNotebook(notebook: Pick<NotebookDocument, 'uri' | 'notebookType' | 'version'>, change: NotebookDocumentChangeEvent): Promise<void>;
+    saveNotebook(notebook: Pick<NotebookDocument, 'uri' | 'notebookType'>): Promise<void>;
+    closeNotebook(notebook: Pick<NotebookDocument, 'uri' | 'notebookType'>, cellUris: readonly string[]): Promise<void>;
     setConfiguration(settings: Record<string, unknown>): Promise<void>;
     onRequest(method: string, handler: RequestHandler): Disposable;
     onNotification(method: string, listener: (params: unknown) => void | Promise<void>): Disposable;