import type { ConfigManager } from '../config/manager.js';
import type { ProviderRegistry } from '../providers/registry.js';
import type { CreateDaemonBatchJobInput, DaemonBatchJob, DaemonBatchRuntimeSnapshot, DaemonBatchTickResult } from './types.js';
export declare class DaemonBatchManager {
    private readonly options;
    private readonly store;
    private data;
    private interval;
    private ticking;
    /** Whole-store writes run one at a time, in call order. See StoreWriteQueue. */
    private readonly writes;
    constructor(options: {
        readonly configManager: Pick<ConfigManager, 'get' | 'getControlPlaneConfigDir'>;
        readonly providerRegistry: Pick<ProviderRegistry, 'getCurrentModel' | 'getForModel' | 'getRegistered' | 'listProviders'>;
        readonly storePath?: string | undefined;
    });
    start(): void;
    dispose(): void;
    describeRuntime(): Promise<DaemonBatchRuntimeSnapshot>;
    createJob(input: CreateDaemonBatchJobInput): Promise<DaemonBatchJob>;
    getJob(jobId: string): Promise<DaemonBatchJob | null>;
    listJobs(limit?: number): Promise<readonly DaemonBatchJob[]>;
    cancelJob(jobId: string): Promise<DaemonBatchJob>;
    tick(options?: {
        readonly forceSubmit?: boolean;
    }): Promise<DaemonBatchTickResult>;
    private runTick;
    private submitQueuedJobs;
    private submitProviderBatch;
    private pollProviderBatches;
    private applyProviderResults;
    private getBatchProvider;
    private requireProviderBatchSupport;
    private load;
    /**
     * Write the job store, after every write already queued has finished.
     *
     * `PersistentStore.persist` is atomic but unordered, and two of these are in
     * flight at once on the ordinary path: `tick` writes at the end of a pass
     * that begins with a network round trip to the provider, and `cancelJob`
     * writes the moment an operator cancels. Unordered, the tick's rename could
     * land last and put its view of the job, 'queued', captured before the
     * cancel, back on disk. After a restart the cancelled job reads back as
     * queued, and the next tick submits it to the provider, which is a paid
     * request the operator explicitly called off.
     *
     * `this.data` is the live store object rather than a copy, and that is
     * unchanged here: `PersistentStore.persist` serialises it when the write
     * RUNS, so each queued write emits a view at least as new as the one before
     * it and the last to land is the most recent. What was missing was only the
     * order.
     */
    private persist;
    private getMode;
    private getFallback;
    private getQueueBackend;
    private getNumberConfig;
    private getBooleanConfig;
    private getStringConfig;
}
//# sourceMappingURL=manager.d.ts.map