import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxArchiveLimits, type SandboxConcurrencyLimits, type ExposedPortEndpoint, type ExecCommandArgs, type Mount, type SandboxSessionLifecycleOptions, type SandboxSessionState, type TypedMount, type WriteStdinArgs } from '@openai/agents-core/sandbox';
import { RemoteSandboxSessionBase, type RemoteSandboxCommandOptions, type RemoteSandboxCommandResult, type ManifestMountMaterializationContext } from '../shared';
import { type BlaxelDriveApi } from './mounts';
export declare const DEFAULT_BLAXEL_WORKSPACE_ROOT = "/workspace";
type BlaxelCreateInternalOptions = {
    allowExistingNamedSandbox?: boolean;
};
type BlaxelSandboxLike = {
    name?: string;
    metadata?: {
        name?: string;
        createdAt?: string;
        workspace?: string;
        createdBy?: string;
    };
    status?: string;
    url?: string;
    sandbox?: {
        metadata?: {
            url?: string;
        };
    };
    process: {
        exec(params: Record<string, unknown>): Promise<BlaxelProcessResult>;
    };
    fs: {
        mkdir(path: string): Promise<void>;
        write(path: string, content: string): Promise<void>;
        writeBinary(path: string, content: Uint8Array): Promise<void>;
        read(path: string): Promise<string>;
        readBinary(path: string): Promise<Blob | Uint8Array | ArrayBuffer>;
        rm(path: string, recursive?: boolean): Promise<void>;
    };
    previews?: BlaxelPreviewApi;
    drives?: BlaxelDriveApi;
    delete(): Promise<void>;
};
type BlaxelPreviewApi = {
    createIfNotExists(params: Record<string, unknown>): Promise<unknown>;
};
type BlaxelProcessResult = {
    stdout?: string;
    stderr?: string;
    exitCode?: number | null;
};
export interface BlaxelSandboxTimeouts {
    execTimeoutMs?: number;
    createTimeoutMs?: number;
    cleanupTimeoutMs?: number;
    fileUploadTimeoutMs?: number;
    fileDownloadTimeoutMs?: number;
    workspaceTarTimeoutMs?: number;
    fastOperationTimeoutMs?: number;
}
export interface BlaxelSandboxClientOptions extends SandboxClientOptions {
    image?: string;
    memory?: number;
    region?: string;
    ports?: Array<Record<string, unknown>>;
    exposedPortPublic?: boolean;
    exposedPortUrlTtlS?: number;
    timeoutMs?: number;
    createTimeoutMs?: number;
    timeouts?: BlaxelSandboxTimeouts;
    apiKey?: string;
    env?: Record<string, string>;
    labels?: Record<string, string>;
    ttl?: string;
    name?: string;
    pauseOnExit?: boolean;
    archiveLimits?: SandboxArchiveLimits | null;
}
export interface BlaxelSandboxSessionState extends SandboxSessionState {
    sandboxName: string;
    sandboxIdentity?: string;
    mountArtifactScope?: string;
    image?: string;
    memory?: number;
    region?: string;
    ports?: Array<Record<string, unknown>>;
    exposedPortPublic?: boolean;
    exposedPortUrlTtlS?: number;
    timeoutMs?: number;
    createTimeoutMs?: number;
    timeouts?: BlaxelSandboxTimeouts;
    sandboxUrl?: string;
    labels?: Record<string, string>;
    ttl?: string;
    pauseOnExit: boolean;
    ownsSandbox: boolean;
    environment: Record<string, string>;
}
export declare class BlaxelSandboxSession extends RemoteSandboxSessionBase<BlaxelSandboxSessionState> {
    private readonly sandbox;
    private readonly apiKey?;
    private ownsSandbox;
    private closed;
    private readonly ptyProcesses;
    private readonly activeFuseMountPaths;
    private readonly activeDriveMountPaths;
    constructor(args: {
        state: BlaxelSandboxSessionState;
        sandbox: BlaxelSandboxLike;
        apiKey?: string;
        ownsSandbox?: boolean;
        concurrencyLimits?: SandboxConcurrencyLimits;
        archiveLimits?: SandboxArchiveLimits | null;
    });
    supportsPty(): boolean;
    writeStdin(args: WriteStdinArgs): Promise<string>;
    protected execPtyCommand(args: ExecCommandArgs): Promise<string>;
    protected allowOnDemandExposedPorts(): boolean;
    protected useCachedExposedPortEndpoint(_port: number): boolean;
    protected exposedPortSource(): string;
    protected resolveRemoteExposedPort(requestedPort: number): Promise<ExposedPortEndpoint>;
    prepareWorkspaceRoot(): Promise<void>;
    close(): Promise<void>;
    shutdown(_options?: SandboxSessionLifecycleOptions): Promise<void>;
    delete(options?: SandboxSessionLifecycleOptions): Promise<void>;
    private shouldPreserveOnCleanup;
    rehydrateActiveMountPathsFromManifest(): Promise<void>;
    protected manifestMetadataSupport(): import("../shared").SandboxManifestMetadataSupport;
    protected manifestMaterializationOptions(): {
        materializeMount: (absolutePath: string, entry: Mount | TypedMount, context: ManifestMountMaterializationContext) => Promise<void>;
        validateManifest: (manifest: Manifest) => void;
    };
    private assertUnownedCloudBucketMountsAreCredentialless;
    protected forceTerminateAfterFailedPrivilegedManifestTransition(): Promise<void>;
    protected assertExecRunAs(_runAs?: string): void;
    protected assertFilesystemRunAs(_runAs?: string): void;
    private materializeMountEntry;
    private unmountActiveMounts;
    private mountCommandRunner;
    private writeMountSecretFile;
    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>;
    private writeRemoteTempFile;
    protected deleteRemotePath(path: string): Promise<void>;
    private ensureMountArtifactScope;
    private timeoutForCommand;
}
/**
 * @see {@link https://docs.blaxel.ai/Sandboxes/Overview | Sandboxes overview}.
 * @see {@link https://docs.blaxel.ai/Sandboxes/Filesystem | Filesystem operations}.
 * @see {@link https://docs.blaxel.ai/Sandboxes/Sessions | Client-side sessions}.
 */
export declare class BlaxelSandboxClient implements SandboxClient<BlaxelSandboxClientOptions, BlaxelSandboxSessionState> {
    readonly backendId = "blaxel";
    private readonly options;
    constructor(options?: BlaxelSandboxClientOptions);
    create(args?: SandboxClientCreateArgs<BlaxelSandboxClientOptions> | Manifest, manifestOptions?: BlaxelSandboxClientOptions, internalOptions?: BlaxelCreateInternalOptions): Promise<BlaxelSandboxSession>;
    serializeSessionState(state: BlaxelSandboxSessionState): Promise<Record<string, unknown>>;
    canPersistOwnedSessionState(state: BlaxelSandboxSessionState): boolean;
    deserializeSessionState(state: Record<string, unknown>): Promise<BlaxelSandboxSessionState>;
    resume(state: BlaxelSandboxSessionState): Promise<BlaxelSandboxSession>;
    private recreateFromState;
}
export {};