import { type ToolOutputImage } from '@openai/agents-core';
import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxPreservedSessionReuseOptions, type SandboxArchiveLimits, type SandboxConcurrencyLimits, type ExposedPortEndpoint, type ExecCommandArgs, type MaterializeEntryArgs, type ReadFileArgs, type SandboxSession, type SandboxSessionState, type ViewImageArgs, type WriteStdinArgs, type WorkspaceArchiveData, type WorkspaceArchiveOptions } from '@openai/agents-core/sandbox';
import { RemoteSandboxEditor } from '../shared/editor';
import { type CloudflareBucketMountRequestOptions } from './mounts';
export interface CloudflareSandboxClientOptions extends SandboxClientOptions {
    workerUrl: string;
    apiKey?: string;
    exposedPorts?: number[];
    timeoutMs?: number;
    createTimeoutMs?: number;
    requestTimeoutMs?: number;
    timeouts?: CloudflareSandboxTimeouts;
    mounts?: Array<Record<string, unknown>>;
    archiveLimits?: SandboxArchiveLimits | null;
}
export interface CloudflareSandboxTimeouts {
    execTimeoutMs?: number;
    createTimeoutMs?: number;
    requestTimeoutMs?: number;
}
export interface CloudflareSandboxSessionState extends SandboxSessionState {
    workerUrl: string;
    sandboxId: string;
    configuredExposedPorts?: number[];
    timeoutMs?: number;
    createTimeoutMs?: number;
    requestTimeoutMs?: number;
    timeouts?: CloudflareSandboxTimeouts;
    mounts?: Array<Record<string, unknown>>;
    environment: Record<string, string>;
}
export declare class CloudflareSandboxSession implements SandboxSession<CloudflareSandboxSessionState> {
    readonly state: CloudflareSandboxSessionState;
    private readonly apiKey?;
    private readonly ptyProcesses;
    private readonly concurrencyLimits?;
    private archiveLimits?;
    private readonly remotePathResolver;
    constructor(args: {
        state: CloudflareSandboxSessionState;
        apiKey?: string;
        concurrencyLimits?: SandboxConcurrencyLimits;
        archiveLimits?: SandboxArchiveLimits | null;
    });
    setArchiveLimits(limits?: SandboxArchiveLimits | null): void;
    createEditor(runAs?: string): RemoteSandboxEditor;
    supportsPty(): boolean;
    execCommand(args: ExecCommandArgs): Promise<string>;
    writeStdin(args: WriteStdinArgs): Promise<string>;
    private execPtyCommand;
    viewImage(args: ViewImageArgs): Promise<ToolOutputImage>;
    readFile(args: ReadFileArgs): Promise<Uint8Array>;
    pathExists(path: string, runAs?: string): Promise<boolean>;
    directoryExists(path: string, runAs?: string): Promise<boolean>;
    running(): Promise<boolean>;
    resolveExposedPort(port: number): Promise<ExposedPortEndpoint>;
    materializeEntry(args: MaterializeEntryArgs): Promise<void>;
    private materializeEntryExclusive;
    applyManifest(manifest: Manifest, runAs?: string): Promise<void>;
    private applyManifestExclusive;
    mountBucket(args: {
        bucket: string;
        mountPath: string;
        options: CloudflareBucketMountRequestOptions;
    }): Promise<void>;
    private mountBucketAtResolvedPath;
    unmountBucket(mountPath: string): Promise<void>;
    persistWorkspace(): Promise<Uint8Array>;
    hydrateWorkspace(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    close(): Promise<void>;
    shutdown(): Promise<void>;
    delete(): Promise<void>;
    private writer;
    private manifestMaterializationOptions;
    private materializeMountEntry;
    private execShell;
    private runAsCommandRunner;
    private readFileBytes;
    private writeFile;
    private ensureParentDir;
    private mkdirPath;
    private fetch;
    private resolveRemotePath;
}
/**
 * @see {@link https://developers.cloudflare.com/sandbox/ | Sandbox SDK overview}.
 * @see {@link https://developers.cloudflare.com/sandbox/get-started/ | Getting started}.
 * @see {@link https://developers.cloudflare.com/sandbox/concepts/architecture/ | Sandbox architecture}.
 */
export declare class CloudflareSandboxClient implements SandboxClient<CloudflareSandboxClientOptions, CloudflareSandboxSessionState> {
    readonly backendId = "cloudflare";
    readonly serializedSessionStateRequiresFreshCreation = true;
    private readonly options;
    private readonly deserializedSessionStates;
    constructor(options?: Partial<CloudflareSandboxClientOptions>);
    canReusePreservedOwnedSession(state: CloudflareSandboxSessionState, options?: SandboxPreservedSessionReuseOptions<CloudflareSandboxClientOptions>): boolean;
    create(args?: SandboxClientCreateArgs | Manifest, manifestOptions?: SandboxClientOptions): Promise<CloudflareSandboxSession>;
    serializeSessionState(state: CloudflareSandboxSessionState): Promise<Record<string, unknown>>;
    canPersistOwnedSessionState(): boolean;
    deserializeSessionState(state: Record<string, unknown>): Promise<CloudflareSandboxSessionState>;
    resume(state: CloudflareSandboxSessionState): Promise<CloudflareSandboxSession>;
}