import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxPreservedSessionReuseOptions, type SandboxArchiveLimits, type SandboxConcurrencyLimits, type ExposedPortEndpoint, type ExecCommandArgs, type Mount, type SandboxSessionLifecycleOptions, type SandboxSessionState, type TypedMount, type WriteStdinArgs, type WorkspaceArchiveData, type WorkspaceArchiveOptions } from '@openai/agents-core/sandbox';
import { RemoteSandboxSessionBase, type RemoteSandboxCommandOptions, type RemoteSandboxCommandResult, type ManifestMountMaterializationContext } from '../shared';
import { validateRcloneMountEnvironmentCredentialExposure } from '../shared/inContainerMounts';
type E2BSandboxInstance = {
    sandboxId: string;
    files: E2BFilesystemApi;
    commands: E2BCommandsApi;
    pty?: E2BPtyApi;
    getHost?(port: number): string | Promise<string>;
    createSnapshot?(): Promise<{
        snapshotId?: string;
    }>;
    kill(): Promise<void | boolean>;
    pause?(): Promise<boolean>;
};
type E2BFilesystemApi = {
    write(path: string | {
        path: string;
        data: string | Uint8Array;
    }[], data?: string | Uint8Array): Promise<unknown>;
    read?(path: string, opts?: {
        format?: 'text' | 'bytes';
    }): Promise<string | Uint8Array>;
    remove?(path: string): Promise<unknown>;
    makeDir?(path: string): Promise<unknown>;
};
type E2BCommandResult = {
    stdout?: string;
    stderr?: string;
    exitCode?: number | null;
    error?: string;
};
type E2BCommandHandle = E2BCommandResult & {
    pid: number;
    wait?(): Promise<E2BCommandResult>;
    kill?(): Promise<boolean>;
    disconnect?(): Promise<void>;
};
type E2BCommandsApi = {
    run(command: string, opts?: {
        background?: boolean;
        cwd?: string;
        envs?: Record<string, string>;
        user?: string;
        timeoutMs?: number;
        onStdout?: (data: string) => void | Promise<void>;
        onStderr?: (data: string) => void | Promise<void>;
        stdin?: boolean;
    }): Promise<E2BCommandResult | E2BCommandHandle>;
};
type E2BPtyApi = {
    create(opts: {
        cols?: number;
        rows?: number;
        size?: {
            cols: number;
            rows: number;
        };
        cwd?: string;
        envs?: Record<string, string>;
        timeoutMs?: number;
        onData?: (data: Uint8Array) => void | Promise<void>;
    }): Promise<E2BCommandHandle>;
    sendInput?(pid: number, data: Uint8Array, opts?: Record<string, unknown>): Promise<void>;
    kill?(pid: number, opts?: Record<string, unknown>): Promise<boolean>;
};
export type E2BSandboxType = 'e2b' | 'e2b_code_interpreter';
export type E2BWorkspacePersistence = true | 'tar' | 'snapshot';
export type E2BTimeoutAction = 'pause' | 'kill';
export interface E2BSandboxClientOptions extends SandboxClientOptions {
    sandboxType?: E2BSandboxType;
    template?: string;
    timeout?: number;
    commandTimeoutMs?: number;
    requestTimeoutMs?: number;
    connectionTimeoutMs?: number;
    onTimeout?: E2BTimeoutAction;
    timeoutAction?: E2BTimeoutAction;
    autoResume?: boolean;
    metadata?: Record<string, string>;
    secure?: boolean;
    allowInternetAccess?: boolean;
    exposedPorts?: number[];
    workspacePersistence?: E2BWorkspacePersistence;
    archiveLimits?: SandboxArchiveLimits | null;
    mcp?: Record<string, unknown>;
    pauseOnExit?: boolean;
    env?: Record<string, string>;
}
export interface E2BSandboxSessionState extends SandboxSessionState {
    sandboxId: string;
    template?: string;
    sandboxType: E2BSandboxType;
    timeout?: number;
    commandTimeoutMs?: number;
    requestTimeoutMs?: number;
    connectionTimeoutMs?: number;
    onTimeout?: E2BTimeoutAction;
    timeoutAction?: E2BTimeoutAction;
    autoResume?: boolean;
    metadata?: Record<string, string>;
    secure?: boolean;
    allowInternetAccess?: boolean;
    configuredExposedPorts?: number[];
    workspacePersistence?: E2BWorkspacePersistence;
    mcp?: Record<string, unknown>;
    pauseOnExit: boolean;
    pauseOnExitSupported?: boolean;
    environment: Record<string, string>;
}
export declare class E2BSandboxSession extends RemoteSandboxSessionBase<E2BSandboxSessionState> {
    private sandbox;
    private readonly ptyProcesses;
    private readonly activeMountPaths;
    constructor(args: {
        state: E2BSandboxSessionState;
        sandbox: E2BSandboxInstance;
        concurrencyLimits?: SandboxConcurrencyLimits;
        archiveLimits?: SandboxArchiveLimits | null;
    });
    supportsPty(): boolean;
    writeStdin(args: WriteStdinArgs): Promise<string>;
    protected execPtyCommand(args: ExecCommandArgs): Promise<string>;
    protected exposedPortSource(): string;
    protected resolveRemoteExposedPort(requestedPort: number): Promise<ExposedPortEndpoint>;
    prepareWorkspaceRoot(): Promise<void>;
    persistWorkspace(): Promise<Uint8Array>;
    hydrateWorkspace(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    private persistWorkspaceViaNativeSnapshot;
    private nativeSnapshotRequiresTarFallback;
    private replaceSandboxFromSnapshot;
    close(): Promise<void>;
    shutdown(options?: SandboxSessionLifecycleOptions): Promise<void>;
    delete(options?: SandboxSessionLifecycleOptions): Promise<void>;
    private shouldPauseOnCleanup;
    private pauseOrKillAfterPauseFailure;
    protected assertExecRunAs(_runAs?: string): void;
    protected assertFilesystemRunAs(_runAs?: string): void;
    protected manifestMetadataSupport(): import("../shared").SandboxManifestMetadataSupport;
    protected manifestMaterializationOptions(): {
        materializeMount: (absolutePath: string, entry: Mount | TypedMount, context: ManifestMountMaterializationContext) => Promise<void>;
        validateManifest: typeof validateRcloneMountEnvironmentCredentialExposure;
    };
    protected forceTerminateAfterFailedPrivilegedManifestTransition(): Promise<void>;
    protected afterManifestMutationCommitted(materializedManifest: Manifest): void;
    protected runRemoteCommand(command: string, options: RemoteSandboxCommandOptions): Promise<RemoteSandboxCommandResult>;
    protected mkdirRemote(path: string): Promise<void>;
    protected readRemoteText(path: string): Promise<string>;
    protected readRemoteFile(path: string): Promise<Uint8Array>;
    protected writeRemoteFile(path: string, content: string | Uint8Array): Promise<void>;
    protected deleteRemotePath(path: string): Promise<void>;
    private ensureDirectory;
    private removeSandboxPath;
    private materializeMountEntry;
    private unmountActiveMounts;
    private mountCommandRunner;
    private runCommandForStatus;
    private commandTimeoutMs;
}
/**
 * @see {@link https://e2b.dev/docs | E2B docs}.
 * @see {@link https://e2b.dev/docs/sdk-reference/js-sdk/v2.8.0/sandbox | JavaScript SDK Sandbox reference}.
 * @see {@link https://e2b.dev/docs/sdk-reference/code-interpreter-js-sdk/v2.3.2/sandbox | Code Interpreter JavaScript SDK Sandbox reference}.
 */
export declare class E2BSandboxClient implements SandboxClient<E2BSandboxClientOptions, E2BSandboxSessionState> {
    readonly backendId = "e2b";
    private readonly options;
    constructor(options?: E2BSandboxClientOptions);
    create(args?: SandboxClientCreateArgs<E2BSandboxClientOptions> | Manifest, manifestOptions?: E2BSandboxClientOptions): Promise<E2BSandboxSession>;
    serializeSessionState(state: E2BSandboxSessionState): Promise<Record<string, unknown>>;
    canPersistOwnedSessionState(state: E2BSandboxSessionState): boolean;
    canReusePreservedOwnedSession(state: E2BSandboxSessionState, options?: SandboxPreservedSessionReuseOptions<E2BSandboxClientOptions>): Promise<boolean>;
    deserializeSessionState(state: Record<string, unknown>): Promise<E2BSandboxSessionState>;
    resume(state: E2BSandboxSessionState): Promise<E2BSandboxSession>;
}
export {};