import type { HandlerResult, ResultProgressReporter, TextDocumentChangeEvent, WorkDoneProgressReporter } from 'vscode-languageserver';
import type LSP from 'vscode-languageserver-protocol';
import type { TextDocument } from 'vscode-languageserver-textdocument';
import { Constructable, type FactoryRegistration, type InjectionToken, type Scope } from '../di/index.js';
import { ClassDecoratorFunction, CompatibleMethodDecorator, MethodDecoratorFunction } from '../di/types.js';
import type { PublicOnlyIfObject } from '../shared/types.js';
import { CommandId } from './types.js';
import { MaybeAsync } from './utils/index.js';
declare const lspServiceMetadataKey = "__languageServerServiceMetadata__";
declare const lspServiceConstructorMetadataKey = "__isLanguageServerService__";
export interface CommandHandlerMetadata {
    commandId: CommandId;
    methodName: string | symbol;
    handler: CommandMethod;
    options: CommandOptions;
}
export type InitializeHandler = (params?: LSP.InitializeParams) => Partial<LSP.InitializeResult> | void;
export interface LspServiceInstanceMetadata {
    commandHandlers: CommandHandlerMetadata[];
    initializerHandlers: InitializeHandler[];
    textDocumentHandlers: TextDocumentHandlerMetadata[];
    notificationHandlers: NotificationHandlerMetadata[];
    shutdownHandlers: ShutdownHandler[];
    connectionHandlers: ConnectionHandlerMetadata[];
    disposables: LSP.Disposable[];
}
export type TextDocumentEventName = 'onDidOpen' | 'onDidChangeContent' | 'onDidSave' | 'onDidClose';
export type TextDocumentEventHandler = (event: TextDocumentChangeEvent<TextDocument>) => Promise<void> | void;
export interface TextDocumentHandlerMetadata {
    event: TextDocumentEventName;
    handler: TextDocumentEventHandler;
}
export type NotificationRegistrationType = LSP.ProtocolNotificationType0<unknown> | LSP.ProtocolNotificationType<unknown, unknown> | LSP.NotificationType0 | LSP.NotificationType<unknown> | string | undefined;
export type NotificationMethod = (...args: unknown[]) => Promise<void> | void;
export interface NotificationHandlerMetadata {
    type: NotificationRegistrationType;
    handler: NotificationMethod;
}
interface ConnectionHandlerMap {
    completion: CompletionRequestHandler;
    codeAction: CodeActionRequestHandler;
    documentFormatting: DocumentFormattingRequestHandler;
}
type ConnectionHandlerKind = keyof ConnectionHandlerMap;
export type ConnectionHandlerMetadata = {
    [K in ConnectionHandlerKind]: {
        kind: K;
        handler: ConnectionHandlerMap[K];
    };
}[ConnectionHandlerKind];
type CompletionRequestHandler = (params: LSP.CompletionParams, token: LSP.CancellationToken, workDone: WorkDoneProgressReporter, resultProgress?: ResultProgressReporter<LSP.CompletionItem[]>) => Promise<LSP.CompletionItem[] | LSP.CompletionList | undefined | null>;
type CodeActionRequestHandler = (params: LSP.CodeActionParams, token: LSP.CancellationToken, workDone: WorkDoneProgressReporter, resultProgress?: ResultProgressReporter<(LSP.Command | LSP.CodeAction)[]>) => Promise<(LSP.Command | LSP.CodeAction)[] | undefined | null>;
type DocumentFormattingRequestHandler = (params: LSP.DocumentFormattingParams, token: LSP.CancellationToken, workDone: WorkDoneProgressReporter, resultProgress?: ResultProgressReporter<never>) => Promise<LSP.TextEdit[] | undefined | null>;
type AsyncNotificationHandler0 = MaybeAsync<() => void>;
type AsyncNotificationHandler<P> = MaybeAsync<(params: P) => void>;
type AsyncGenericNotificationHandler = MaybeAsync<LSP.GenericNotificationHandler>;
type AsyncStarNotificationHandler = MaybeAsync<LSP.StarNotificationHandler>;
export type ShutdownHandler = () => void | Promise<void>;
export type DecoratedLspServiceConstructor = Constructable<object> & {
    [lspServiceConstructorMetadataKey]: true;
};
/**
 * Returns if the given instance is of a class decorated as a language server service.
 */
export declare function isLanguageServerServiceInstance(instance: unknown): instance is {
    [lspServiceMetadataKey]: LspServiceInstanceMetadata;
};
/**
 * Returns if the given class is decorated as a language server service.
 */
export declare function isLanguageServerServiceConstructor(target: Constructable<unknown>): target is Constructable<unknown> & {
    __isLanguageServerService__: true;
};
/**
 * Gets the language server service metadata for the given instance.
 */
export declare function getLanguageServerServiceMetadata(instance: unknown): LspServiceInstanceMetadata | undefined;
/**
 * Decorates a class as being a service that participates in the language server
 * lifecycle.
 */
export declare function lspService(): ClassDecoratorFunction;
export interface CommandOptions {
    minArgs?: number;
}
export type CommandMethod = <R>(...args: any[]) => HandlerResult<any, R>;
/**
 * Decorator to mark a method as a handler for a specific command ID.
 * @param commandId The command ID to handle.
 */
export declare function command(commandId: CommandId, options?: CommandOptions): MethodDecoratorFunction<CommandMethod>;
/**
 * Decorator to mark a method as an initialization handler.
 */
export declare function initialize(): CompatibleMethodDecorator<InitializeHandler>;
/**
 *
 */
export declare function textDocumentEvent(event: TextDocumentEventName): CompatibleMethodDecorator<TextDocumentEventHandler>;
export declare function notification<R0>(type: LSP.ProtocolNotificationType0<R0>): CompatibleMethodDecorator<AsyncNotificationHandler0>;
export declare function notification<P, R0>(type: LSP.ProtocolNotificationType<P, R0>): CompatibleMethodDecorator<AsyncNotificationHandler<P>>;
export declare function notification(type: LSP.NotificationType0): CompatibleMethodDecorator<AsyncNotificationHandler0>;
export declare function notification<P>(type: LSP.NotificationType<P>): CompatibleMethodDecorator<AsyncNotificationHandler<P>>;
export declare function notification(type: string): CompatibleMethodDecorator<AsyncGenericNotificationHandler>;
export declare function notification(): CompatibleMethodDecorator<AsyncStarNotificationHandler>;
/**
 * Marks a method as a handler for a specific completion request.
 */
export declare function completionRequest(): CompatibleMethodDecorator<CompletionRequestHandler>;
/**
 * Marks a method as a handler for a specific code action request.
 */
export declare function codeActionRequest(): CompatibleMethodDecorator<CodeActionRequestHandler>;
/**
 * Marks a method as a handler for a specific document formatting request.
 */
export declare function documentFormattingRequest(): CompatibleMethodDecorator<DocumentFormattingRequestHandler>;
/**
 * Marks a method as a shutdown handler.
 */
export declare function shutdown(): CompatibleMethodDecorator<ShutdownHandler>;
/**
 * Create a stub with `cls.prototype` in its chain, so `instance.constructor`
 * points to `cls`. This satisfies `@lspService()` init hooks that check the
 * constructor for metadata flags. Plain objects from {@link provideTestValue}
 * fail that check.
 *
 * Only copies own enumerable properties from `overrides` via `Object.assign`.
 * Prototype methods on a fake class will not be copied. Use
 * {@link provideTestValue} for non-`@lspService()` stubs.
 */
export declare function createLspServiceStub<T extends object>(cls: abstract new (...args: any[]) => T, overrides: Partial<T>): T;
/**
 * Factory registration wrapper around {@link createLspServiceStub}. Use only
 * for `@lspService()` tokens. Use {@link provideTestValue} otherwise.
 */
export declare function provideLspServiceStub<T extends object>(token: InjectionToken<T> & (abstract new (...args: any[]) => T), factory: () => Partial<PublicOnlyIfObject<T>>, scope?: Scope): FactoryRegistration<T>;
export {};