import { type LocalRuntime } from './runtime.js';
import { Sandbox, type Isolation, type SandboxNetwork, type VolumeMount } from './sandbox.js';
export interface BuildImageInfo {
    reference: string;
    digest: string;
    sizeBytes: number;
    layerCount: number;
}
export interface ImageInfo {
    reference: string;
    digest: string;
    sizeBytes: number;
    pulledAt: string;
    lastUsed: string;
    path: string;
}
export type RegistryProtocol = 'https' | 'http';
export declare class RegistryCredentials {
    readonly username: string;
    readonly password: string;
    constructor(username: string, password: string);
    bridgeValue(): Readonly<Record<string, string>>;
}
type SignaturePolicyValue = {
    mode: 'skip';
} | {
    mode: 'cosign_key';
    public_key: string;
} | {
    mode: 'cosign_keyless';
    issuer: string;
    identity: string;
};
export declare class SignaturePolicy {
    private readonly value;
    private constructor();
    static skip(): SignaturePolicy;
    static cosignKey(publicKey: string): SignaturePolicy;
    static cosignKeyless(issuer: string, identity: string): SignaturePolicy;
    bridgeValue(): SignaturePolicyValue;
}
export interface ImageHealthCheckInfo {
    test: readonly string[];
    interval?: number;
    timeout?: number;
    retries?: number;
    startPeriod?: number;
}
export interface ImageInspectInfo extends ImageInfo {
    manifestDigest: string;
    layerCount: number;
    entrypoint?: readonly string[];
    command?: readonly string[];
    env: Readonly<Record<string, string>>;
    workingDir?: string;
    user?: string;
    exposedPorts: readonly string[];
    volumes: readonly string[];
    stopSignal?: string;
    healthCheck?: ImageHealthCheckInfo;
    onbuild: readonly string[];
    labels: Readonly<Record<string, string>>;
}
export interface ImageHistoryInfo {
    created?: string;
    createdBy: string;
    sizeBytes: number;
    comment: string;
    emptyLayer: boolean;
}
export interface PushImageInfo {
    reference: string;
    manifestDigest: string;
    configUrl: string;
    manifestUrl: string;
}
export interface SdkCapabilities {
    protocolVersion: number;
    operations: readonly string[];
}
export interface SandboxSummary {
    id: string;
    shortId: string;
    name: string;
    image: string;
    isolation: string;
    status: string;
    statusSummary: string;
    active: boolean;
    pid?: number;
    cpus: number;
    memoryMb: number;
    ports: readonly string[];
    command: readonly string[];
    health: string;
    labels: Readonly<Record<string, string>>;
    createdAt: string;
    startedAt?: string;
    networkName?: string;
    volumeNames: readonly string[];
}
export interface SandboxLogEntry {
    stream: string;
    message: string;
    timestamp?: string;
}
export interface SandboxStats {
    id: string;
    shortId: string;
    name: string;
    status: string;
    pid: number;
    cpus: number;
    cpuPercent: number;
    cpuPercentScaled: number;
    memoryBytes: number;
    memoryLimitBytes: number;
    memoryPercent: number;
    networkRxBytes: number;
    networkTxBytes: number;
    blockReadBytes: number;
    blockWriteBytes: number;
}
export interface RuntimeVirtualization {
    available: boolean;
    backend?: string;
    details: string;
}
export interface RuntimeDiagnostics {
    coreVersion: string;
    runtimeVersion: string;
    sdkVersion: string;
    home: string;
    virtualization: RuntimeVirtualization;
}
export interface RuntimeDiskUsage {
    home: string;
    totalBytes: number;
    boxesBytes: number;
    imagesBytes: number;
    volumesBytes: number;
    snapshotsBytes: number;
    stateBytes: number;
    otherBytes: number;
}
export interface FilesystemSnapshotSummary {
    id: string;
    name: string;
    sourceSandboxId: string;
    image: string;
    vcpus: number;
    memoryMb: number;
    volumes: readonly string[];
    command: readonly string[];
    ports: readonly string[];
    labels: Readonly<Record<string, string>>;
    networkMode?: string;
    sizeBytes: number;
    createdAt: string;
    description: string;
}
export interface VolumeInfo {
    name: string;
    driver: string;
    mountPoint: string;
    labels: Readonly<Record<string, string>>;
    inUseBy: readonly string[];
    inUse: boolean;
    sizeLimit: number;
    createdAt: string;
}
export interface NetworkEndpointInfo {
    boxId: string;
    boxName: string;
    aliases: readonly string[];
    ipAddress: string;
    macAddress: string;
}
export interface NetworkInfo {
    name: string;
    driver: string;
    subnet: string;
    gateway: string;
    labels: Readonly<Record<string, string>>;
    endpoints: readonly NetworkEndpointInfo[];
    endpointCount: number;
    isolation: string;
    createdAt: string;
}
/** Host-level resource client and entry point for fluent builders. */
export declare class A3SBoxClient {
    readonly runtime: LocalRuntime;
    constructor(runtime?: LocalRuntime);
    image(contextDir: string): ImageBuilder;
    volume(name: string): VolumeBuilder;
    network(name: string): NetworkBuilder;
    sandbox(image?: string): SandboxBuilder;
    pullImage(reference: string, options?: {
        force?: boolean;
        platform?: string;
        credentials?: RegistryCredentials;
        signaturePolicy?: SignaturePolicy;
    }): Promise<ImageInfo>;
    getImage(reference: string): Promise<ImageInfo | undefined>;
    listImages(): Promise<ImageInfo[]>;
    inspectImage(reference: string): Promise<ImageInspectInfo | undefined>;
    imageHistory(reference: string): Promise<ImageHistoryInfo[] | undefined>;
    tagImage(source: string, target: string): Promise<ImageInfo>;
    pushImage(source: string, target: string, options?: {
        credentials?: RegistryCredentials;
        registryProtocol?: RegistryProtocol;
    }): Promise<PushImageInfo>;
    removeImage(reference: string): Promise<void>;
    evictImages(): Promise<string[]>;
    getVolume(name: string): Promise<VolumeInfo | undefined>;
    listVolumes(): Promise<VolumeInfo[]>;
    removeVolume(name: string, options?: {
        force?: boolean;
    }): Promise<VolumeInfo>;
    pruneVolumes(): Promise<string[]>;
    getNetwork(name: string): Promise<NetworkInfo | undefined>;
    listNetworks(): Promise<NetworkInfo[]>;
    removeNetwork(name: string): Promise<NetworkInfo>;
    pruneNetworks(): Promise<string[]>;
    capabilities(): Promise<SdkCapabilities>;
    listSandboxes(options?: {
        all?: boolean;
    }): Promise<SandboxSummary[]>;
    getSandbox(query: string): Promise<SandboxSummary | undefined>;
    runtimeDiagnostics(): Promise<RuntimeDiagnostics>;
    runtimeDiskUsage(): Promise<RuntimeDiskUsage>;
    listFilesystemSnapshots(): Promise<FilesystemSnapshotSummary[]>;
    getFilesystemSnapshot(snapshotId: string): Promise<FilesystemSnapshotSummary | undefined>;
}
export declare class ImageBuilder {
    private readonly runtime;
    private readonly contextDir;
    private dockerfilePath?;
    private imageTag?;
    private readonly buildArgs;
    private quietBuild;
    private readonly platforms;
    private buildTarget?;
    private disableCache;
    constructor(runtime: LocalRuntime, contextDir: string);
    dockerfile(path: string): this;
    tag(tag: string): this;
    buildArg(key: string, value: string): this;
    quiet(enabled?: boolean): this;
    platform(platform: string): this;
    target(target: string): this;
    noCache(enabled?: boolean): this;
    build(): Promise<BuildImageInfo>;
}
export declare class VolumeBuilder {
    private readonly runtime;
    private readonly name;
    private readonly labels;
    private sizeLimitBytes;
    constructor(runtime: LocalRuntime, name: string);
    label(key: string, value: string): this;
    sizeLimit(sizeBytes: number): this;
    create(): Promise<VolumeInfo>;
}
export declare class NetworkBuilder {
    private readonly runtime;
    private readonly name;
    private networkSubnet;
    private readonly labels;
    constructor(runtime: LocalRuntime, name: string);
    subnet(subnet: string): this;
    label(key: string, value: string): this;
    create(): Promise<NetworkInfo>;
}
export declare class SandboxBuilder {
    private readonly image;
    private readonly options;
    constructor(runtime: LocalRuntime, image: string);
    timeout(timeoutMs: number): this;
    command(...argv: string[]): this;
    entrypoint(...argv: string[]): this;
    env(key: string, value: string): this;
    metadata(key: string, value: string): this;
    name(name: string): this;
    cpus(cpus: number): this;
    memoryMb(memoryMb: number): this;
    isolation(isolation: Isolation): this;
    filesystemSnapshot(snapshotId: string): this;
    workspace(path: string): this;
    workdir(path: string): this;
    user(user: string): this;
    hostname(hostname: string): this;
    mount(mount: VolumeMount): this;
    mountBind(source: string, target: string, options?: {
        readOnly?: boolean;
    }): this;
    mountNamed(name: string, target: string, options?: {
        readOnly?: boolean;
    }): this;
    tmpfs(target: string, options?: {
        sizeBytes?: number;
        readOnly?: boolean;
    }): this;
    network(network: string | SandboxNetwork): this;
    disableNetwork(): this;
    publishTcp(hostPort: number, guestPort: number): this;
    dnsServer(address: string): this;
    hostAlias(host: string, address: string): this;
    readOnly(enabled?: boolean): this;
    persistent(enabled?: boolean): this;
    autoRemove(enabled?: boolean): this;
    start(): Promise<Sandbox>;
}
export {};
//# sourceMappingURL=client.d.ts.map