import 'reflect-metadata';
type QueryDirection = 'asc' | 'desc';
type QueryFieldKey<T> = Extract<keyof T, string>;
type ComparableValue = string | number | bigint | Date;
type ComparableFieldKey<T> = {
    [K in QueryFieldKey<T>]-?: T[K] extends ComparableValue ? K : never;
}[QueryFieldKey<T>];
type NumericFieldKey<T> = {
    [K in QueryFieldKey<T>]-?: T[K] extends number ? K : never;
}[QueryFieldKey<T>];
type StringFieldKey<T> = {
    [K in QueryFieldKey<T>]-?: T[K] extends string ? K : never;
}[QueryFieldKey<T>];
type ArrayFieldKey<T> = {
    [K in QueryFieldKey<T>]-?: T[K] extends readonly any[] ? K : never;
}[QueryFieldKey<T>];
type ArrayElement<T> = T extends readonly (infer U)[] ? U : never;
type ContainsValue<T> = T extends string ? string : T extends readonly (infer U)[] ? U : never;
type QueryOperator = 'equals' | 'gt' | 'gte' | 'lt' | 'lte' | 'startsWith' | 'endsWith' | 'contains' | 'matches' | 'between' | 'notBetween' | 'in' | 'notIn' | 'containsAny' | 'containsAll';
type GroupCountResult<T, K extends Extract<keyof T, string>> = Array<Record<K, T[K]> & {
    count: number;
}>;
declare class FieldQueryBuilder<T, K extends QueryFieldKey<T>> {
    private parent;
    private field;
    constructor(parent: QueryBuilder<T>, field: K);
    equals(value: T[K]): QueryBuilder<T>;
    gt(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
    gte(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
    lt(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
    lte(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
    startsWith(this: FieldQueryBuilder<T, StringFieldKey<T>>, value: string): QueryBuilder<T>;
    endsWith(this: FieldQueryBuilder<T, StringFieldKey<T>>, value: string): QueryBuilder<T>;
    contains(this: FieldQueryBuilder<T, StringFieldKey<T>> | FieldQueryBuilder<T, ArrayFieldKey<T>>, value: ContainsValue<T[K]>): QueryBuilder<T>;
    matches(this: FieldQueryBuilder<T, StringFieldKey<T>>, value: RegExp | string): QueryBuilder<T>;
    between(start: T[K] extends ComparableValue ? T[K] : never, end: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
    notBetween(start: T[K] extends ComparableValue ? T[K] : never, end: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
    in(values: Array<T[K]>): QueryBuilder<T>;
    notIn(values: Array<T[K]>): QueryBuilder<T>;
    containsAny(this: FieldQueryBuilder<T, ArrayFieldKey<T>>, values: Array<ArrayElement<T[K]>>): QueryBuilder<T>;
    containsAll(this: FieldQueryBuilder<T, ArrayFieldKey<T>>, values: Array<ArrayElement<T[K]>>): QueryBuilder<T>;
    and<K2 extends QueryFieldKey<T>>(field: K2): FieldQueryBuilder<T, K2>;
    or(): QueryBuilder<T>;
}
declare class QueryBuilder<T> {
    private db;
    private storeName;
    private transaction?;
    private clauses;
    private orderField?;
    private orderDirection;
    private limitCount?;
    private offsetCount?;
    private indexName?;
    private rangeStart?;
    private rangeEnd?;
    private currentField?;
    private groupField?;
    private pendingConnector;
    constructor(db: IDBDatabase, storeName: string, transaction?: IDBTransaction);
    where<K extends QueryFieldKey<T>>(field: K): FieldQueryBuilder<T, K>;
    where(builder: (query: QueryBuilder<T>) => QueryBuilder<T> | void): this;
    and<K extends QueryFieldKey<T>>(field: K): FieldQueryBuilder<T, K>;
    and(builder: (query: QueryBuilder<T>) => QueryBuilder<T> | void): this;
    or(): this;
    private addNestedGroup;
    clearCurrentField(): void;
    appendCondition(field: string, op: QueryOperator, value: any): void;
    private appendClause;
    private requireCurrentField;
    private addCondition;
    equals(value: any): this;
    gt(value: any): this;
    gte(value: any): this;
    lt(value: any): this;
    lte(value: any): this;
    startsWith(value: string): this;
    endsWith(value: string): this;
    contains(value: any): this;
    matches(value: RegExp | string): this;
    between(start: any, end: any): this;
    notBetween(start: any, end: any): this;
    ['in'](values: any[]): this;
    notIn(values: any[]): this;
    containsAny(values: any[]): this;
    containsAll(values: any[]): this;
    orderBy(field: Extract<keyof T, string>, direction?: QueryDirection): this;
    limit(n: number): this;
    offset(n: number): this;
    useIndex(indexName: string): this;
    range(start: any, end: any): this;
    groupBy<K extends QueryFieldKey<T>>(field: K): QueryBuilder<T> & {
        count(): Promise<GroupCountResult<T, K>>;
    };
    private loadCandidates;
    private createReadRequest;
    private matchesClause;
    private evaluateClauses;
    private collectMatches;
    private sortResults;
    private applyPagination;
    private aggregateValues;
    private aggregateGroupedCount;
    execute(): Promise<T[]>;
    count(): Promise<number | GroupCountResult<T, Extract<keyof T, string>>>;
    sum(field: NumericFieldKey<T>): Promise<number>;
    avg(field: NumericFieldKey<T>): Promise<number>;
    min(field: ComparableFieldKey<T>): Promise<T[typeof field] | null>;
    max(field: ComparableFieldKey<T>): Promise<T[typeof field] | null>;
}
interface KeyPathOptions {
    autoIncrement?: boolean;
    generator?: 'uuid' | 'timestamp' | 'random' | ((item?: any) => string | number);
}
interface RetentionPolicyOptions {
    seconds: number;
    enabled?: boolean;
    field?: string;
}
interface RetentionPolicyMetadata {
    seconds: number;
    enabled: boolean;
    field: string;
}
interface KeyPathMetadata {
    fields: string | string[];
    options?: KeyPathOptions;
}
declare class KeyGenerators {
    static uuid(): string;
    static timestamp(): number;
    static random(): string;
}
declare function KeyPath(options?: KeyPathOptions): PropertyDecorator;
declare function CompositeKeyPath(fields: string[], options?: KeyPathOptions): ClassDecorator;
declare function Index(options?: IDBIndexParameters): PropertyDecorator;
declare function Validate<T = any>(predicate: (value: any, item: T) => boolean, message: string): PropertyDecorator;
declare function RetentionPolicy(options: RetentionPolicyOptions): ClassDecorator;
interface DataClassOptions {
    version?: number;
}
declare function DataClass(options?: DataClassOptions): ClassDecorator;
interface EntityRepository<T> {
    create(item: T): Promise<void>;
    createMany(items: T[]): Promise<void>;
    read(key: string | string[] | number): Promise<T | undefined>;
    update(item: T): Promise<void>;
    updateMany(items: T[]): Promise<void>;
    delete(key: string | string[] | number): Promise<void>;
    deleteMany(keys: Array<string | string[] | number>): Promise<void>;
    deleteWhere(predicate: (query: QueryBuilder<T>) => QueryBuilder<T> | void): Promise<void>;
    list(): Promise<T[]>;
    listPaginated(page: number, pageSize: number): Promise<T[]>;
    findByIndex(indexName: string, value: any): Promise<T[]>;
    findOneByIndex(indexName: string, value: any): Promise<T | undefined>;
    count(): Promise<number>;
    exists(key: string): Promise<boolean>;
    clear(): Promise<void>;
    query(): QueryBuilder<T>;
}
interface TransactionController {
    commit(): Promise<void>;
    rollback(): Promise<void>;
}
type TransactionalDatabase<T extends Record<string, EntityRepository<any>>> = T & TransactionController;
type DatabaseWithRepositories<T extends Record<string, any>> = Database & T;
declare class Database {
    private dbName;
    private classes;
    private db;
    private entityRepositories;
    private dbVersion;
    private retentionTimer;
    private retentionCleanupRunning;
    private retentionPolicies;
    private printEnabled;
    private printDebug;
    private printError;
    private constructor();
    private calculateDatabaseVersion;
    static build<T extends Record<string, EntityRepository<any>>>(dbName: string, classes: Function[]): Promise<DatabaseWithRepositories<T>>;
    private initDB;
    private generateEntityRepositories;
    private calculateRetentionCleanupIntervalMs;
    private startRetentionCleanup;
    private runRetentionCleanup;
    private cleanupExpiredRecords;
    private createEntityRepository;
    private performOperation;
    private createTransactionHandle;
    beginTransaction(entityNames: string[], mode?: IDBTransactionMode): Promise<TransactionalDatabase<Record<string, EntityRepository<any>>>>;
    transaction<T>(callback: (tx: TransactionalDatabase<Record<string, EntityRepository<any>>>) => Promise<T> | T): Promise<T>;
    close(): void;
    getAvailableEntities(): string[];
    getDatabaseVersion(): number;
    getEntityVersions(): Map<string, number>;
    getEntityVersion(entityName: string): number | undefined;
}
export { Database, KeyPath, CompositeKeyPath, DataClass, Index, Validate, RetentionPolicy, EntityRepository, KeyGenerators, };
export type { DatabaseWithRepositories, DataClassOptions, KeyPathOptions, KeyPathMetadata, RetentionPolicyOptions, RetentionPolicyMetadata, };