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';
type DaytonaSandboxLike = {
    id: string;
    start(timeout?: number): Promise<void>;
    stop(timeout?: number, force?: boolean): Promise<void>;
    delete(timeout?: number): Promise<void>;
    fs: {
        createFolder(path: string, mode: string): Promise<void>;
        uploadFile(source: Buffer | string, remotePath: string, timeout?: number): Promise<void>;
        downloadFile(remotePath: string, timeout?: number): Promise<Buffer>;
        deleteFile(path: string, recursive?: boolean): Promise<void>;
    };
    process: {
        executeCommand(command: string, cwd?: string, env?: Record<string, string>, timeout?: number): Promise<DaytonaExecuteResponse>;
        createPty?(options?: {
            id?: string;
            cwd?: string;
            envs?: Record<string, string>;
            cols?: number;
            rows?: number;
            onData?: (data: Uint8Array | string) => void | Promise<void>;
        }): Promise<DaytonaPtyHandle>;
        killPtySession?(id: string): Promise<void>;
    };
    getSignedPreviewUrl?(port: number, expiresInSeconds?: number): Promise<DaytonaPreviewUrlLike>;
};
type DaytonaExecuteResponse = {
    exitCode: number;
    result: string;
    artifacts?: {
        stdout?: string;
    };
};
type DaytonaPreviewUrlLike = string | {
    url?: string;
};
type DaytonaPtyHandle = {
    sessionId?: string;
    waitForConnection?(): Promise<void>;
    sendInput?(data: string | Uint8Array): Promise<void>;
    wait?(): Promise<{
        exitCode?: number;
        error?: string;
    }>;
    kill?(): Promise<void>;
    disconnect?(): Promise<void>;
    exitCode?: number;
    error?: string;
};
export interface DaytonaSandboxClientOptions extends SandboxClientOptions {
    image?: string;
    resources?: Record<string, unknown>;
    env?: Record<string, string>;
    pauseOnExit?: boolean;
    createTimeoutSec?: number;
    startTimeoutSec?: number;
    timeoutSec?: number;
    sandboxSnapshotName?: string;
    exposedPorts?: number[];
    exposedPortUrlTtlS?: number;
    name?: string;
    autoStopInterval?: number;
    apiKey?: string;
    apiUrl?: string;
    target?: string;
    archiveLimits?: SandboxArchiveLimits | null;
}
export interface DaytonaSandboxSessionState extends SandboxSessionState {
    sandboxId: string;
    image?: string;
    resources?: Record<string, unknown>;
    pauseOnExit: boolean;
    createTimeoutSec?: number;
    startTimeoutSec?: number;
    timeoutSec?: number;
    sandboxSnapshotName?: string;
    configuredExposedPorts?: number[];
    exposedPortUrlTtlS?: number;
    name?: string;
    autoStopInterval?: number;
    environment: Record<string, string>;
    apiKey?: string;
    apiUrl?: string;
    target?: string;
}
export declare class DaytonaSandboxSession implements SandboxSession<DaytonaSandboxSessionState> {
    readonly state: DaytonaSandboxSessionState;
    private readonly sandbox;
    private readonly ptyProcesses;
    private readonly remotePathResolver;
    private readonly activeMountPaths;
    private readonly concurrencyLimits?;
    private archiveLimits?;
    private stopPromise?;
    private deletePromise?;
    constructor(args: {
        state: DaytonaSandboxSessionState;
        sandbox: DaytonaSandboxLike;
        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;
    private terminatePtyHandle;
    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;
    materializeInitialManifest(manifest: Manifest): Promise<void>;
    rematerializeMountEntries(): Promise<void>;
    private rematerializeMountEntriesExclusive;
    prepareWorkspaceRoot(): Promise<void>;
    persistWorkspace(): Promise<Uint8Array>;
    hydrateWorkspace(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    close(): Promise<void>;
    shutdown(): Promise<void>;
    delete(): Promise<void>;
    private stopOnce;
    private deleteOnce;
    private writer;
    private assertSessionUsable;
    private invalidateAfterFailedPrivilegedManifestTransition;
    private manifestMaterializationOptions;
    private materializeMountEntry;
    private unmountActiveMounts;
    private unmountMountPath;
    private mountCommandRunner;
    private runAsCommandRunner;
    private archiveIo;
    private readFileBytes;
    private readEditorText;
    private mkdirEditorPath;
    private writeEditorText;
    private deleteEditorPath;
    private runEditorFileCommand;
    private resolveEditorPath;
    private ensureParentDir;
    private resolveRemotePath;
    private resolveRemoteCredentialPath;
    private createSignedPreviewUrl;
}
/**
 * @see {@link https://www.daytona.io/docs/ | Daytona docs}.
 * @see {@link https://www.daytona.io/docs/en/getting-started/ | Getting started}.
 * @see {@link https://www.daytona.io/docs/en/typescript-sdk/sandbox/ | TypeScript SDK Sandbox reference}.
 */
export declare class DaytonaSandboxClient implements SandboxClient<DaytonaSandboxClientOptions, DaytonaSandboxSessionState> {
    readonly backendId = "daytona";
    private readonly options;
    constructor(options?: DaytonaSandboxClientOptions);
    resolveTrustedManifestForResume(manifest: Manifest): Manifest;
    create(args?: SandboxClientCreateArgs<DaytonaSandboxClientOptions> | Manifest, manifestOptions?: DaytonaSandboxClientOptions): Promise<DaytonaSandboxSession>;
    serializeSessionState(state: DaytonaSandboxSessionState): Promise<Record<string, unknown>>;
    canPersistOwnedSessionState(state: DaytonaSandboxSessionState): boolean;
    canReusePreservedOwnedSession(state: DaytonaSandboxSessionState, options?: SandboxPreservedSessionReuseOptions<DaytonaSandboxClientOptions>): Promise<boolean>;
    deserializeSessionState(state: Record<string, unknown>): Promise<DaytonaSandboxSessionState>;
    resume(state: DaytonaSandboxSessionState): Promise<DaytonaSandboxSession>;
    private recreateFromPersistedState;
}
export {};