import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxClientResumeOptions, type SandboxArchiveLimits, type SandboxConcurrencyLimits, type MaterializeEntryArgs, type SandboxSessionSerializationOptions, type SandboxPreservedSessionReuseOptions, type SandboxSessionState, type WorkspaceArchiveData, type WorkspaceArchiveOptions } from '@openai/agents-core/sandbox';
import { RemoteSandboxSessionBase, type RemoteSandboxCommandOptions, type RemoteSandboxCommandResult } from '../shared';
type VercelSandboxRunCommandParams = Record<string, unknown> & {
    cmd: string;
    args?: string[];
    cwd?: string;
    env?: Record<string, string>;
    sudo?: boolean;
    detached?: boolean;
    signal?: AbortSignal;
};
type VercelSandboxInstance = {
    sandboxId: string;
    runCommand(params: VercelSandboxRunCommandParams): Promise<VercelCommandFinishedLike>;
    runDetachedCommand(params: VercelSandboxRunCommandParams): Promise<VercelCommandLike>;
    mkDir(path: string): Promise<void>;
    readFileToBuffer(file: {
        path: string;
        cwd?: string;
    }): Promise<Buffer | Uint8Array | null>;
    writeFiles(files: {
        path: string;
        content: string | Uint8Array;
        mode?: number;
    }[]): Promise<void>;
    domain?(port: number): string;
    stop?(): Promise<unknown>;
    snapshot?(params?: {
        expiration?: number;
    }): Promise<{
        snapshotId?: string;
    }>;
};
type VercelCommandFinishedLike = {
    exitCode: number | null;
    output(stream?: 'stdout' | 'stderr' | 'both', options?: {
        signal?: AbortSignal;
    }): Promise<string>;
};
type VercelCommandLike = {
    wait(options?: {
        signal?: AbortSignal;
    }): Promise<VercelCommandFinishedLike>;
    kill(signal?: 'SIGKILL'): Promise<void>;
};
export type VercelWorkspacePersistence = 'tar' | 'snapshot';
export interface VercelSandboxClientOptions extends SandboxClientOptions {
    /**
     * Vercel project ID. Per-create or per-resume options override constructor options, which
     * override `VERCEL_PROJECT_ID`. Credentials are forwarded only when the
     * resolved `projectId`, `teamId`, and `token` are all non-empty.
     */
    projectId?: string;
    /**
     * Vercel team ID. Per-create or per-resume options override constructor options, which
     * override `VERCEL_TEAM_ID`. Credentials are forwarded only when the
     * resolved `projectId`, `teamId`, and `token` are all non-empty.
     */
    teamId?: string;
    /**
     * Vercel access token. Per-create or per-resume options override constructor options,
     * which override `VERCEL_TOKEN`. Credentials are forwarded only when the
     * resolved `projectId`, `teamId`, and `token` are all non-empty; otherwise
     * authentication is delegated to `@vercel/sandbox`. Create-time tokens are
     * included in serialized session state; current restoration credentials
     * remain runtime-only.
     */
    token?: string;
    runtime?: string;
    resources?: Record<string, unknown>;
    exposedPorts?: number[];
    interactive?: boolean;
    networkPolicy?: Record<string, unknown>;
    timeoutMs?: number;
    workspacePersistence?: VercelWorkspacePersistence;
    archiveLimits?: SandboxArchiveLimits | null;
    snapshotExpirationMs?: number;
    env?: Record<string, string>;
    /**
     * @deprecated Use Manifest.withInContainerMountCredentialExposureAcknowledged()
     * with each exact Vercel mount path instead.
     */
    allowS3CredentialExposure?: boolean;
}
export interface VercelSandboxSessionState extends SandboxSessionState {
    sandboxId: string;
    /**
     * Whether authentication is explicitly configured or delegated to the SDK.
     * Missing values identify session state created before this field existed.
     */
    authenticationMode?: 'explicit' | 'sdk';
    projectId?: string;
    teamId?: string;
    token?: string;
    runtime?: string;
    resources?: Record<string, unknown>;
    configuredExposedPorts?: number[];
    interactive?: boolean;
    networkPolicy?: Record<string, unknown>;
    timeoutMs?: number;
    workspacePersistence: VercelWorkspacePersistence;
    snapshotExpirationMs?: number;
    environment: Record<string, string>;
    snapshotId?: string;
    snapshotSandboxId?: string;
    snapshotSupported?: boolean;
}
export declare class VercelSandboxSession extends RemoteSandboxSessionBase<VercelSandboxSessionState> {
    #private;
    private sandbox;
    private readonly knownDirs;
    private readonly pendingDirCreates;
    private closePromise?;
    private closeCompleted;
    private mountFailure?;
    private readonly mountOperationMutex;
    /**
     * This provider applies the remote mount simplicity boundary by fixing the
     * mount set at creation and keeping it only in memory.
     *
     * Keep the lifecycle limited to create, tar detach/remount, and close. Do not
     * add dynamic mutation, persisted mount reconstruction, credential refresh,
     * or best-effort reconciliation without a trusted provider primitive that
     * makes those transitions unambiguous.
     */
    private readonly activeMounts;
    private readonly credentials;
    constructor(args: {
        state: VercelSandboxSessionState;
        sandbox: VercelSandboxInstance;
        credentials?: Pick<VercelSandboxClientOptions, 'projectId' | 'teamId' | 'token'>;
        concurrencyLimits?: SandboxConcurrencyLimits;
        archiveLimits?: SandboxArchiveLimits | null;
    });
    supportsPty(): boolean;
    protected assertExecRunAs(runAs?: string): void;
    protected assertFilesystemRunAs(runAs?: string): void;
    protected resolveManifestForApply(manifest: Manifest): Manifest;
    protected manifestMetadataSupport(): import("../shared").SandboxManifestMetadataSupport;
    protected beforeFilesystemMutation(): Promise<void>;
    protected beforeExecCommand(): Promise<void>;
    protected beforeMaterializeEntry(args: MaterializeEntryArgs): Promise<void>;
    protected beforeApplyManifest(manifest: Manifest): Promise<void>;
    protected runningWorkdir(): string;
    protected exposedPortSource(): string;
    protected resolveRemoteExposedPort(requestedPort: number): Promise<string>;
    materializeInitialManifest(manifest: Manifest): Promise<void>;
    prepareWorkspaceRoot(): Promise<void>;
    persistWorkspace(): Promise<Uint8Array>;
    hydrateWorkspace(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    close(): Promise<void>;
    private closeOnce;
    private closeMountedSandbox;
    shutdown(): Promise<void>;
    delete(): Promise<void>;
    private mountInitialEntry;
    private assertCanonicalMountPath;
    private assertCanonicalMountPathDuringTransition;
    private assertResolvedMountPath;
    private rollbackInitialMounts;
    private assertMountSessionUsable;
    protected assertSessionUsable(): void;
    private markMountSessionUnusable;
    private invalidateAfterFailedInitialMount;
    /**
     * Runs tar persistence while external bucket files are outside the workspace.
     *
     * A failed detach or remount stops the sandbox. This fail-closed boundary is
     * deliberate: recovery logic must not guess whether a privileged remote
     * operation completed.
     */
    private withMountsDetached;
    private withMountsDetachedLocked;
    private unmountAll;
    private remountAll;
    private prepareMountCandidates;
    private stopAfterMountTransitionFailure;
    private readonly mountCommand;
    private mountTransitionArchiveIo;
    private resolveRemotePathDirect;
    private resolveRemoteCredentialPathDirect;
    private runWorkspaceOperation;
    private runRemoteCommandDirect;
    private readRemoteFileDirect;
    private writeRemoteFileDirect;
    private execShell;
    private replaceSandboxFromSnapshot;
    private recoverSandboxAfterSnapshotRestoreFailure;
    private resolveSnapshotCredentials;
    private createAndPrepareSandboxFromSnapshot;
    private createSandboxFromSnapshot;
    private bindRestoredSandbox;
    private resetKnownDirs;
    private markWorkspaceMutated;
    private clearExposedPortCache;
    private ensureDir;
    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>;
    protected forceTerminateAfterFailedPrivilegedManifestTransition(): Promise<void>;
}
/**
 * @see {@link https://vercel.com/docs/vercel-sandbox | Vercel Sandbox overview}.
 * @see {@link https://vercel.com/docs/vercel-sandbox/sdk-reference | Sandbox SDK reference}.
 * @see {@link https://vercel.com/docs/vercel-sandbox/working-with-sandbox | Working with Sandbox examples}.
 */
export declare class VercelSandboxClient implements SandboxClient<VercelSandboxClientOptions, VercelSandboxSessionState> {
    readonly backendId = "vercel";
    private readonly options;
    constructor(options?: VercelSandboxClientOptions);
    resolveTrustedManifestForResume(manifest: Manifest, options?: VercelSandboxClientOptions): Manifest;
    create(args?: SandboxClientCreateArgs<VercelSandboxClientOptions> | Manifest, manifestOptions?: VercelSandboxClientOptions): Promise<VercelSandboxSession>;
    serializeSessionState(state: VercelSandboxSessionState, options?: SandboxSessionSerializationOptions): Promise<Record<string, unknown>>;
    canPersistOwnedSessionState(state: VercelSandboxSessionState): boolean;
    canReusePreservedOwnedSession(state: VercelSandboxSessionState, options?: SandboxPreservedSessionReuseOptions<VercelSandboxClientOptions>): Promise<boolean> | boolean;
    private canReuseMountedSession;
    deserializeSessionState(state: Record<string, unknown>): Promise<VercelSandboxSessionState>;
    resume(inputState: VercelSandboxSessionState, options?: SandboxClientResumeOptions<VercelSandboxClientOptions>): Promise<VercelSandboxSession>;
    private resolveSessionCredentials;
}
export {};