import type { Application, Context } from 'egg';
import http, { ServerResponse } from 'node:http';
import { ControllerMetadata, MCPControllerMeta, MCPPromptMeta, MCPToolMeta, EggContext, EggObjectName, MCPResourceMeta, MCPProtocols } from '@eggjs/tegg';
import { EggPrototype } from '@eggjs/tegg-metadata';
import { EggContainerFactory, EggObject } from '@eggjs/tegg-runtime';
import { ControllerRegister } from '../../ControllerRegister';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
import compose from 'koa-compose';
import { MCPConfig } from './MCPConfig';
import { MCPServerHelper } from './MCPServerHelper';
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
export interface MCPControllerHook {
    preSSEInitHandle?: (ctx: Context, transport: SSEServerTransport, register: MCPControllerRegister) => Promise<void>;
    preHandleInitHandle?: (ctx: Context) => Promise<void>;
    preHandle?: (ctx: Context) => Promise<void>;
    onStreamSessionInitialized?: (ctx: Context, transport: StreamableHTTPServerTransport, server: McpServer, register: MCPControllerRegister) => Promise<void>;
    preProxy?: (ctx: Context, proxyReq: http.IncomingMessage, proxyResp: http.ServerResponse) => Promise<void>;
    schemaLoader?: (controllerMeta: MCPControllerMeta, meta: MCPPromptMeta | MCPToolMeta) => Promise<Parameters<McpServer['tool']>['2'] | Parameters<McpServer['prompt']>['2']>;
    checkAndRunProxy?: (ctx: Context, type: MCPProtocols, sessionId: string) => Promise<boolean>;
    middlewareStart?: (ctx: Context) => Promise<void>;
    middlewareEnd?: (ctx: Context) => Promise<void>;
    middlewareError?: (ctx: Context, e: Error) => Promise<void>;
}
interface ServerRegisterRecord<T> {
    getOrCreateEggObject: (proto: EggPrototype, name?: EggObjectName) => Promise<EggObject>;
    proto: EggPrototype;
    meta: T;
}
declare class InnerSSEServerTransport extends SSEServerTransport {
    send(message: JSONRPCMessage): Promise<void>;
}
export declare class MCPControllerRegister implements ControllerRegister {
    static instance?: MCPControllerRegister;
    readonly app: Application;
    readonly eggContainerFactory: typeof EggContainerFactory;
    private readonly router;
    private controllerProtos;
    private registeredControllerProtos;
    transports: Record<string, InnerSSEServerTransport>;
    sseConnections: Map<string, {
        res: ServerResponse;
        intervalId: NodeJS.Timeout;
    }>;
    mcpServerHelperMap: Record<string, () => MCPServerHelper>;
    private controllerMeta;
    mcpConfig: MCPConfig;
    streamTransports: Record<string, StreamableHTTPServerTransport>;
    sseTransportsRequestMap: Map<InnerSSEServerTransport, Record<string, {
        resolve: (value: PromiseLike<null> | null) => void;
        reject: (reason?: any) => void;
    }>>;
    static hooks: MCPControllerHook[];
    globalMiddlewares: compose.ComposedMiddleware<EggContext>;
    registerMap: Record<string, {
        tools: ServerRegisterRecord<MCPToolMeta>[];
        prompts: ServerRegisterRecord<MCPPromptMeta>[];
        resources: ServerRegisterRecord<MCPResourceMeta>[];
    }>;
    pingIntervals: Record<string, NodeJS.Timeout>;
    static create(proto: EggPrototype, controllerMeta: ControllerMetadata, app: Application): MCPControllerRegister;
    constructor(_proto: EggPrototype, controllerMeta: MCPControllerMeta, app: Application);
    static addHook(hook: MCPControllerHook): void;
    static deleteHook(hook: MCPControllerHook): void;
    static connectStatelessStreamTransport(_name?: string): Promise<void>;
    static clean(): void;
    mcpStatelessStreamServerInit(name?: string): void;
    mcpStreamServerInit(name?: string): void;
    mcpServerInit(name?: string): void;
    clearSseMcpServer(transport: SSEServerTransport): Promise<void>;
    waitResponseClosed(res: ServerResponse): Promise<void>;
    clearStreamMcpServer(sessionId: string): void;
    sseCtxStorageRun(ctx: Context, transport: SSEServerTransport, name?: string): void;
    mcpServerRegister(name?: string): void;
    getGlobalMiddleware(): void;
    mcpServerPing(server: Server, sessionId: string, name?: string): void;
    register(): Promise<void>;
}
export {};