import type { CreateLoopInput, CreateWorkflowInput, Loop, LoopRun, LoopStatus, PublicWorkflowEvent, RunReceipt, RunStatus, WorkflowInvocation, WorkflowRun, WorkflowSpec, WorkflowStepRun, WorkflowWorkItem, WorkflowWorkItemStatus, WriteRunReceiptInput } from "../../types.js";
import { type PublicLoopMutationResult, LoopMutationEnvelope, LoopMutationLookupCaps } from "../operation-contract.js";
import type { Goal, GoalPlanNode, GoalRun, GoalStatus } from "../goal/types.js";
import type { HasnaStorageClient } from "@hasna/contracts/client/storage";
type Env = Record<string, string | undefined>;
import { Store } from "../store.js";
import type { PruneHistoryOptions, PruneHistorySummary } from "../store.js";
/** Which transport backs a resolved store (for banners/diagnostics only). */
export type StoreTransport = "file" | "api";
export interface StuckRunCandidate {
    runId: string;
    loopId: string;
    snapshotId: string;
}
export interface StuckRunCandidateReport {
    state: "clear" | "stuck";
    expiredBefore: string;
    candidates: StuckRunCandidate[];
    truncated: boolean;
}
export interface StuckRunReconciliationOutcome {
    runId: string;
    outcome: "recovered" | "already_recovered" | "conflict" | "operation_reconciliation_required";
    reason?: string;
}
export interface StuckRunReconciliationReport {
    outcomes: StuckRunReconciliationOutcome[];
}
/**
 * Thrown when a command routed through the API store hits an operation that
 * the control-plane `/v1` API does not yet expose. Failing loudly here is
 * deliberate: the alternative (silently reading/writing the on-box sqlite
 * island while the machine is connected to a control plane) is exactly the
 * split-brain bug we are removing.
 */
export declare class CloudUnsupportedError extends Error {
    constructor(operation: string);
}
/**
 * The single data interface for the Loops client. Both {@link LocalStore}
 * and {@link ApiStore} implement it; callers hold a `LoopStore` and never know
 * (or branch on) which one. Every method is async so the two transports share
 * one surface.
 */
export interface LoopStore {
    readonly transport: StoreTransport;
    close(): Promise<void>;
    createLoop(input: CreateLoopInput, from?: Date): Promise<Loop>;
    getLoop(id: string): Promise<Loop | undefined>;
    findLoopByName(name: string): Promise<Loop | undefined>;
    requireLoop(idOrName: string): Promise<Loop>;
    requireUniqueLoop(idOrName: string): Promise<Loop>;
    listLoops(opts?: {
        status?: LoopStatus;
        labels?: string[];
        limit?: number;
        offset?: number;
        archived?: boolean;
        includeArchived?: boolean;
        name?: string;
    }): Promise<Loop[]>;
    countLoops(status?: LoopStatus, opts?: {
        archived?: boolean;
        includeArchived?: boolean;
    }): Promise<number>;
    updateLoop(id: string, patch: Partial<Pick<Loop, "status" | "nextRunAt" | "retryScheduledFor" | "expiresAt" | "labels" | "maxAttempts">>): Promise<Loop>;
    mutateLoop(envelope: LoopMutationEnvelope): Promise<PublicLoopMutationResult>;
    getLoopMutationResult(operationId: string, stepId: string, caps: LoopMutationLookupCaps): Promise<PublicLoopMutationResult | undefined>;
    renameLoop(id: string, name: string): Promise<Loop>;
    archiveLoop(idOrName: string): Promise<Loop>;
    unarchiveLoop(idOrName: string): Promise<Loop>;
    deleteLoop(idOrName: string): Promise<boolean>;
    createWorkflow(input: CreateWorkflowInput): Promise<WorkflowSpec>;
    getWorkflow(id: string): Promise<WorkflowSpec | undefined>;
    findWorkflowByName(name: string): Promise<WorkflowSpec | undefined>;
    requireWorkflow(idOrName: string): Promise<WorkflowSpec>;
    listWorkflows(opts?: {
        status?: WorkflowSpec["status"];
        limit?: number;
        offset?: number;
    }): Promise<WorkflowSpec[]>;
    countWorkflows(opts?: {
        status?: WorkflowSpec["status"];
    }): Promise<number>;
    archiveWorkflow(idOrName: string): Promise<WorkflowSpec>;
    getWorkflowRun(id: string): Promise<WorkflowRun | undefined>;
    requireWorkflowRun(id: string): Promise<WorkflowRun>;
    listWorkflowRuns(opts?: {
        workflowId?: string;
        loopRunId?: string;
        limit?: number;
    }): Promise<WorkflowRun[]>;
    listWorkflowStepRuns(workflowRunId: string): Promise<WorkflowStepRun[]>;
    listWorkflowEvents(workflowRunId: string, limit?: number): Promise<PublicWorkflowEvent[]>;
    recoverWorkflowRun(workflowRunId: string, reason?: string): Promise<{
        run: WorkflowRun;
        recoveredSteps: WorkflowStepRun[];
    }>;
    cancelWorkflowRun(workflowRunId: string, reason?: string): Promise<WorkflowRun>;
    listWorkflowWorkItems(opts?: {
        status?: WorkflowWorkItemStatus;
        routeKey?: string;
        limit?: number;
    }): Promise<WorkflowWorkItem[]>;
    getWorkflowWorkItem(id: string): Promise<WorkflowWorkItem | undefined>;
    requeueWorkflowWorkItem(id: string, patch?: {
        reason?: string;
        resetAttempts?: boolean;
    }): Promise<WorkflowWorkItem>;
    listWorkflowInvocations(opts?: {
        limit?: number;
    }): Promise<WorkflowInvocation[]>;
    getWorkflowInvocation(id: string): Promise<WorkflowInvocation | undefined>;
    getGoal(id: string): Promise<Goal | undefined>;
    findGoalByLoop(idOrName: string): Promise<Goal | undefined>;
    findGoalByRunId(id: string): Promise<Goal | undefined>;
    listGoals(opts?: {
        status?: GoalStatus;
        limit?: number;
    }): Promise<Goal[]>;
    listGoalPlanNodes(goalIdOrPlanId: string): Promise<GoalPlanNode[]>;
    listGoalRuns(opts?: {
        goalId?: string;
        runId?: string;
        limit?: number;
    }): Promise<GoalRun[]>;
    listRuns(opts?: {
        loopId?: string;
        status?: RunStatus;
        labels?: string[];
        limit?: number;
        offset?: number;
    }): Promise<LoopRun[]>;
    countRuns(opts?: {
        loopId?: string;
        status?: RunStatus;
        labels?: string[];
    }): Promise<number>;
    getRun(id: string): Promise<LoopRun | undefined>;
    writeRunReceipt(input: WriteRunReceiptInput): Promise<RunReceipt>;
    getRunReceipt(runId: string): Promise<RunReceipt | undefined>;
    listRunReceipts(opts?: {
        loopId?: string;
        repo?: string;
        taskId?: string;
        knowledgeId?: string;
        status?: string;
        limit?: number;
    }): Promise<RunReceipt[]>;
    listStuckRunCandidates(opts?: {
        expiredBefore?: string;
        limit?: number;
    }): Promise<StuckRunCandidateReport>;
    reconcileStuckRunCandidates(candidates: StuckRunCandidate[]): Promise<StuckRunReconciliationReport>;
    pruneHistory(opts: PruneHistoryOptions): Promise<PruneHistorySummary>;
}
/**
 * On-box SQLite transport. Wraps a single {@link Store} and awaits its
 * synchronous methods so callers see the async {@link LoopStore} surface.
 */
export declare class LocalStore implements LoopStore {
    readonly transport: "file";
    private readonly store;
    constructor(store?: Store);
    /**
     * The underlying on-box sqlite {@link Store}. Exposed ONLY for genuinely
     * local-runtime operations that cannot route over HTTP — the scheduler
     * (tick/run-now inline execution), migration import/export, and local
     * diagnostics (doctor/health/daemon status). Callers must gate on
     * `transport === "file"` first; the hosted ApiStore has no `raw` store, so
     * these operations fail loudly on the API connection instead of touching an
     * island.
     */
    get raw(): Store;
    close(): Promise<void>;
    createLoop(input: CreateLoopInput, from?: Date): Promise<Loop>;
    getLoop(id: string): Promise<Loop | undefined>;
    findLoopByName(name: string): Promise<Loop | undefined>;
    requireLoop(idOrName: string): Promise<Loop>;
    requireUniqueLoop(idOrName: string): Promise<Loop>;
    listLoops(opts?: Parameters<Store["listLoops"]>[0]): Promise<Loop[]>;
    countLoops(status?: LoopStatus, opts?: {
        archived?: boolean;
        includeArchived?: boolean;
    }): Promise<number>;
    updateLoop(id: string, patch: Partial<Pick<Loop, "status" | "nextRunAt" | "retryScheduledFor" | "expiresAt" | "labels" | "maxAttempts">>): Promise<Loop>;
    mutateLoop(envelope: LoopMutationEnvelope): Promise<PublicLoopMutationResult>;
    getLoopMutationResult(operationId: string, stepId: string, caps: LoopMutationLookupCaps): Promise<PublicLoopMutationResult | undefined>;
    renameLoop(id: string, name: string): Promise<Loop>;
    archiveLoop(idOrName: string): Promise<Loop>;
    unarchiveLoop(idOrName: string): Promise<Loop>;
    deleteLoop(idOrName: string): Promise<boolean>;
    createWorkflow(input: CreateWorkflowInput): Promise<WorkflowSpec>;
    getWorkflow(id: string): Promise<WorkflowSpec | undefined>;
    findWorkflowByName(name: string): Promise<WorkflowSpec | undefined>;
    requireWorkflow(idOrName: string): Promise<WorkflowSpec>;
    listWorkflows(opts?: Parameters<Store["listWorkflows"]>[0]): Promise<WorkflowSpec[]>;
    countWorkflows(opts?: {
        status?: WorkflowSpec["status"];
    }): Promise<number>;
    archiveWorkflow(idOrName: string): Promise<WorkflowSpec>;
    getWorkflowRun(id: string): Promise<WorkflowRun | undefined>;
    requireWorkflowRun(id: string): Promise<WorkflowRun>;
    listWorkflowRuns(opts?: Parameters<Store["listWorkflowRuns"]>[0]): Promise<WorkflowRun[]>;
    listWorkflowStepRuns(workflowRunId: string): Promise<WorkflowStepRun[]>;
    listWorkflowEvents(workflowRunId: string, limit?: number): Promise<PublicWorkflowEvent[]>;
    recoverWorkflowRun(workflowRunId: string, reason?: string): Promise<{
        run: WorkflowRun;
        recoveredSteps: WorkflowStepRun[];
    }>;
    cancelWorkflowRun(workflowRunId: string, reason?: string): Promise<WorkflowRun>;
    listWorkflowWorkItems(opts?: Parameters<Store["listWorkflowWorkItems"]>[0]): Promise<WorkflowWorkItem[]>;
    getWorkflowWorkItem(id: string): Promise<WorkflowWorkItem | undefined>;
    requeueWorkflowWorkItem(id: string, patch?: {
        reason?: string;
        resetAttempts?: boolean;
    }): Promise<WorkflowWorkItem>;
    listWorkflowInvocations(opts?: Parameters<Store["listWorkflowInvocations"]>[0]): Promise<WorkflowInvocation[]>;
    getWorkflowInvocation(id: string): Promise<WorkflowInvocation | undefined>;
    getGoal(id: string): Promise<Goal | undefined>;
    findGoalByLoop(idOrName: string): Promise<Goal | undefined>;
    findGoalByRunId(id: string): Promise<Goal | undefined>;
    listGoals(opts?: Parameters<Store["listGoals"]>[0]): Promise<Goal[]>;
    listGoalPlanNodes(goalIdOrPlanId: string): Promise<GoalPlanNode[]>;
    listGoalRuns(opts?: Parameters<Store["listGoalRuns"]>[0]): Promise<GoalRun[]>;
    listRuns(opts?: Parameters<Store["listRuns"]>[0]): Promise<LoopRun[]>;
    countRuns(opts?: Parameters<LoopStore["countRuns"]>[0]): Promise<number>;
    getRun(id: string): Promise<LoopRun | undefined>;
    writeRunReceipt(input: WriteRunReceiptInput): Promise<RunReceipt>;
    getRunReceipt(runId: string): Promise<RunReceipt | undefined>;
    listRunReceipts(opts?: Parameters<Store["listRunReceipts"]>[0]): Promise<RunReceipt[]>;
    listStuckRunCandidates(opts?: {
        expiredBefore?: string;
        limit?: number;
    }): Promise<StuckRunCandidateReport>;
    reconcileStuckRunCandidates(candidates: StuckRunCandidate[]): Promise<StuckRunReconciliationReport>;
    pruneHistory(opts: PruneHistoryOptions): Promise<PruneHistorySummary>;
}
export declare class HostedResponseShapeError extends Error {
    constructor(key: string);
}
/**
 * API transport: routes every read+write through the hosted `/v1` API. Loop/name
 * resolution (requireLoop/requireUniqueLoop/find*) is done client-side by
 * listing and matching, mirroring the local Store behaviour, so a server that
 * ignores a name filter can never return the wrong row.
 */
export declare class ApiStore implements LoopStore {
    private readonly client;
    readonly baseUrl: string;
    readonly transport: "api";
    constructor(client: HasnaStorageClient, baseUrl: string);
    private get t();
    close(): Promise<void>;
    createLoop(input: CreateLoopInput): Promise<Loop>;
    getLoop(id: string): Promise<Loop | undefined>;
    findLoopByName(name: string): Promise<Loop | undefined>;
    requireLoop(idOrName: string): Promise<Loop>;
    requireUniqueLoop(idOrName: string): Promise<Loop>;
    private resolveLoop;
    listLoops(opts?: Parameters<LoopStore["listLoops"]>[0]): Promise<Loop[]>;
    countLoops(status?: LoopStatus, opts?: {
        archived?: boolean;
        includeArchived?: boolean;
    }): Promise<number>;
    updateLoop(id: string, patch: Partial<Pick<Loop, "status" | "nextRunAt" | "retryScheduledFor" | "expiresAt" | "labels" | "maxAttempts">>): Promise<Loop>;
    mutateLoop(envelope: LoopMutationEnvelope): Promise<PublicLoopMutationResult>;
    getLoopMutationResult(operationId: string, stepId: string, caps: LoopMutationLookupCaps): Promise<PublicLoopMutationResult | undefined>;
    renameLoop(id: string, name: string): Promise<Loop>;
    archiveLoop(idOrName: string): Promise<Loop>;
    unarchiveLoop(idOrName: string): Promise<Loop>;
    private mutateArchiveState;
    deleteLoop(idOrName: string): Promise<boolean>;
    createWorkflow(input: CreateWorkflowInput): Promise<WorkflowSpec>;
    getWorkflow(id: string): Promise<WorkflowSpec | undefined>;
    findWorkflowByName(name: string): Promise<WorkflowSpec | undefined>;
    requireWorkflow(idOrName: string): Promise<WorkflowSpec>;
    listWorkflows(opts?: Parameters<LoopStore["listWorkflows"]>[0]): Promise<WorkflowSpec[]>;
    countWorkflows(opts?: {
        status?: WorkflowSpec["status"];
    }): Promise<number>;
    archiveWorkflow(idOrName: string): Promise<WorkflowSpec>;
    getWorkflowRun(id: string): Promise<WorkflowRun | undefined>;
    requireWorkflowRun(id: string): Promise<WorkflowRun>;
    listWorkflowRuns(opts?: Parameters<LoopStore["listWorkflowRuns"]>[0]): Promise<WorkflowRun[]>;
    listWorkflowStepRuns(workflowRunId: string): Promise<WorkflowStepRun[]>;
    listWorkflowEvents(workflowRunId: string, limit?: number): Promise<PublicWorkflowEvent[]>;
    recoverWorkflowRun(workflowRunId: string, reason?: string): Promise<{
        run: WorkflowRun;
        recoveredSteps: WorkflowStepRun[];
    }>;
    cancelWorkflowRun(_workflowRunId: string, _reason?: string): Promise<WorkflowRun>;
    listWorkflowWorkItems(opts?: Parameters<LoopStore["listWorkflowWorkItems"]>[0]): Promise<WorkflowWorkItem[]>;
    getWorkflowWorkItem(id: string): Promise<WorkflowWorkItem | undefined>;
    requeueWorkflowWorkItem(_id: string, _patch?: {
        reason?: string;
        resetAttempts?: boolean;
    }): Promise<WorkflowWorkItem>;
    listWorkflowInvocations(opts?: Parameters<LoopStore["listWorkflowInvocations"]>[0]): Promise<WorkflowInvocation[]>;
    getWorkflowInvocation(id: string): Promise<WorkflowInvocation | undefined>;
    getGoal(id: string): Promise<Goal | undefined>;
    findGoalByLoop(idOrName: string): Promise<Goal | undefined>;
    findGoalByRunId(id: string): Promise<Goal | undefined>;
    listGoals(opts?: Parameters<LoopStore["listGoals"]>[0]): Promise<Goal[]>;
    listGoalPlanNodes(goalIdOrPlanId: string): Promise<GoalPlanNode[]>;
    listGoalRuns(opts?: Parameters<LoopStore["listGoalRuns"]>[0]): Promise<GoalRun[]>;
    listRuns(opts?: Parameters<LoopStore["listRuns"]>[0]): Promise<LoopRun[]>;
    countRuns(opts?: Parameters<LoopStore["countRuns"]>[0]): Promise<number>;
    getRun(id: string): Promise<LoopRun | undefined>;
    writeRunReceipt(input: WriteRunReceiptInput): Promise<RunReceipt>;
    getRunReceipt(runId: string): Promise<RunReceipt | undefined>;
    listRunReceipts(opts?: Parameters<LoopStore["listRunReceipts"]>[0]): Promise<RunReceipt[]>;
    listStuckRunCandidates(opts?: {
        expiredBefore?: string;
        limit?: number;
    }): Promise<StuckRunCandidateReport>;
    reconcileStuckRunCandidates(candidates: StuckRunCandidate[]): Promise<StuckRunReconciliationReport>;
    pruneHistory(opts: PruneHistoryOptions): Promise<PruneHistorySummary>;
}
/**
 * Resolve the client store for the current environment: an {@link ApiStore} when
 * the connection contract resolves to the HTTP transport (API URL + API key
 * set), else a {@link LocalStore}. Callers hold a {@link LoopStore} and never
 * branch on connection.
 */
export declare function getStore(env?: Env): LoopStore;
/** True when the resolved store is the control-plane HTTP transport. */
export declare function isCloudStore(env?: Env): boolean;
export {};