import { SerializableEngine } from "jm-castle-ac-dc-types";
import { Persistence } from "../../persistence/Types.mjs";
import { ControlContext } from "../ControlContext.mjs";
import { EngineContext } from "../EngineContext.mjs";
import { ControlContextConsumer, Engine, EngineContextConsumer } from "../Types.mjs";
import { PersistPart } from "./Types.mjs";
export interface RunPartsResponse {
    duration: number;
    errors?: string[];
}
export interface PersistEngineProps {
    engineId: string;
    persistences: Record<string, Persistence>;
    parts?: {
        onEngineContext?: PersistPart<EngineContext>[];
        onControlContext?: PersistPart<ControlContext>[];
    };
}
export declare class PersistEngine implements Engine, EngineContextConsumer, ControlContextConsumer {
    constructor(props: PersistEngineProps);
    private engineId;
    private persistences;
    private lastStartedAt;
    private lastLapEndAt;
    private running;
    private shouldRun;
    private lap;
    private durations;
    private errors;
    private parts;
    private runPartsOnEngineContext;
    private runPartsOnControlContext;
    private lapEnd;
    private runOnEngineContext;
    private runOnControlContext;
    onContextChange: (context: EngineContext) => Promise<void>;
    onControlContextChange: (context: ControlContext) => Promise<void>;
    private waitAndCheckRunning;
    start: () => Promise<void>;
    stop: () => Promise<void>;
    status: () => Promise<{
        lastStartedAt: number;
        lastLapEndAt: number;
        running: boolean;
        duration: {
            laps: number;
            consumed: {
                total: number;
                lapStart: number;
                lapEnd: number;
            };
        };
        errors: {
            lap: number;
            errors: string[];
        }[];
    }>;
    settings: () => Promise<{
        lapDuration: number;
    }>;
    getSerializable: () => Promise<SerializableEngine>;
}