import type { McpToolMetadata } from './mcp-tool-metadata';
import type { McpResourceMetadata } from './mcp-resource-metadata';
import type { McpPromptMetadata } from './mcp-prompt-metadata';
import type { McpAuthInfo } from './mcp-auth-info';
import type { McpToolContext } from './mcp-tool-context';
import type { McpToolInterceptor } from './mcp-tool-interceptor';
import type { McpCanActivate } from './mcp-can-activate';
import type { McpAuthStrategy } from './mcp-auth-strategy';
import type { McpGuardMetadata } from './mcp-guard-metadata';
import type { McpToolResult } from './mcp-tool-result';
import type { McpLogLevel } from './mcp-log-level';
import type { McpRegistrationChangeListener } from './mcp-registration-change-listener';
import type { McpResourceUpdateListener } from './mcp-resource-update-listener';
interface ToolEntry {
    metadata: McpToolMetadata;
    handler: (params: any, context?: McpToolContext) => Promise<any>;
    guards?: McpGuardMetadata[];
}
interface ResourceEntry {
    metadata: McpResourceMetadata;
    handler: (...args: any[]) => Promise<any>;
}
interface PromptEntry {
    metadata: McpPromptMetadata;
    handler: (...args: any[]) => Promise<any>;
}
export declare class McpToolRegistry {
    private readonly logger;
    private readonly tools;
    private readonly resources;
    private readonly prompts;
    private readonly interceptors;
    private readonly changeListeners;
    private readonly resourceSubscriptions;
    private readonly resourceUpdateListeners;
    private toolEnabledDelegate?;
    private guardResolver?;
    private providerResolver?;
    private authStrategy?;
    onRegistrationChange(listener: McpRegistrationChangeListener): () => void;
    private notifyChange;
    subscribeResource(uri: string, sessionId: string): void;
    unsubscribeResource(uri: string, sessionId: string): void;
    getResourceSubscribers(uri: string): ReadonlySet<string>;
    notifyResourceUpdated(uri: string): void;
    onResourceUpdate(listener: McpResourceUpdateListener): () => void;
    removeSessionSubscriptions(sessionId: string): void;
    registerInterceptor(interceptor: McpToolInterceptor): void;
    setGuardResolver(resolver: (guardClass: new (...args: any[]) => McpCanActivate) => McpCanActivate): void;
    setAuthStrategy(strategy: McpAuthStrategy): void;
    setProviderResolver(resolver: (cls: new (...args: any[]) => any) => any): void;
    resolveProvider<T>(cls: new (...args: any[]) => T): T;
    setToolEnabledDelegate(delegate: (name: string, enabled: boolean) => void): void;
    setToolEnabled(name: string, enabled: boolean): void;
    registerTool(metadata: McpToolMetadata, handler: (params: any) => Promise<any>, guards?: McpGuardMetadata[]): void;
    registerResource(metadata: McpResourceMetadata, handler: (...args: any[]) => Promise<any>): void;
    registerPrompt(metadata: McpPromptMetadata, handler: (...args: any[]) => Promise<any>): void;
    getTools(): ReadonlyArray<ToolEntry>;
    getResources(): ReadonlyArray<ResourceEntry>;
    getPrompts(): ReadonlyArray<PromptEntry>;
    getTool(name: string): ToolEntry | undefined;
    hasTool(name: string): boolean;
    getToolGuards(name: string): ReadonlyArray<McpGuardMetadata>;
    executeToolRaw(name: string, params: Record<string, unknown>, authInfo?: McpAuthInfo, extra?: {
        sessionId?: string;
        signal?: AbortSignal;
        sendProgress?: (progress: number, total?: number, message?: string) => Promise<void>;
        sendLog?: (level: McpLogLevel, data: unknown, logger?: string) => Promise<void>;
        createMessage?: (params: Record<string, unknown>) => Promise<unknown>;
        elicitInput?: (params: Record<string, unknown>) => Promise<unknown>;
        listRoots?: () => Promise<unknown>;
    }): Promise<unknown>;
    executeToolWrapped(name: string, params: Record<string, unknown>, authInfo?: McpAuthInfo, extra?: {
        sessionId?: string;
        signal?: AbortSignal;
        sendProgress?: (progress: number, total?: number, message?: string) => Promise<void>;
        sendLog?: (level: McpLogLevel, data: unknown, logger?: string) => Promise<void>;
        createMessage?: (params: Record<string, unknown>) => Promise<unknown>;
        elicitInput?: (params: Record<string, unknown>) => Promise<unknown>;
        listRoots?: () => Promise<unknown>;
    }): Promise<McpToolResult>;
    getToolJsonSchemas(): Array<{
        name: string;
        description: string;
        jsonSchema: Record<string, unknown>;
    }>;
}
export {};
//# sourceMappingURL=mcp-tool-registry.d.ts.map