import { MariaInterface } from "jm-castle-mariadb";
import { InsertResponse, SelectResponse, Table, UpdateResponse } from "jm-castle-types";
import { DbExportData, DbImportData, ErrorCode, MariaDatabaseSpec, PersistentRow, Row_Article, Row_Attribute, Row_Costunit, Row_Emission, Row_Hashtag, Row_ImageContent, Row_ImageReference, Row_Manufacturer, Row_Receipt, Row_Receiver, Row_Store, Row_StoreSection } from "jm-castle-warehouse-types";
import { Pool } from "mariadb";
import { AggregationFunction, MasterdataInsertOptions, MasterdataUpdateOptions, Persistence, StockdataInsertOptions, TableRowsChangeConsumer } from "../Types.mjs";
import { Filter_At_FromTo_Seconds, Filter_Hashtag, Filter_ImageExtension, Filter_ImageId, Filter_NameLike, Filter_Reference } from "./query/QueryUtils.mjs";
export interface RunPartsResponse {
    duration: number;
    errors?: string[];
}
export declare const MasterdataTables: {
    [x: string]: Table;
};
export declare const AllTables: Table[];
export interface MariaDbClientProps {
    persistenceId: string;
    spec: MariaDatabaseSpec;
}
export declare class MariaDbClient implements Persistence, MariaInterface {
    constructor(props: MariaDbClientProps);
    version: string;
    private setupPool;
    private databasePool;
    private tableStats;
    private tableRowsChangeConsumers;
    private spec;
    private handlePoolError;
    type: () => string;
    getDatabaseName: () => string;
    getDatabasePool: () => Pool;
    getSetupPool: () => Pool;
    getTableStats: (tableId: string) => {
        countOfRows?: number;
        lastChangeAt?: number;
    };
    addTableRowsChangeConsumer: (consumer: TableRowsChangeConsumer) => void;
    removeTableRowsChangeConsumer: (consumer: TableRowsChangeConsumer) => void;
    changedTableStats: (tableId: string, updates: {
        countOfRows?: number;
        lastChangeAt?: number;
    }) => void;
    countOfRowsForTable: (tableId: string, countOfRows: number) => void;
    private exportSingleTableData;
    private importSingleTableStockdata;
    private importSingleTableMasterdata;
    exportTableData: () => Promise<{
        tables: DbExportData["tables"];
    } | {
        error: string;
        errorCode: ErrorCode;
    }>;
    importTableData: (tables: DbExportData["tables"]) => Promise<(DbImportData & {
        error?: never;
        errorCode?: never;
    }) | {
        error: string;
        errorCode: ErrorCode;
        tables?: never;
    }>;
    tables: {
        stats: {
            countOfRowsForTables: (...tables: Table[]) => Promise<import("jm-castle-types").FindResponse<{
                table: string;
                countOfRows: number;
                lastChangeAt: number;
            }>[]>;
        };
        pagination: {
            selectPage: <T extends Partial<Record<string, unknown>>>(table: Table, page: number, pageSize: number) => Promise<SelectResponse<T>>;
        };
        masterdata: {
            selectEditedAtFromTo: (source: keyof typeof MasterdataTables, filter: Filter_At_FromTo_Seconds) => Promise<SelectResponse<import("jm-castle-warehouse-types").Row_Masterdata>>;
        };
        imageReference: {
            insert: (values: Row_ImageReference & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_ImageReference>>;
            update: (values: Row_ImageReference & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_ImageReference>>;
            updateImageReferences: (reference: string, previous: string | null, current: string | null) => Promise<import("jm-castle-types").BatchResponse>;
            insertImageReferences: (reference: string, current: string | null) => Promise<import("jm-castle-types").BatchResponse>;
            select: (filter: Filter_ImageId | Filter_Reference) => Promise<SelectResponse<Row_ImageReference>>;
            all: () => Promise<SelectResponse<Row_ImageReference>>;
        };
        imageContent: {
            insert: (values: Row_ImageContent & PersistentRow, options?: MasterdataInsertOptions) => Promise<UpdateResponse<Row_ImageContent>>;
            update: (values: Row_ImageContent & PersistentRow, options?: MasterdataUpdateOptions) => Promise<InsertResponse<Row_ImageContent>>;
            select: (filter: Filter_ImageId | Filter_ImageExtension) => Promise<SelectResponse<Row_ImageContent>>;
            selectLikeImageId: (filter: Filter_ImageId) => Promise<SelectResponse<Row_ImageContent>>;
            all: () => Promise<SelectResponse<Row_ImageContent>>;
        };
        attribute: {
            insert: (values: Row_Attribute & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Attribute>>;
            update: (values: Row_Attribute & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Attribute>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_Attribute>>;
            selectByKey: (attributeId: string) => Promise<SelectResponse<Row_Attribute>>;
            all: () => Promise<SelectResponse<Row_Attribute>>;
        };
        store: {
            insert: (values: Row_Store & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Store>>;
            update: (values: Row_Store & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Store>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_Store>>;
            selectByKey: (storeId: string) => Promise<SelectResponse<Row_Store>>;
            all: () => Promise<SelectResponse<Row_Store>>;
        };
        storeSection: {
            insert: (values: Row_StoreSection & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_StoreSection>>;
            update: (values: Row_StoreSection & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_StoreSection>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_StoreSection>>;
            selectByKey: (sectionId: string) => Promise<import("jm-castle-types").FindResponse<Row_StoreSection>>;
            all: () => Promise<SelectResponse<Row_StoreSection>>;
        };
        article: {
            insert: (values: Row_Article & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Article>>;
            update: (values: Row_Article & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Article>>;
            select: (filter: Filter_NameLike & Partial<Filter_Hashtag>) => Promise<SelectResponse<Row_Article>>;
            selectByKey: (articleId: string) => Promise<import("jm-castle-types").FindResponse<Row_Article>>;
            all: () => Promise<SelectResponse<Row_Article>>;
        };
        hashtag: {
            insert: (values: Row_Hashtag & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Hashtag>>;
            update: (values: Row_Hashtag & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Hashtag>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_Hashtag>>;
            selectByKey: (articleId: string) => Promise<SelectResponse<Row_Hashtag>>;
            all: () => Promise<SelectResponse<Row_Hashtag>>;
        };
        costunit: {
            insert: (values: Row_Costunit & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Costunit>>;
            update: (values: Row_Costunit & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Costunit>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_Costunit>>;
            selectByKey: (articleId: string) => Promise<SelectResponse<Row_Costunit>>;
            all: () => Promise<SelectResponse<Row_Costunit>>;
        };
        receiver: {
            insert: (values: Row_Receiver & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Receiver>>;
            update: (values: Row_Receiver & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Receiver>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_Receiver>>;
            selectByKey: (articleId: string) => Promise<SelectResponse<Row_Receiver>>;
            all: () => Promise<SelectResponse<Row_Receiver>>;
        };
        manufacturer: {
            insert: (values: Row_Manufacturer & PersistentRow, options?: MasterdataInsertOptions) => Promise<InsertResponse<Row_Manufacturer>>;
            update: (values: Row_Manufacturer & PersistentRow, options?: MasterdataUpdateOptions) => Promise<UpdateResponse<Row_Manufacturer>>;
            select: (filter: Filter_NameLike) => Promise<SelectResponse<Row_Manufacturer>>;
            selectByKey: (articleId: string) => Promise<SelectResponse<Row_Manufacturer>>;
            all: () => Promise<SelectResponse<Row_Manufacturer>>;
        };
        receipt: {
            insert: (values: Row_Receipt & PersistentRow, options?: StockdataInsertOptions) => Promise<InsertResponse<Row_Receipt>>;
            select: (filter: Filter_At_FromTo_Seconds) => Promise<SelectResponse<Row_Receipt>>;
            selectBySectionAndArticle: (sectionId: string, articleId: string) => Promise<SelectResponse<Row_Receipt>>;
            selectGroupBy: (filter: Filter_At_FromTo_Seconds, groupBy: Array<keyof Row_Receipt>, aggregate: Array<{
                col: keyof Row_Receipt;
                fn: AggregationFunction;
            }>) => Promise<SelectResponse<Partial<Row_Receipt>>>;
            all: () => Promise<SelectResponse<Row_Receipt>>;
        };
        emission: {
            insert: (values: Row_Emission & PersistentRow, options?: StockdataInsertOptions) => Promise<InsertResponse<Row_Emission>>;
            select: (filter: Filter_At_FromTo_Seconds) => Promise<SelectResponse<Row_Emission>>;
            selectGroupBy: (filter: Filter_At_FromTo_Seconds, groupBy: Array<keyof Row_Emission>, aggregate: Array<{
                col: keyof Row_Emission;
                fn: AggregationFunction;
            }>) => Promise<SelectResponse<Partial<Row_Emission>>>;
            all: () => Promise<SelectResponse<Row_Emission>>;
        };
    };
    disconnect: () => Promise<void>;
}