import { type MCPPoolKeyIdentity, type MCPPoolKeyOptions, type MCPPoolSharingMode } from "./pool-key";
import { type MCPRequestOptions, type MCPServerConfig, type MCPServerConnection } from "./types";
export type { MCPPoolCapabilityProfile, MCPPoolKeyIdentity, MCPPoolKeyOptions, MCPPoolSharingMode } from "./pool-key";
export declare class MCPPoolLeaseReleaseError extends Error {
    readonly code: "MCP_POOL_LEASE_RELEASE_FAILED";
    readonly serverName: string;
    readonly poolKey: string;
    constructor(serverName: string, poolKey: string, cause: unknown);
}
export declare class MCPPoolLeaseObsoleteError extends Error {
    readonly code: "MCP_POOL_LEASE_OBSOLETE";
    readonly serverName: string;
    readonly poolKey: string;
    readonly generation: number;
    constructor(serverName: string, poolKey: string, generation: number);
}
export declare class MCPPoolAcquireAbortError extends Error {
    readonly code: "MCP_POOL_ACQUIRE_ABORTED";
    readonly serverName: string;
    readonly poolKey: string;
    cleanup?: Promise<unknown>;
    constructor(serverName: string, poolKey: string, cause: unknown, cleanup?: Promise<unknown>);
}
export declare class MCPPoolLeaseInvalidatedError extends Error {
    readonly code: "MCP_POOL_LEASE_INVALIDATED";
    readonly serverName: string;
    readonly poolKey: string;
    constructor(serverName: string, poolKey: string, cause?: unknown);
}
export type MCPPoolEvent = {
    type: "notification";
    method: string;
    params: unknown;
} | {
    type: "close";
    error?: Error;
} | {
    type: "error";
    error: Error;
} | {
    type: "replacement";
    success: boolean;
};
export interface MCPPoolHealthEvent {
    type: "notification" | "close" | "error" | "connecting" | "connected" | "closing" | "closed";
    at: number;
    message?: string;
}
export interface MCPPoolHealth {
    key: string;
    serverName: string;
    transport: "stdio" | "http" | "sse";
    state: "connecting" | "connected" | "closing" | "closed" | "error";
    refCount: number;
    events: MCPPoolHealthEvent[];
}
export interface MCPPoolAcquireOptions extends MCPPoolKeyOptions {
    signal?: AbortSignal;
    /** Advertise roots/list to the server (defaults to true). */
    advertiseRoots?: boolean;
    onNotification?: (method: string, params: unknown) => void;
    onRequest?: (method: string, params: unknown) => Promise<unknown>;
}
export interface MCPConnectionPoolOptions {
    sharedPoolIdleMs?: number;
    connect?: (name: string, config: MCPServerConfig, options: {
        signal?: AbortSignal;
        advertiseRoots?: boolean;
        onNotification?: (method: string, params: unknown) => void;
        onRequest?: (method: string, params: unknown) => Promise<unknown>;
    }) => Promise<MCPServerConnection>;
}
type HealthListener = (health: MCPPoolHealth[]) => void;
type LeaseListener = (event: MCPPoolEvent) => void;
type PoolEntry = {
    generation: number;
    key: string;
    name: string;
    config: MCPServerConfig;
    identity: MCPPoolKeyIdentity;
    connection: MCPServerConnection;
    refCount: number;
    leases: Set<MCPPoolLeaseImpl>;
    rootsByLease: Map<MCPPoolLeaseImpl, Array<{
        uri: string;
        name: string;
    }>>;
    pending?: PendingEntry;
    resourceSubscriptionCounts: Map<string, number>;
    resourceSubscriptionUpdate: Promise<void>;
    state: MCPPoolHealth["state"];
    events: MCPPoolHealthEvent[];
    idleTimer?: ReturnType<typeof setTimeout>;
    transportCloseStarted?: boolean;
    closePromise?: Promise<void>;
    rootsNotificationScheduled?: boolean;
};
type PendingAcquisition = {
    entry: PoolEntry;
    claim: () => void;
};
type PendingWaiter = {
    resolve: (acquisition: PendingAcquisition) => void;
    reject: (reason?: unknown) => void;
    settled: boolean;
    claimed: boolean;
    removeAbortListener?: () => void;
};
type PendingEntry = {
    claims: number;
    promise: Promise<PoolEntry>;
    resolve: (entry: PoolEntry) => void;
    reject: (reason?: unknown) => void;
    waiters: Set<PendingWaiter>;
    settled: boolean;
    cancelled: boolean;
    entry?: PoolEntry;
    cancellationReason?: unknown;
    openAbortController: AbortController;
    openSignal?: AbortSignal;
    settlement?: Promise<unknown>;
};
/** A lease over one physical MCP connection. */
export interface MCPPoolLease {
    readonly generation: number;
    readonly key: string;
    readonly serverName: string;
    readonly name: string;
    readonly sharingMode: MCPPoolSharingMode;
    readonly connection: MCPServerConnection;
    connectionForLease(): MCPServerConnection;
    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
    notify(method: string, params?: Record<string, unknown>): Promise<void>;
    setResourceSubscriptions(uris: string[]): Promise<void>;
    /** Update the connection-global root union contribution for this lease. */
    updateRoots(roots: Array<{
        uri: string;
        name: string;
    }>): void;
    onEvent(listener: LeaseListener): () => void;
    release(): Promise<void>;
}
declare class MCPPoolLeaseImpl implements MCPPoolLease {
    #private;
    readonly generation: number;
    readonly key: string;
    readonly serverName: string;
    readonly connection: MCPServerConnection;
    constructor(pool: MCPConnectionPool, entry: PoolEntry);
    get name(): string;
    get sharingMode(): MCPPoolSharingMode;
    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
    notify(method: string, params?: Record<string, unknown>): Promise<void>;
    connectionForLease(): MCPServerConnection;
    setResourceSubscriptions(uris: string[]): Promise<void>;
    updateRoots(roots: Array<{
        uri: string;
        name: string;
    }>): void;
    onEvent(listener: LeaseListener): () => void;
    emit(event: MCPPoolEvent): void;
    isCurrent(): boolean;
    retireFromPool(): void;
    invalidate(cause?: unknown): void;
    release(): Promise<void>;
    get subscriptions(): ReadonlySet<string>;
    private assertLive;
}
/** Owns physical MCP connections and exposes ref-counted leases. */
export declare class MCPConnectionPool {
    #private;
    constructor(options?: MCPConnectionPoolOptions);
    get size(): number;
    isCurrentLease(lease: MCPPoolLease): boolean;
    isCurrentGeneration(key: string, generation: number): boolean;
    /** Remove a lease's physical entry from key lookup before lifecycle rotation. */
    retireLease(lease: MCPPoolLease): void;
    /** @internal physical-entry retirement used by manager rotation. */
    retireEntry(entry: PoolEntry): void;
    /** Claim the single restart owner for a physical pool entry. */
    claimRestart(key: string): boolean;
    awaitRestart(key: string): Promise<boolean>;
    finishRestart(key: string, error?: unknown): void;
    releaseRestart(key: string): void;
    acquire(name: string, config: MCPServerConfig, options?: MCPPoolAcquireOptions): Promise<MCPPoolLease>;
    private waitForPendingEntry;
    private scheduleZeroClaimCleanup;
    private cancelPendingEntry;
    private startPendingEntry;
    private openEntry;
    private installTransportHandlers;
    private emit;
    broadcastReplacement(key: string, success: boolean): void;
    updateLeaseRoots(entry: PoolEntry, lease: MCPPoolLeaseImpl, roots: Array<{
        uri: string;
        name: string;
    }>): void;
    /** @internal Lease-facing aggregate subscription refcount update; not public API. */
    updateLeaseSubscriptions(entry: PoolEntry, previous: ReadonlySet<string>, next: ReadonlySet<string>): Promise<void>;
    releaseLease(entry: PoolEntry, lease: MCPPoolLeaseImpl, subscriptions: ReadonlySet<string>): Promise<void>;
    private closeEntry;
    private record;
    private notifyHealthChanged;
    getHealth(): MCPPoolHealth[];
    onHealthChanged(listener: HealthListener): () => void;
    shutdown(): Promise<void>;
}
export { buildMCPPoolKeyIdentity, computeMCPPoolKey, MCPPoolConfigError } from "./pool-key";