import { type ToolOutputImage } from '@openai/agents-core';
import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxClientResumeOptions, 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, type RemoteSandboxPathOptions } from '../shared';
type ModalCloudBucketMountLike = {
    toProto?(mountPath: string): unknown;
};
type ModalSecretLike = unknown;
type ModalSandboxFilesystemLike = {
    readBytes(path: string): Promise<Uint8Array>;
    writeBytes(data: Uint8Array | ArrayBuffer | Buffer, path: string): Promise<void>;
};
type ModalClientLike = {
    apps: {
        fromName(name: string, params?: {
            createIfMissing?: boolean;
            environment?: string;
        }): Promise<ModalAppLike>;
    };
    images: {
        fromRegistry(tag: string): ModalImageLike;
        fromId?(id: string): ModalImageLike | Promise<ModalImageLike>;
        delete?(id: string): Promise<void>;
    };
    sandboxes: {
        create(app: ModalAppLike, image: ModalImageLike, params?: Record<string, unknown>): Promise<ModalSandboxLike>;
        fromId(id: string): Promise<ModalSandboxLike>;
    };
    cloudBucketMounts: {
        create(bucketName: string, params?: Record<string, unknown>): ModalCloudBucketMountLike;
    };
    secrets: {
        fromName(name: string, params?: {
            environment?: string;
        }): ModalSecretLike | Promise<ModalSecretLike>;
        fromObject(entries: Record<string, string>, params?: Record<string, unknown>): ModalSecretLike | Promise<ModalSecretLike>;
    };
    imageBuilderVersion?(version?: string): string;
};
type ModalAppLike = {
    appId?: string;
};
type ModalImageLike = {
    imageId?: string;
    objectId?: string;
    cmd?(command: string[]): ModalImageLike;
};
type ModalSandboxSelectorLike = {
    sandboxId: string;
    objectId?: string;
    [key: string]: unknown;
};
type ModalSandboxLike = {
    sandboxId: string;
    objectId?: string;
    filesystem: ModalSandboxFilesystemLike;
    exec(command: string[], params?: Record<string, unknown>): Promise<ModalContainerProcessLike>;
    terminate(params?: {
        wait?: boolean;
    }): Promise<void | number>;
    poll(): Promise<number | null>;
    tunnels?(timeoutMs?: number): Promise<Record<number, ModalTunnelLike>>;
    snapshotFilesystem?(timeoutMs?: number): Promise<string | {
        objectId?: string;
        imageId?: string;
        id?: string;
    }>;
    snapshotDirectory?(path: string): Promise<string | {
        objectId?: string;
        imageId?: string;
        id?: string;
    }>;
    mountImage?(path: string, image?: ModalImageLike): Promise<unknown>;
};
type ModalTunnelLike = {
    host?: string;
    port?: number;
};
type ModalContainerProcessLike = {
    stdin?: {
        writeText?(text: string): Promise<void>;
        close?(): Promise<void>;
    };
    stdout: ReadableStream<string>;
    stderr: ReadableStream<string>;
    wait(): Promise<number>;
};
type ModalCloudBucketMountsProvider = () => Promise<Record<string, ModalCloudBucketMountLike> | undefined>;
export type ModalWorkspacePersistence = 'tar' | 'snapshot_filesystem' | 'snapshot_directory';
export type ModalImageSelectorKind = 'image' | 'id' | 'tag';
export declare class ModalImageSelector {
    readonly kind: ModalImageSelectorKind;
    readonly value: ModalImageLike | string;
    private constructor();
    static fromImage(image: ModalImageLike): ModalImageSelector;
    static fromId(imageId: string): ModalImageSelector;
    static fromTag(imageTag: string): ModalImageSelector;
}
export type ModalSandboxSelectorKind = 'sandbox' | 'id';
export declare class ModalSandboxSelector {
    readonly kind: ModalSandboxSelectorKind;
    readonly value: ModalSandboxSelectorLike | string;
    private constructor();
    static fromSandbox(sandbox: ModalSandboxSelectorLike): ModalSandboxSelector;
    static fromId(sandboxId: string): ModalSandboxSelector;
}
export interface ModalSandboxClientOptions extends SandboxClientOptions {
    appName: string;
    image?: ModalImageSelector;
    sandbox?: ModalSandboxSelector;
    imageTag?: string;
    sandboxCreateTimeoutS?: number;
    workspacePersistence?: ModalWorkspacePersistence;
    snapshotFilesystemTimeoutMs?: number;
    snapshotFilesystemRestoreTimeoutMs?: number;
    env?: Record<string, string>;
    timeoutMs?: number;
    idleTimeoutMs?: number;
    cpu?: number;
    cpuLimit?: number;
    memoryMiB?: number;
    memoryLimitMiB?: number;
    gpu?: string;
    exposedPorts?: number[];
    environment?: string;
    endpoint?: string;
    tokenId?: string;
    tokenSecret?: string;
    imageBuilderVersion?: string;
    nativeCloudBucketSecretName?: string;
    useSleepCmd?: boolean;
    archiveLimits?: SandboxArchiveLimits | null;
}
export interface ModalSandboxSessionState extends SandboxSessionState {
    sandboxId?: string;
    ownsSandbox?: boolean;
    appName: string;
    imageId?: string;
    imageTag: string;
    sandboxCreateTimeoutS?: number;
    workspacePersistence: ModalWorkspacePersistence;
    snapshotFilesystemTimeoutMs?: number;
    snapshotFilesystemRestoreTimeoutMs?: number;
    environment: Record<string, string>;
    timeoutMs?: number;
    idleTimeoutMs?: number;
    cpu?: number;
    cpuLimit?: number;
    memoryMiB?: number;
    memoryLimitMiB?: number;
    gpu?: string;
    configuredExposedPorts?: number[];
    modalEnvironment?: string;
    endpoint?: string;
    imageBuilderVersion?: string;
    nativeCloudBucketSecretName?: string;
    useSleepCmd: boolean;
}
export declare class ModalSandboxSession implements SandboxSession<ModalSandboxSessionState> {
    readonly state: ModalSandboxSessionState;
    private readonly modal;
    private readonly app;
    private readonly cloudBucketMountsProvider?;
    private cloudBucketMounts?;
    private cloudBucketMountsResolved;
    private sandbox;
    private ownsSandbox;
    private closed;
    private closePromise?;
    private readonly activeProcesses;
    private readonly remotePathResolver;
    private readonly concurrencyLimits?;
    private archiveLimits?;
    private nextProcessId;
    constructor(args: {
        state: ModalSandboxSessionState;
        modal: ModalClientLike;
        app: ModalAppLike;
        sandbox: ModalSandboxLike;
        ownsSandbox?: boolean;
        cloudBucketMounts?: Record<string, ModalCloudBucketMountLike>;
        cloudBucketMountsProvider?: ModalCloudBucketMountsProvider;
        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>;
    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>;
    applyManifest(manifest: Manifest, runAs?: string): Promise<void>;
    persistWorkspace(): Promise<Uint8Array>;
    hydrateWorkspace(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    private persistSnapshotFilesystem;
    private persistSnapshotDirectory;
    private nativeSnapshotRequiresTarFallback;
    private assertExpectedSnapshotPersistence;
    private restoreSnapshotFilesystem;
    private restoreSnapshotDirectory;
    private deleteSnapshotDirectoryImage;
    private modalImageFromId;
    private sandboxCreateParams;
    private resolveCloudBucketMounts;
    close(): Promise<void>;
    private closeOnce;
    private resetActiveProcesses;
    private manifestMaterializationOptions;
    private invalidateCloudBucketMounts;
    shutdown(): Promise<void>;
    delete(): Promise<void>;
    private registerActiveProcess;
    private deleteActiveProcess;
    resolveAbsolutePath(path?: string): string;
    resolveRemotePath(path?: string, options?: RemoteSandboxPathOptions): Promise<string>;
    resolveWorkdir(path?: string): string;
    ensureDirectory(path: string): Promise<void>;
    writeSandboxFile(path: string, content: string | Uint8Array): Promise<void>;
    readSandboxFile(path: string): Promise<Uint8Array>;
    removeSandboxPath(path: string): Promise<void>;
    private runAsCommandRunner;
    private writer;
    private archiveIo;
    private runDirectCommand;
}
/**
 * @see {@link https://modal.com/docs/guide/sandboxes | Sandboxes guide}.
 * @see {@link https://modal.com/docs/guide/sdk-javascript-go | JavaScript and Go SDK guide}.
 * @see {@link https://modal.com/docs/reference/modal.Sandbox | Sandbox reference}.
 */
export declare class ModalSandboxClient implements SandboxClient<ModalSandboxClientOptions, ModalSandboxSessionState> {
    readonly backendId = "modal";
    readonly preservedOwnedSessionReuseRejectionRequiresFreshCreation = true;
    private readonly options;
    constructor(options?: Partial<ModalSandboxClientOptions>);
    create(args?: SandboxClientCreateArgs | Manifest, manifestOptions?: SandboxClientOptions): Promise<ModalSandboxSession>;
    serializeSessionState(state: ModalSandboxSessionState): Promise<Record<string, unknown>>;
    canPersistOwnedSessionState(): boolean;
    serializedSessionStateRequiresFreshCreationForOptions(state: ModalSandboxSessionState, options?: SandboxClientResumeOptions<ModalSandboxClientOptions>): boolean;
    canReusePreservedOwnedSession(state: ModalSandboxSessionState, options?: SandboxPreservedSessionReuseOptions<ModalSandboxClientOptions>): Promise<boolean>;
    rebindPreservedOwnedSessionState(state: ModalSandboxSessionState, options?: SandboxPreservedSessionReuseOptions<ModalSandboxClientOptions>): void;
    deserializeSessionState(state: Record<string, unknown>): Promise<ModalSandboxSessionState>;
    resume(state: ModalSandboxSessionState, options?: SandboxClientResumeOptions<ModalSandboxClientOptions>): Promise<ModalSandboxSession>;
}
export {};