import { SessionChildren as BrainChildren, SessionSandbox as BrainSandbox } from "@aexhq/brain";
import type { SandboxFileEntry as BrainSandboxFileEntry, SandboxStatus as BrainSandboxStatus } from "@aexhq/brain";
import type { Event, Session as BrainSession } from "@aexhq/brain/session";
import type { EventOptions } from "./transport.js";
import { Transport } from "./transport.js";
export type BinarySource = string | ArrayBuffer | ArrayBufferView | Blob;
/** A replayable, length- and digest-declared source for O(1)-heap large uploads. */
export interface StreamingUploadSource {
    readonly bytes: number;
    readonly sha256: string;
    stream(): ReadableStream<Uint8Array>;
}
export type UploadSource = BinarySource | StreamingUploadSource;
export interface OperationOptions {
    signal?: AbortSignal;
}
export interface IdempotentOperationOptions extends OperationOptions {
    /** Stable retry identity; the SDK generates one when omitted. */
    idempotencyKey?: string;
}
export interface PageOptions extends OperationOptions {
    cursor?: string;
    limit?: number;
}
export interface SandboxStatus {
    state: BrainSandboxStatus["state"];
    generation?: string;
    reason?: string;
    changedAt?: string;
    expiresAt?: string;
}
export interface SandboxFile {
    path: string;
    kind: BrainSandboxFileEntry["kind"];
    bytes: number;
    sha256?: string;
    modifiedAt: string;
}
export interface SandboxFilePage {
    data: SandboxFile[];
    hasMore: boolean;
    nextCursor?: string;
    generation: string;
}
export interface SandboxFileOptions extends OperationOptions {
    generation: string;
}
export interface SandboxFilePageOptions extends SandboxFileOptions, PageOptions {
}
export declare class SandboxFiles {
    #private;
    constructor(inner: BrainSandbox["files"], transport: Transport);
    list(path: string, options: SandboxFilePageOptions): Promise<SandboxFilePage>;
    stat(path: string, options: SandboxFileOptions): Promise<SandboxFile>;
    download(path: string, options: SandboxFileOptions): Promise<Uint8Array>;
    downloadStream(path: string, options: SandboxFileOptions): Promise<ReadableStream<Uint8Array>>;
    upload(path: string, source: UploadSource, options: SandboxFileOptions & {
        overwrite?: boolean;
    }): Promise<SandboxFile>;
    find(input: {
        path: string;
        glob: string;
    }, options: SandboxFilePageOptions): Promise<SandboxFilePage>;
    grep(input: {
        path: string;
        query: string;
    }, options: SandboxFilePageOptions): Promise<SandboxFilePage>;
}
export declare class SessionSandbox {
    #private;
    readonly files: SandboxFiles;
    constructor(transport: Transport, sessionId: string);
    status(options?: OperationOptions): Promise<SandboxStatus>;
    create(options?: OperationOptions): Promise<SandboxStatus>;
}
export interface StorageObject {
    key: string;
    bytes: number;
    sha256: string;
    contentType?: string;
    createdAt: string;
    updatedAt: string;
}
export interface StoragePage {
    data: StorageObject[];
    hasMore: boolean;
    nextCursor?: string;
}
export declare class SessionStorage {
    #private;
    constructor(transport: Transport, sessionId: string);
    list(options?: PageOptions & {
        prefix?: string;
    }): Promise<StoragePage>;
    stat(key: string, options?: OperationOptions): Promise<StorageObject>;
    download(key: string, options?: OperationOptions): Promise<Uint8Array>;
    downloadStream(key: string, options?: OperationOptions): Promise<ReadableStream<Uint8Array>>;
    upload(key: string, source: UploadSource, options?: OperationOptions & {
        contentType?: string;
        overwrite?: boolean;
    }): Promise<StorageObject>;
    delete(key: string, options?: OperationOptions): Promise<void>;
    copyFromSandbox(input: {
        key: string;
        path: string;
        sandboxGeneration: string;
        overwrite?: boolean;
    }, options?: OperationOptions): Promise<StorageObject>;
    copyToSandbox(input: {
        key: string;
        path: string;
        sandboxGeneration: string;
        overwrite?: boolean;
    }, options?: OperationOptions): Promise<SandboxFile>;
}
export interface ChildSummary {
    id: string;
    parentId: string;
    rootId: string;
    name?: string;
    depth: number;
    state: BrainSession["state"];
    turnState: BrainSession["turn_state"];
    turnPhase?: string;
    shape: BrainSession["shape"];
    createdAt: string;
    updatedAt: string;
}
export declare class SessionChild {
    #private;
    constructor(inner: ReturnType<BrainChildren["get"]>);
    get id(): string;
    info(options?: OperationOptions): Promise<ChildSummary>;
    send(message: string, options?: IdempotentOperationOptions): Promise<void>;
    followUp(message: string, options?: IdempotentOperationOptions): Promise<ChildSummary>;
    wait(options?: OperationOptions & {
        timeoutMs?: number;
    }): Promise<ChildSummary>;
    interrupt(options?: OperationOptions): Promise<ChildSummary>;
    end(options?: OperationOptions): Promise<ChildSummary>;
    events(options?: EventOptions): AsyncGenerator<Event>;
}
export declare class SessionChildren {
    #private;
    constructor(transport: Transport, sessionId: string);
    create(input: {
        prompt: string;
        name?: string;
        forkTurns?: "all" | "none" | `${number}`;
    }, options?: IdempotentOperationOptions): Promise<SessionChild>;
    list(options?: PageOptions): Promise<{
        data: ChildSummary[];
        hasMore: boolean;
        nextCursor?: string;
    }>;
    get(childId: string): SessionChild;
}
export declare function encodeBase64(bytes: Uint8Array): string;