import { EventEmitter } from 'node:events';
import { randomUUID } from 'node:crypto';
import { Readable } from 'node:stream';
import { ReadableStream, TransformStream } from 'node:stream/web';
import { AsyncLocalStorage } from 'node:async_hooks';
import { setTimeout as nodeSetTimeout, clearTimeout as nodeClearTimeout } from 'node:timers';
import { ListToolsResultSchema } from '@modelcontextprotocol/sdk/types.js';
type ToolList = ReturnType<typeof ListToolsResultSchema['parse']>;
type ToolItem = ToolList['tools'][number];
type CallToolContent = unknown;
declare class NodeMCPServerStdio {
    private session;
    private transport;
    private tools;
    private cacheDirty;
    private readonly timeout;
    private readonly nameValue;
    private readonly params;
    constructor(options: Record<string, unknown>);
    get name(): string;
    connect(): Promise<void>;
    listTools(): Promise<ToolItem[]>;
    callTool(toolName: string, args: Record<string, unknown> | null, timeoutMs?: number): Promise<CallToolContent>;
    invalidateToolsCache(): Promise<void>;
    close(): Promise<void>;
}
declare class NodeMCPServerSSE {
    private session;
    private transport;
    private tools;
    private cacheDirty;
    private readonly timeout;
    private readonly nameValue;
    private readonly params;
    constructor(options: Record<string, unknown>);
    get name(): string;
    connect(): Promise<void>;
    listTools(): Promise<ToolItem[]>;
    callTool(toolName: string, args: Record<string, unknown> | null, timeoutMs?: number): Promise<CallToolContent>;
    invalidateToolsCache(): Promise<void>;
    close(): Promise<void>;
}
declare class NodeMCPServerStreamableHttp {
    private session;
    private transport;
    private tools;
    private cacheDirty;
    private readonly timeout;
    private readonly nameValue;
    private readonly params;
    constructor(options: Record<string, unknown>);
    get name(): string;
    connect(): Promise<void>;
    listTools(): Promise<ToolItem[]>;
    callTool(toolName: string, args: Record<string, unknown> | null, timeoutMs?: number): Promise<CallToolContent>;
    invalidateToolsCache(): Promise<void>;
    close(): Promise<void>;
}
export declare const RuntimeEventEmitter: typeof EventEmitter;
export { randomUUID, Readable, ReadableStream, TransformStream, AsyncLocalStorage };
export declare const MCPServerStdio: typeof NodeMCPServerStdio;
export declare const MCPServerStreamableHttp: typeof NodeMCPServerStreamableHttp;
export declare const MCPServerSSE: typeof NodeMCPServerSSE;
export declare const timer: {
    setTimeout: (callback: (...args: unknown[]) => void, ms?: number) => NodeJS.Timeout;
    clearTimeout: (timeoutId: ReturnType<typeof nodeSetTimeout>) => void;
};
export declare const loadEnv: () => Record<string, unknown>;
export declare const isTracingLoopRunningByDefault: () => boolean;
export declare const isBrowserEnvironment: () => boolean;
export declare const clearTimeout: typeof nodeClearTimeout;
declare const shimModule: {
    RuntimeEventEmitter: typeof EventEmitter;
    randomUUID: typeof randomUUID;
    Readable: typeof Readable;
    ReadableStream: {
        new (underlyingSource: import("stream/web").UnderlyingByteSource, strategy?: import("stream/web").QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
        new <R = any>(underlyingSource?: import("stream/web").UnderlyingSource<R>, strategy?: import("stream/web").QueuingStrategy<R>): ReadableStream<R>;
        prototype: ReadableStream;
        from<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;
    };
    TransformStream: {
        new <I = any, O = any>(transformer?: import("stream/web").Transformer<I, O>, writableStrategy?: import("stream/web").QueuingStrategy<I>, readableStrategy?: import("stream/web").QueuingStrategy<O>): TransformStream<I, O>;
        prototype: TransformStream;
    };
    AsyncLocalStorage: typeof AsyncLocalStorage;
    MCPServerStdio: typeof NodeMCPServerStdio;
    MCPServerStreamableHttp: typeof NodeMCPServerStreamableHttp;
    MCPServerSSE: typeof NodeMCPServerSSE;
    timer: {
        setTimeout: (callback: (...args: unknown[]) => void, ms?: number) => NodeJS.Timeout;
        clearTimeout: (timeoutId: ReturnType<typeof nodeSetTimeout>) => void;
    };
    loadEnv: () => Record<string, unknown>;
    isTracingLoopRunningByDefault: () => boolean;
    isBrowserEnvironment: () => boolean;
    clearTimeout: typeof nodeClearTimeout;
};
export default shimModule;
//# sourceMappingURL=openai-agents-core-shims.d.ts.map