import { BlitConnection, type AwaitSessionExitOptions, type CreateBlitConnectionOptions } from "./BlitConnection";
import type { BlitConnectionSnapshot, BlitSearchResult, BlitSession, BlitTransport, BlitWorkspaceSnapshot, ConnectionId, SessionId, TransportConfig } from "./types";
import type { BlitWasmModule } from "./TerminalStore";
import type { FsFileIndex, FsGrepOptions, FsGrepResult, FsSyncHandle, FsSyncOptions } from "./fs";
import type { GitDiscoverOptions, GitFoundRepo, GitOpenOptions, GitRepoHandle } from "./git";
import type { KvFetchResult, KvPutOptions, KvWatchHandle, KvWatchOptions } from "./kv";
import type { LspHandle, LspOpenOptions } from "./lsp";
import { BlitActivityStore } from "./activity";
export interface AddBlitConnectionOptions extends Omit<CreateBlitConnectionOptions, "wasm" | "transport"> {
    transport?: BlitTransport | TransportConfig;
    wasm?: BlitWasmModule | Promise<BlitWasmModule>;
}
/** Logger interface for workspace lifecycle events. */
export interface BlitLogger {
    /** Called for informational events (subscribe, unsubscribe, connect, etc.). */
    info(msg: string, ...args: unknown[]): void;
    /** Called for warnings (decode errors, transport issues, etc.). */
    warn(msg: string, ...args: unknown[]): void;
}
/** Default logger that writes to the console. */
export declare const consoleLogger: BlitLogger;
/** Silent logger that discards everything. */
export declare const nullLogger: BlitLogger;
export interface CreateBlitWorkspaceOptions {
    wasm: BlitWasmModule | Promise<BlitWasmModule>;
    connections?: AddBlitConnectionOptions[];
    logger?: BlitLogger;
}
export interface CreateWorkspaceSessionOptions {
    connectionId: ConnectionId;
    rows: number;
    cols: number;
    tag?: string;
    /** Run this through the target server's login shell. */
    command?: string;
    /** Exec this argv directly, no shell. Needs `FEATURE_CREATE_EXEC`. */
    argv?: readonly string[];
    cwdFromSessionId?: SessionId;
    cwd?: string;
    /** Environment overrides for the child. Needs `FEATURE_CREATE_EXEC`. */
    env?: Readonly<Record<string, string>>;
    /** Server-enforced lifetime, armed at creation. Needs
     *  `FEATURE_PTY_DEADLINE`. */
    deadlineMs?: number;
    /** Whether the creating connection should immediately receive terminal
     *  frame updates. Defaults to true. */
    subscribe?: boolean;
}
export interface ResizeWorkspaceSessionOptions {
    sessionId: SessionId;
    rows: number;
    cols: number;
}
export declare class BlitWorkspace {
    private readonly listeners;
    private readonly connectionListeners;
    private readonly termCwdListeners;
    private readonly termCwdUnsubs;
    private readonly connections;
    private readonly defaultWasm;
    private surfaceDiagnosticsEnabled;
    /** Slow operations surfaced by shell chrome such as the status bar. */
    readonly activities: BlitActivityStore;
    readonly logger: BlitLogger;
    private snapshot;
    constructor({ wasm, connections, logger }: CreateBlitWorkspaceOptions);
    subscribe: (listener: () => void) => (() => void);
    getSnapshot: () => BlitWorkspaceSnapshot;
    addConnection(options: AddBlitConnectionOptions): BlitConnection;
    removeConnection(connectionId: ConnectionId): void;
    dispose(): void;
    getConnection(connectionId: ConnectionId): BlitConnection | null;
    /** Drop terminal view-size registrations while keeping connections alive. */
    resetViewSizes(): void;
    getConnectionSnapshot(connectionId: ConnectionId): BlitConnectionSnapshot | null;
    getSession(sessionId: SessionId): BlitSession | null;
    createSession(options: CreateWorkspaceSessionOptions): Promise<BlitSession>;
    closeSession(sessionId: SessionId): Promise<void>;
    /** Wait for a session to exit or close, preserving its final exit status. */
    awaitSessionExit(sessionId: SessionId, options?: AwaitSessionExitOptions): Promise<BlitSession>;
    closeSurface(connectionId: ConnectionId, surfaceId: number): void;
    /**
     * Mirror a directory tree from one connection's server (docs/fs-watch.md):
     * a live map plus per-record callbacks. See `BlitConnection.syncFs`.
     */
    syncFs(connectionId: ConnectionId, path: string, options?: FsSyncOptions): Promise<FsSyncHandle>;
    /**
     * Open a git repository on one connection's server (docs/git.md): live
     * state plus oid-addressed reads. See `BlitConnection.openRepo`.
     */
    openRepo(connectionId: ConnectionId, path: string, options?: GitOpenOptions): Promise<GitRepoHandle>;
    /**
     * Repositories under `path` on one connection's server — "what is checked
     * out here" in one call, rather than a ladder of candidate paths probed
     * with an `FS_SYNC` per level. Allocates no repo id, so it costs nothing
     * against the per-connection repo budget. See
     * `BlitConnection.discoverRepos`.
     */
    discoverRepos(connectionId: ConnectionId, path: string, options?: GitDiscoverOptions): Promise<GitFoundRepo[]>;
    /** Fuzzy file search under `root` on one connection; up to `limit` matches,
     *  best first. See `BlitConnection.searchFiles`. */
    searchFiles(connectionId: ConnectionId, root: string, query: string, limit?: number): Promise<string[]>;
    /** Candidate file list under `root` on one connection, for client-side
     *  fuzzy search. See `BlitConnection.indexFiles`. */
    indexFiles(connectionId: ConnectionId, root: string): Promise<FsFileIndex>;
    /** Content search under `root` on one connection, hits grouped by file
     *  (tracked first, gitignored last). See `BlitConnection.grep`. */
    grep(connectionId: ConnectionId, root: string, query: string, opts?: FsGrepOptions): Promise<FsGrepResult>;
    /** A session's live working directory (server reads the pty's cwd). "" when
     *  unavailable. See `BlitConnection.sessionCwd`. */
    sessionCwd(connectionId: ConnectionId, sessionId: SessionId): Promise<string>;
    /** Subscribe to server-pushed cwd changes across every connection
     *  (`S2C_TERM_CWD_EVENT`, docs/protocol.md): consumers can suppress
     *  `sessionCwd` polling while pushes flow. Returns an unsubscribe
     *  function. */
    onTermCwd(listener: (sessionId: SessionId, cwd: string) => void): () => void;
    /** The most recent server-pushed cwd for a session, or null when none
     *  has arrived since (re)connect. See `BlitConnection.lastPushedCwd`. */
    lastPushedCwd(sessionId: SessionId): string | null;
    /**
     * Attach language intelligence on one connection's server (docs/lsp.md):
     * live server state + diagnostics plus point-in-time queries. See
     * `BlitConnection.openLsp`.
     */
    openLsp(connectionId: ConnectionId, path: string, options?: LspOpenOptions): Promise<LspHandle>;
    /** CAS put into one connection's server KV store (docs/design/kv.md).
     *  See `BlitConnection.kvPut`. */
    kvPut(connectionId: ConnectionId, key: string, value: Uint8Array, options?: KvPutOptions): Promise<{
        hash: bigint;
        mtimeNs: bigint;
    }>;
    /** Delete a key from one connection's server KV store.
     *  See `BlitConnection.kvDelete`. */
    kvDelete(connectionId: ConnectionId, key: string, options?: {
        ifHash?: bigint;
    }): Promise<void>;
    /** Fetch one value from one connection's server KV store; null when
     *  absent. See `BlitConnection.kvFetch`. */
    kvFetch(connectionId: ConnectionId, key: string): Promise<KvFetchResult | null>;
    /** Watch a literal byte prefix of one connection's server KV store.
     *  See `BlitConnection.watchKv`. */
    watchKv(connectionId: ConnectionId, prefix: string, options?: KvWatchOptions): Promise<KvWatchHandle>;
    restartSession(sessionId: SessionId): void;
    killSession(sessionId: SessionId, signal?: number): void;
    focusSession(sessionId: SessionId | null): void;
    reconnectConnection(connectionId: ConnectionId): void;
    sendInput(sessionId: SessionId, data: Uint8Array): void;
    resizeSession(sessionId: SessionId, rows: number, cols: number): void;
    clearSessionSize(sessionId: SessionId): void;
    clearSessionSizes(sessionIds: Iterable<SessionId>): void;
    resizeSessions(entries: Iterable<ResizeWorkspaceSessionOptions>): void;
    scrollSession(sessionId: SessionId, offset: number): void;
    /** Move a scrolled view by `lines` instead of to a position; `offset` is
     *  the caller's idea of where that lands.  See
     *  {@link BlitConnection.scrollSessionBy}. */
    scrollSessionBy(sessionId: SessionId, offset: number, lines: number): void;
    sendMouse(sessionId: SessionId, type: number, button: number, col: number, row: number): void;
    search(query: string, scope?: {
        connectionId?: ConnectionId;
    }): Promise<BlitSearchResult[]>;
    setVisibleSessions(sessionIds: Iterable<SessionId>): void;
    /** Enable the per-frame histories used only by the UI debug pane. */
    setSurfaceDiagnosticsEnabled(enabled: boolean): void;
    getConnectionDebugStats(connectionId: ConnectionId, sessionId: SessionId | null): ReturnType<BlitConnection["getDebugStats"]> | null;
    private emit;
    private _syncingFocus;
    private recomputeSnapshot;
    private resolveFocusedSessionId;
    private requireConnection;
    private requireSession;
}
export declare function createBlitWorkspace(options: CreateBlitWorkspaceOptions): BlitWorkspace;
//# sourceMappingURL=BlitWorkspace.d.ts.map