import { Logger } from "@libp2p/logger";
import { Awaitable } from "@canvas-js/utils";
import { Config } from "./config.js";
import { ModelValue, Effect, Model, QueryParams, WhereCondition, ModelValueWithIncludes, PrimaryKeyValue, DatabaseAPI, DatabaseUpgradeAPI, ModelSchema } from "./types.js";
export type Subscription = {
    model: string;
    query: QueryParams;
    filter: (effect: Effect) => boolean;
    callback: (results: ModelValue[] | ModelValueWithIncludes[]) => Awaitable<void>;
};
export type ModelDBBackend = "idb" | "postgres" | "sqlite-disk" | "sqlite-memory" | "sqlite-wasm" | "sqlite-expo" | "sqlite-durable-objects";
export type DatabaseUpgradeCallback = (upgradeAPI: DatabaseUpgradeAPI, oldConfig: Config, oldVersion: Record<string, number>, newVersion: Record<string, number>) => Awaitable<void>;
export interface ModelDBInit {
    models: ModelSchema;
    version?: Record<string, number>;
    upgrade?: DatabaseUpgradeCallback;
    initialUpgradeVersion?: Record<string, number>;
    initialUpgradeSchema?: ModelSchema;
    clear?: boolean;
}
export declare abstract class AbstractModelDB implements DatabaseAPI {
    #private;
    readonly config: Config;
    readonly version: Record<string, number>;
    static namespace: string;
    static version: number;
    protected static baseVersion: {
        [x: string]: number;
    };
    readonly models: Record<string, Model>;
    protected readonly log: Logger;
    protected readonly subscriptions: Map<number, Subscription>;
    protected constructor(config: Config, version: Record<string, number>);
    protected static initialize(baseModelDB: DatabaseAPI, timestamp: string, initialVersion: Record<string, number>, initialConfig: Config): Promise<void>;
    protected static getVersion(baseModelDB: DatabaseAPI): Promise<Record<string, number>>;
    protected static upgrade(baseModelDB: DatabaseAPI, timestamp: string, newVersion: Record<string, number>, newConfig: Config, upgrade: (oldConfig: Config, oldVersion: Record<string, number>) => Promise<void>): Promise<void>;
    protected abstract hasModel(model: Model): Awaitable<boolean>;
    protected satisfies(config: Config): Promise<boolean>;
    abstract getType(): ModelDBBackend;
    abstract close(): Promise<void>;
    abstract get<T extends ModelValue<any> = ModelValue<any>>(modelName: string, key: PrimaryKeyValue | PrimaryKeyValue[]): Promise<T | null>;
    abstract getAll<T extends ModelValue<any> = ModelValue<any>>(modelName: string): Promise<T[]>;
    abstract getMany<T extends ModelValue<any> = ModelValue<any>>(modelName: string, key: PrimaryKeyValue[] | PrimaryKeyValue[][]): Promise<(T | null)[]>;
    abstract iterate<T extends ModelValue<any> = ModelValue<any>>(modelName: string, query?: QueryParams): AsyncIterable<T>;
    abstract query<T extends ModelValue<any> = ModelValue<any>>(modelName: string, query?: QueryParams): Promise<T[]>;
    abstract count(modelName: string, where?: WhereCondition): Promise<number>;
    abstract clear(modelName: string): Promise<void>;
    abstract apply(effects: Effect[]): Promise<void>;
    set<T extends ModelValue<any> = ModelValue<any>>(modelName: string, value: T): Promise<void>;
    delete(modelName: string, key: PrimaryKeyValue | PrimaryKeyValue[]): Promise<void>;
    update<T extends ModelValue<any> = ModelValue<any>>(modelName: string, value: T): Promise<void>;
    merge<T extends ModelValue<any> = ModelValue<any>>(modelName: string, value: T): Promise<void>;
    subscribe(modelName: string, query: QueryParams, callback: (results: ModelValue[] | ModelValueWithIncludes[]) => Awaitable<void>): {
        id: number;
        results: Promise<ModelValue[]>;
    };
    unsubscribe(id: number): void;
    protected getEffectFilter(model: Model, query: QueryParams): (effect: Effect) => boolean;
}