import { type ToolOutputImage } from '@openai/agents-core';
import { type ExecCommandArgs, type ExposedPortEndpoint, Manifest, type MaterializeEntryArgs, type ReadFileArgs, type SandboxArchiveLimits, type SandboxConcurrencyLimits, type SandboxSession, type SandboxSessionState, type ViewImageArgs, type WorkspaceArchiveData, type WorkspaceArchiveOptions } from '@openai/agents-core/sandbox';
import { type RemoteWorkspaceTarIo } from './archive';
import { RemoteSandboxEditor } from './editor';
import { type ManifestMaterializationOptions } from './manifest';
import type { RemoteManifestWriter, RemoteSandboxPathOptions, RemoteSandboxPathResolver, SandboxManifestMetadataSupport } from './types';
export type RemoteSandboxCommandKind = 'archive' | 'exec' | 'manifest' | 'path' | 'running';
export type RemoteSandboxCommandOptions = {
    kind: RemoteSandboxCommandKind;
    workdir: string;
    environment?: Record<string, string>;
    runAs?: string;
    execArgs?: ExecCommandArgs;
    timeoutMs?: number;
};
export type RemoteSandboxCommandResult = {
    status: number;
    stdout?: string;
    stderr?: string;
};
export type RemoteSandboxSessionBaseOptions = {
    providerName: string;
    providerId: string;
    concurrencyLimits?: SandboxConcurrencyLimits;
    archiveLimits?: SandboxArchiveLimits | null;
};
export declare abstract class RemoteSandboxSessionBase<TState extends SandboxSessionState & {
    environment: Record<string, string>;
}> implements SandboxSession<TState> {
    readonly state: TState;
    protected readonly providerName: string;
    protected readonly providerId: string;
    private readonly concurrencyLimits?;
    private archiveLimits?;
    protected readonly remotePathResolver: RemoteSandboxPathResolver;
    protected constructor(args: {
        state: TState;
        options: RemoteSandboxSessionBaseOptions;
    });
    setArchiveLimits(limits?: SandboxArchiveLimits | null): void;
    protected getArchiveLimits(): SandboxArchiveLimits | null | undefined;
    createEditor(runAs?: string): RemoteSandboxEditor;
    supportsPty(): boolean;
    execCommand(args: ExecCommandArgs): Promise<string>;
    viewImage(args: ViewImageArgs): Promise<ToolOutputImage>;
    pathExists(path: string, runAs?: string): Promise<boolean>;
    directoryExists(path: string, runAs?: string): Promise<boolean>;
    readFile(args: ReadFileArgs): Promise<Uint8Array>;
    running(): Promise<boolean>;
    resolveExposedPort(port: number): Promise<ExposedPortEndpoint>;
    materializeEntry(args: MaterializeEntryArgs): Promise<void>;
    private materializeEntryExclusive;
    applyManifest(manifest: Manifest, runAs?: string): Promise<void>;
    private applyManifestExclusive;
    persistWorkspace(): Promise<Uint8Array>;
    hydrateWorkspace(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    protected abstract runRemoteCommand(command: string, options: RemoteSandboxCommandOptions): Promise<RemoteSandboxCommandResult>;
    protected abstract mkdirRemote(path: string): Promise<void>;
    protected abstract readRemoteText(path: string): Promise<string>;
    protected abstract readRemoteFile(path: string): Promise<Uint8Array>;
    protected abstract writeRemoteFile(path: string, content: string | Uint8Array): Promise<void>;
    protected abstract deleteRemotePath(path: string): Promise<void>;
    protected afterManifestMutationCommitted(_materializedManifest: Manifest): void;
    protected assertSessionUsable(): void;
    protected execPtyCommand(_args: ExecCommandArgs): Promise<string>;
    private sessionUsable;
    protected invalidateAfterFailedPrivilegedManifestTransition(): Promise<void>;
    protected assertExecRunAs(runAs?: string): void;
    protected assertFilesystemRunAs(runAs?: string): void;
    protected assertManifestRunAs(runAs?: string): void;
    protected beforeExecCommand(_args: ExecCommandArgs): Promise<void>;
    protected beforeFilesystemMutation(): Promise<void>;
    protected beforeMaterializeEntry(_args: MaterializeEntryArgs): Promise<void>;
    protected beforeMaterializeEntryMayHaveSideEffects(): boolean;
    protected beforeApplyManifest(_manifest: Manifest): Promise<void>;
    protected beforeApplyManifestMayHaveSideEffects(): boolean;
    protected forceTerminateAfterFailedPrivilegedManifestTransition(): Promise<void>;
    protected resolveManifestForApply(manifest: Manifest): Manifest | Promise<Manifest>;
    protected manifestMetadataSupport(): SandboxManifestMetadataSupport | undefined;
    protected manifestMaterializationOptions(): ManifestMaterializationOptions;
    protected workspacePersistence(): unknown;
    protected configuredExposedPorts(): number[] | undefined;
    protected allowOnDemandExposedPorts(): boolean;
    protected useCachedExposedPortEndpoint(_port: number): boolean;
    protected exposedPortSource(): string;
    protected resolveRemoteExposedPort(port: number): Promise<string | ExposedPortEndpoint>;
    protected runningWorkdir(): string;
    protected resolveWorkdir(path?: string): string;
    protected resolveAbsolutePath(path?: string): string;
    protected resolveRemotePath(path?: string, options?: RemoteSandboxPathOptions): Promise<string>;
    protected resolveRemoteCredentialPath(path: string): Promise<string>;
    protected ensureParentDir(path: string): Promise<void>;
    protected persistWorkspaceTar(): Promise<Uint8Array>;
    protected hydrateWorkspaceTar(data: WorkspaceArchiveData, options?: WorkspaceArchiveOptions): Promise<void>;
    protected manifestWriter(): RemoteManifestWriter;
    protected materializeManifestEntries(manifest: Manifest): Promise<void>;
    protected archiveIo(): RemoteWorkspaceTarIo;
    private parentDir;
    private createRunAsEditor;
    private readRemoteFileAs;
    private writeRemoteTextAs;
    private manifestMaterializationOptionsWithMetadata;
    private provisionManifestAccounts;
    private applyManifestEntryMetadata;
    private runCheckedRemoteCommand;
}