import type { HandoffSummary, LiveActivityItem, SessionTreeResponse } from "../../types.js";
import type { RuntimeInstanceRecord } from "../../runtime-instance-store.js";
import type { OutboxSummary } from "../../outbox.js";
import type { ChatThreadSummary } from "../../chat-store.js";
import type { AgentLaunchContext, RunLaunchContext } from "../../agent-context-store.js";
import type { Router } from "../router.js";
type LocalSnapshot = Awaited<ReturnType<typeof import("../../local-openclaw.js").loadLocalOpenClawSnapshot>>;
type AgentContextState = {
    agents: Record<string, AgentLaunchContext>;
    runs?: Record<string, RunLaunchContext>;
};
type SnapshotPersistState = {
    lastFingerprint: string;
    lastPersistAt: number;
};
type LiveSnapshotRoutesDeps<TReq, TRes> = {
    parsePositiveInt: (raw: string | null, fallback: number, max?: number) => number;
    readSnapshotResponseCache: (key: string, options?: {
        allowStale?: boolean;
    }) => Record<string, unknown> | null;
    writeSnapshotResponseCache: (key: string, payload: Record<string, unknown>) => void;
    getSnapshotCacheGeneration: () => number;
    safeErrorMessage: (err: unknown) => string;
    readAgentContexts: () => AgentContextState;
    getScopedAgentIds: (contexts: Record<string, AgentLaunchContext>) => Set<string>;
    readDiagnosticsOutboxStatus: () => Promise<Record<string, unknown> | null>;
    readOutboxSummary: () => Promise<OutboxSummary>;
    readOutboxItems: () => Promise<LiveActivityItem[]>;
    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
    toLocalSessionTree: (snapshot: LocalSnapshot, limit?: number) => SessionTreeResponse;
    toLocalLiveActivity: (snapshot: LocalSnapshot, limit?: number) => Promise<{
        activities: LiveActivityItem[];
        total: number;
    }>;
    toLocalLiveAgents: (snapshot: LocalSnapshot) => {
        agents: Array<{
            initiativeId: string | null;
            status: string;
        } & Record<string, unknown>>;
    };
    getLiveSessions: (input: {
        initiative: string | null;
        projectId: string | null;
        limit: number;
    }) => Promise<SessionTreeResponse>;
    getLiveActivity: (input: {
        run: string | null;
        since: string | null;
        projectId: string | null;
        limit: number;
    }) => Promise<{
        activities: LiveActivityItem[];
    }>;
    getHandoffs: () => Promise<{
        handoffs: HandoffSummary[];
    }>;
    getLiveDecisions: (input: {
        status: string;
        projectId: string | null;
        limit: number;
    }) => Promise<{
        decisions: unknown[];
    }>;
    getLiveAgents: (input: {
        initiative: string | null;
        projectId: string | null;
        includeIdle: boolean | undefined;
    }) => Promise<{
        agents?: unknown[];
    }>;
    listInitiativeIdsForProject: (input: {
        projectId: string;
    }) => Promise<string[]>;
    mapDecisionEntity: (entry: unknown) => Record<string, unknown> & {
        waitingMinutes: number;
    };
    applyAgentContextsToSessionTree: (input: SessionTreeResponse, contexts: {
        agents: Record<string, AgentLaunchContext>;
        runs: Record<string, RunLaunchContext>;
    }) => SessionTreeResponse;
    applyAgentContextsToActivity: (input: LiveActivityItem[], contexts: {
        agents: Record<string, AgentLaunchContext>;
        runs: Record<string, RunLaunchContext>;
    }) => LiveActivityItem[];
    mergeSessionTrees: (base: SessionTreeResponse, extra: SessionTreeResponse) => SessionTreeResponse;
    mergeActivities: (base: LiveActivityItem[], extra: LiveActivityItem[], limit: number) => LiveActivityItem[];
    semanticActivityKey: (item: LiveActivityItem) => string | null;
    listRuntimeInstances: (input: {
        limit: number;
    }) => RuntimeInstanceRecord[];
    injectRuntimeInstancesAsSessions: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
    enrichSessionsWithRuntime: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
    enrichActivityWithRuntime: (input: LiveActivityItem[], instances: RuntimeInstanceRecord[]) => LiveActivityItem[];
    snapshotActivityFingerprint: (items: LiveActivityItem[]) => string;
    appendActivityItems: (items: LiveActivityItem[]) => void;
    snapshotActivityPersistMinIntervalMs: number;
    readSnapshotPersistState: () => SnapshotPersistState;
    writeSnapshotPersistState: (state: SnapshotPersistState) => void;
    parseJsonRequest?: (req: TReq) => Promise<Record<string, unknown>>;
    buildNextUpQueue?: (input: {
        initiativeId?: string | null;
        projectId?: string | null;
    }) => Promise<{
        items: Array<Record<string, unknown>>;
        degraded: string[];
    }>;
    bulkDecideDecisions?: (ids: string[], action: "approve" | "reject", input?: {
        note?: string;
        optionId?: string;
    }) => Promise<Array<{
        id?: string;
        ok?: boolean;
        error?: string;
    }>>;
    emitDecisionResolvedActivity?: (input: {
        ids: string[];
        action: "approve" | "reject";
        note?: string | null;
        optionId?: string | null;
        sliceRunId?: string | null;
        initiativeId?: string | null;
    }) => Promise<void>;
    runAction?: (runId: string, action: "pause" | "resume" | "cancel" | "rollback", input?: {
        checkpointId?: string;
        reason?: string;
    }) => Promise<unknown>;
    listChatThreads?: (input: {
        commandCenterId?: string | null;
        initiativeId?: string | null;
        limit?: number;
        offset?: number;
    }) => {
        threads: ChatThreadSummary[];
        total: number;
        updatedAt: string;
    };
    getCanonicalAutopilotState?: (initiativeId: string) => {
        state: "idle" | "running" | "blocked" | "stopping";
        reason: string | null;
        activeRunId: string | null;
        activeWorkstreamId: string | null;
        activeWorkstreamTitle: string | null;
        queueHeadTitle: string | null;
        lastTransitionAt: string;
    } | null;
    sendJson: (res: TRes, status: number, payload: unknown) => void;
    securityHeaders: Record<string, string>;
    corsHeaders: Record<string, string>;
};
export declare function registerLiveSnapshotRoutes<TReq extends {
    on?: (event: string, listener: () => void) => void;
}, TRes extends {
    write?: (chunk: string | Buffer) => boolean | void;
    end: (chunk?: string | Buffer) => void;
    writeHead: (statusCode: number, headers?: Record<string, string>) => unknown;
    writableEnded?: boolean;
    on?: (event: string, listener: () => void) => void;
    once?: (event: string, listener: () => void) => void;
}>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TReq, TRes>): void;
export {};