import type { CreateLoopInput, Goal, GoalRun, Loop, LoopRun, LoopStatus, OpenAutomationsRuntimeBinding, RunReceipt, RunStatus, WriteRunReceiptInput } from "../types.js";
import { type DoctorReport } from "../lib/doctor.js";
import { type BuildHealthScanOptions, type LoopsHealthReport, type LoopsHealthScan } from "../lib/health.js";
import { type ApplyLoopsMigrationResult, type ControlPlanePlanOptions, type ExportLoopsMigrationOptions, type ImportLoopsMigrationOptions, type LoopsMigrationBundle, type LoopsMigrationPlan } from "../lib/migration.js";
import { tick } from "../lib/scheduler.js";
import { Store } from "../lib/store.js";
import { type LoopStore } from "../lib/store/index.js";
export { runGoal } from "../lib/goal/runner.js";
export { LOOPS_MIGRATION_SCHEMA, applyImportMigrationBundle, buildControlPlaneMigrationPlan, buildImportMigrationPlan, exportLoopsMigrationBundle, migrationHash, validateLoopsMigrationBundle, } from "../lib/migration.js";
export type { ApplyLoopsMigrationResult, ControlPlanePlanOptions, ExportLoopsMigrationOptions, ImportLoopsMigrationOptions, LoopsMigrationAction, LoopsMigrationBundle, LoopsMigrationPlan, LoopsMigrationPlanRow, LoopsMigrationPlanSummary, LoopsMigrationResource, } from "../lib/migration.js";
export interface LoopsClientOptions {
    /**
     * Inject an on-box sqlite {@link Store} (mainly for tests and in-process local
     * runtimes). When provided, both data and local-runtime operations run against
     * it. When omitted, the data store is resolved from the client-flip env via
     * {@link getStore} — the local sqlite store OR the hosted `/v1` API when
     * HASNA_LOOPS_API_URL and HASNA_LOOPS_API_KEY are set — so every data method
     * routes through the one Store abstraction.
     */
    store?: Store;
    /**
     * Claim owner id for inline runs. Keep the `<surface>:<pid>` shape (see
     * INLINE_RUNNER_ID_PATTERN in lib/scheduler.ts; default `sdk:<pid>`) so a
     * starting daemon can see the owner process is still alive and will not
     * reap the run's process group out from under it.
     */
    runnerId?: string;
}
export interface ListLoopsFilters {
    status?: LoopStatus;
    labels?: string[];
    limit?: number;
    /** include archived loops alongside live ones */
    includeArchived?: boolean;
    /** return only archived loops */
    archivedOnly?: boolean;
}
export interface ListRunsFilters {
    status?: RunStatus;
    labels?: string[];
    limit?: number;
}
export interface ListRunReceiptsFilters {
    loopId?: string;
    repo?: string;
    taskId?: string;
    knowledgeId?: string;
    status?: string;
    limit?: number;
}
export interface LoopMutationOptions {
    operationId: string;
    stepId: string;
    expectedRevision: string;
    approvedPlanDigest: string;
    manifestDigest: string;
    descriptorRef: string;
    descriptorDigest: string;
    dryRun?: boolean;
}
export declare class LoopsClient {
    /**
     * The resolved data store: an on-box {@link LocalStore} (sqlite) or the hosted
     * {@link ApiStore} (`/v1` + bearer key). EVERY data method routes through here,
     * so nothing silently touches the on-box island while connected to the hosted API.
     */
    readonly store: LoopStore;
    private readonly ownStore;
    private readonly runnerId;
    constructor(opts?: LoopsClientOptions);
    /**
     * The raw on-box sqlite {@link Store} for local-runtime operations that cannot
     * route over HTTP — the scheduler (tick / inline run-now), migration
     * export/import, and local diagnostics (doctor/health). These act on THIS
     * machine's runtime and database, so they fail loudly instead of silently
     * hitting the on-box island when the client is flipped to the hosted API.
     */
    private localRuntime;
    create(input: CreateLoopInput): Promise<Loop>;
    list(filters?: ListLoopsFilters): Promise<Loop[]>;
    get(idOrName: string): Promise<Loop>;
    private mutateStatus;
    pause(idOrName: string, options?: LoopMutationOptions): Promise<Loop>;
    resume(idOrName: string, options?: LoopMutationOptions): Promise<Loop>;
    stop(idOrName: string, options?: LoopMutationOptions): Promise<Loop>;
    setLabels(idOrName: string, labels: string[]): Promise<Loop>;
    addLabels(idOrName: string, labels: string[]): Promise<Loop>;
    removeLabels(idOrName: string, labels: string[]): Promise<Loop>;
    archive(idOrName: string): Promise<Loop>;
    unarchive(idOrName: string): Promise<Loop>;
    delete(idOrName: string): Promise<boolean>;
    runs(idOrName?: string, filters?: ListRunsFilters): Promise<LoopRun[]>;
    writeReceipt(input: WriteRunReceiptInput): Promise<RunReceipt>;
    receipt(runId: string): Promise<RunReceipt | undefined>;
    receipts(filters?: ListRunReceiptsFilters): Promise<RunReceipt[]>;
    goal(idOrName: string): Promise<{
        goal?: Goal;
        runs: GoalRun[];
    }>;
    doctor(): DoctorReport;
    health(opts?: {
        includeArchived?: boolean;
        includeInactive?: boolean;
        limit?: number;
    }): LoopsHealthReport;
    healthScan(opts?: Omit<BuildHealthScanOptions, "doctor" | "daemon" | "selfHeals"> & {
        doctor?: boolean;
        daemon?: boolean;
    }): LoopsHealthScan;
    tick(): Promise<Awaited<ReturnType<typeof tick>>>;
    runNow(idOrName: string): Promise<LoopRun>;
    exportBundle(opts?: ExportLoopsMigrationOptions): LoopsMigrationBundle;
    planImport(bundle: LoopsMigrationBundle, opts?: ImportLoopsMigrationOptions): LoopsMigrationPlan;
    importBundle(bundle: LoopsMigrationBundle, opts?: ImportLoopsMigrationOptions): ApplyLoopsMigrationResult;
    planControlPlaneMigration(opts?: Omit<ControlPlanePlanOptions, "operation"> & {
        operation?: ControlPlanePlanOptions["operation"];
    }): Promise<LoopsMigrationPlan>;
    close(): Promise<void>;
}
export declare function loops(opts?: LoopsClientOptions): LoopsClient;
export declare function openAutomationsRuntimeBinding(overrides?: Partial<OpenAutomationsRuntimeBinding>): OpenAutomationsRuntimeBinding;