import { LocalDatapointId, MariaDatabaseSpec, PersistentRow, Row_DatapointControlLog, Row_DatapointLog, Row_Sample, SerializableEngine } from "jm-castle-ac-dc-types";
import { InsertResponse, Table } from "jm-castle-types";
import { Pool } from "mariadb";
import { ControlContext } from "../../engines/ControlContext.mjs";
import { EngineContext } from "../../engines/EngineContext.mjs";
import { Engine } from "../../engines/Types.mjs";
import { Persistence, PersistencePart, PersistencePartRunResponse } from "../Types.mjs";
import { Filter_LoggedAt_FromTo_Seconds, Filter_NameLike } from "./query/QueryUtils.mjs";
export interface RunPartsResponse {
    duration: number;
    errors?: string[];
}
export declare const AllTables: Table[];
export interface MariaDbClientProps {
    engineId: string;
    spec: MariaDatabaseSpec;
}
export declare class MariaDbClient implements Persistence, Engine {
    constructor(props: MariaDbClientProps);
    private engineId;
    private setupPool;
    private databasePool;
    private lastStartedAt;
    private lastLapEndAt;
    private spec;
    private running;
    private shouldRun;
    private lap;
    private durations;
    private errors;
    private parts;
    private handlePoolError;
    type: () => string;
    tables: {
        sample: {
            insert: (values: Row_Sample & PersistentRow) => Promise<InsertResponse<Row_Sample>>;
            update: (values: Row_Sample & PersistentRow) => Promise<import("jm-castle-types").UpdateResponse<Row_Sample>>;
            select: (filter: Filter_NameLike) => Promise<import("jm-castle-types").SelectResponse<Row_Sample>>;
            selectByKey: (sampleId: string) => Promise<import("jm-castle-types").SelectResponse<Row_Sample>>;
            all: () => Promise<import("jm-castle-types").SelectResponse<Row_Sample>>;
        };
    };
    datapoint_log: {
        makePersistPart: (...datapoints: string[]) => {
            run: (context: EngineContext) => Promise<PersistencePartRunResponse>;
        };
        insertNow: (values: Row_DatapointLog) => Promise<InsertResponse<Row_DatapointLog>>;
        select: (filter: Filter_LoggedAt_FromTo_Seconds) => Promise<import("jm-castle-types").SelectResponse<Row_DatapointLog>>;
    };
    datapoint_control_log: {
        makePersistPart: (datapoints: Record<string, LocalDatapointId[]>) => {
            run: (context: ControlContext) => Promise<PersistencePartRunResponse>;
        };
        insertNow: (values: Row_DatapointControlLog) => Promise<InsertResponse<Row_DatapointControlLog>>;
        select: (filter: Filter_LoggedAt_FromTo_Seconds) => Promise<import("jm-castle-types").SelectResponse<Row_DatapointControlLog>>;
    };
    getDatabaseName: () => string;
    getDatabasePool: () => Pool;
    getSetupPool: () => Pool;
    addPart: (...parts: PersistencePart[]) => void;
    private runParts;
    private run;
    private waitAndCheckRunning;
    start: () => Promise<void>;
    stop: () => Promise<void>;
    disconnect: () => 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>;
}