import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { ToolProtocol } from '../tools/BaseTool.js';
import { PromptProtocol } from '../prompts/BasePrompt.js';
import { ResourceProtocol } from '../resources/BaseResource.js';
import { BaseTransport } from '../transports/base.js';
import { SSETransportConfig } from '../transports/sse/types.js';
import { HttpStreamTransportConfig } from '../transports/http/types.js';
import { AuthConfig } from '../auth/types.js';
import type { LambdaEvent, LambdaResult, LambdaContext, LambdaHandlerConfig } from '../serverless/types.js';
export type MCPLogLevel = 'debug' | 'info' | 'notice' | 'warning' | 'error' | 'critical' | 'alert' | 'emergency';
export declare const LOG_LEVEL_SEVERITY: Record<MCPLogLevel, number>;
export type TransportType = 'stdio' | 'sse' | 'http-stream';
export interface TransportConfig {
    type: TransportType;
    options?: SSETransportConfig | HttpStreamTransportConfig;
    auth?: AuthConfig;
}
export interface TasksConfig {
    enabled: boolean;
    defaultTtl?: number;
    defaultPollInterval?: number;
    maxTasks?: number;
}
export interface MCPServerConfig {
    name?: string;
    version?: string;
    basePath?: string;
    transport?: TransportConfig;
    /** Array of transport configs for running multiple transports concurrently.
     *  Cannot be used together with `transport`. */
    transports?: TransportConfig[];
    /** Top-level auth config. Used by handleRequest() and createLambdaHandler().
     *  Also used by start() if transport.auth is not set. */
    auth?: AuthConfig;
    logging?: boolean;
    tasks?: TasksConfig;
    /** When true, app HTML content is re-read from disk on every resources/read.
     *  Defaults to true when MCP_DEV_MODE env var is set. */
    devMode?: boolean;
}
export interface TransportBinding {
    config: TransportConfig;
    transport: BaseTransport;
    sdkServer: Server;
    label: string;
}
export interface HandleRequestOptions {
    /** Source IP address of the client (e.g., from Lambda event). */
    sourceIp?: string;
}
export type ServerCapabilities = {
    tools?: {
        listChanged?: true;
    };
    prompts?: {
        listChanged?: true;
    };
    resources?: {
        listChanged?: true;
        subscribe?: true;
    };
    completions?: {};
    logging?: {};
    tasks?: {
        list?: {};
        cancel?: {};
        requests?: {
            tools?: {
                call?: {};
            };
        };
    };
};
export declare class MCPServer {
    private toolsMap;
    private promptsMap;
    private resourcesMap;
    private toolLoader;
    private promptLoader;
    private resourceLoader;
    private appLoader;
    private appsMap;
    private _hasApps;
    private appContentCache;
    private serverName;
    private serverVersion;
    private basePath;
    private transportConfigs;
    private capabilities;
    private isRunning;
    private bindings;
    private shutdownPromise?;
    private shutdownResolve?;
    private _logLevel;
    private _loggingEnabled;
    private _inFlightAbortControllers;
    private _roots;
    private _tasksConfig?;
    private _taskManager?;
    private _devMode;
    private _initialized;
    private _initPromise?;
    private _authConfig?;
    /** Returns the first binding's SDK Server, or undefined if no bindings exist. */
    private get server();
    constructor(config?: MCPServerConfig);
    private validateTransportConfigs;
    private resolveBasePath;
    /**
     * Creates a new SDK Server instance configured with all registered handlers.
     * Used by handleRequest() to create isolated per-request servers, and by
     * SSE transport for per-session servers.
     */
    private createSDKServerForSession;
    private createTransportFromConfig;
    private makeBindingLabel;
    private readPackageJson;
    private getDefaultName;
    private getDefaultVersion;
    private setupHandlers;
    private detectCapabilities;
    private getSdkVersion;
    private createAppTool;
    private generateAppToolInputSchema;
    private createAppResource;
    private createToolAppResource;
    /**
     * Idempotent initialization: loads tools, prompts, resources, apps from
     * disk, validates them, detects capabilities, and caches app content.
     * Safe to call multiple times — only runs once.
     */
    private ensureInitialized;
    private _doInitialize;
    /**
     * Register a tool class programmatically. Must be called before
     * start() or the first handleRequest() call.
     */
    addTool(ToolClass: new () => ToolProtocol): void;
    /**
     * Register a prompt class programmatically. Must be called before
     * start() or the first handleRequest() call.
     */
    addPrompt(PromptClass: new () => PromptProtocol): void;
    /**
     * Register a resource class programmatically. Must be called before
     * start() or the first handleRequest() call.
     */
    addResource(ResourceClass: new () => ResourceProtocol): void;
    /**
     * Handle a single Web Standard Request and return a Response.
     * Designed for serverless environments (Lambda, Cloudflare Workers, etc.)
     * where each request is independent and stateless.
     *
     * Creates a fresh transport and SDK server per request.
     * Tools, prompts, and resources are loaded once and cached.
     */
    handleRequest(request: Request, options?: HandleRequestOptions): Promise<Response>;
    /**
     * Create an AWS Lambda handler function. The returned function can be
     * exported directly as a Lambda handler.
     *
     * @example
     * ```typescript
     * const server = new MCPServer({ name: 'my-mcp', version: '1.0.0' });
     * export const handler = server.createLambdaHandler();
     * ```
     */
    createLambdaHandler(config?: LambdaHandlerConfig): (event: LambdaEvent, context: LambdaContext) => Promise<LambdaResult>;
    private _createCorsPreflightResponse;
    private _addCorsHeaders;
    private _handleOAuthMetadataRequest;
    start(): Promise<void>;
    stop(): Promise<void>;
    get IsRunning(): boolean;
    /**
     * Query the client for its filesystem root boundaries.
     * Returns an empty array if the client doesn't support roots.
     */
    listRoots(): Promise<Array<{
        uri: string;
        name?: string;
    }>>;
    /**
     * Returns the cached roots list (updated automatically when the client
     * sends a roots/list_changed notification).
     */
    get roots(): ReadonlyArray<{
        uri: string;
        name?: string;
    }>;
    /**
     * Send a logging message to all connected clients via the MCP logging protocol.
     * Messages below the current log level threshold will be silently dropped.
     * In multi-transport mode, the message is broadcast to all bindings.
     */
    sendLog(level: MCPLogLevel, loggerName: string, data: unknown): Promise<void>;
}