@enjoys/react-api/dist/idb/index.d.cts

import * as Dexie from 'dexie';
import Dexie__default, { Table, InsertType, EntityTable } from 'dexie';

type Prettify<T> = T extends infer O ? {
    [K in keyof O]: O[K];
} : never;

type FlatKeys<T> = {
    [K in keyof T]: T[K] extends object ? T[K] extends Array<any> ? never : K : K;
}[keyof T] & string;
type CommaString<PK extends string, Extras extends string> = `++${PK}` | `++${PK},${Extras}`;
type PrimaryKeyFromTable<T> = T extends Table<infer R, any, InsertType<infer R2, infer PK>> ? R extends R2 ? PK : never : never;
type CreatePKTableSchema<T extends Record<string, Table<any, any, any>>> = {
    [K in keyof T]: T[K] extends Table<infer R, any, any> ? CommaString<PrimaryKeyFromTable<T[K]>, Exclude<FlatKeys<R>, PrimaryKeyFromTable<T[K]>>> : never;
};
type SchemaForTables<TSchemas extends Record<string, any>, PKMap extends {
    [K in keyof TSchemas]: keyof TSchemas[K];
}> = {
    readonly [K in keyof TSchemas]: EntityTable<TSchemas[K], PKMap[K]>;
};
type TableValue<T> = T extends Table<infer U, any> ? U : never;
type QueryOperator = "equals" | "anyOf" | "above" | "below" | "between";
type PrimaryKeyType<Tables, T extends keyof Tables> = Tables[T] extends Table<infer U, infer PK> ? PK : never;
type Primitive = string | number | boolean | bigint | symbol | null | undefined;
type BuildNested<Value, Keys extends string[]> = Keys extends [
    infer Head extends string,
    ...infer Rest extends string[]
] ? {
    [K in Head]: BuildNested<Value, Rest>;
} : Value;
type PrefixKeys<Prefix extends string, T> = {
    [K in keyof T & string as `${Prefix}.${K}`]: T[K];
};
type NestedToDotPath<T, Prefix extends string = ""> = {
    [K in keyof T & string]: T[K] extends object ? T[K] extends Array<any> ? Prefix extends "" ? {
        [P in K]: T[K];
    } : {
        [P in `${Prefix}.${K}`]: T[K];
    } : Prefix extends "" ? NestedToDotPath<T[K], K> : NestedToDotPath<T[K], `${Prefix}.${K}`> : Prefix extends "" ? {
        [P in K]: T[K];
    } : {
        [P in `${Prefix}.${K}`]: T[K];
    };
}[keyof T & string];
type Merge<A, B> = {
    [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? A[K] extends object ? B[K] extends object ? Merge<A[K], B[K]> : B[K] : B[K] : B[K] : K extends keyof A ? A[K] : never;
};
type DotPathToNested<T extends Record<string, any>> = {
    [K in keyof T]: BuildNested<T[K], Split<Extract<K, string>>>;
} extends infer Mapped ? UnionToIntersection<Mapped[keyof Mapped]> : never;
type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer R) => void ? R : never;
type OnlyNestedKeys<T, Prefix extends string = ""> = {
    [K in keyof T]: T[K] extends Primitive | Function | Array<any> ? `${Prefix}${K & string}` : T[K] extends object ? `${Prefix}${K & string}` | OnlyNestedKeys<T[K], `${Prefix}${K & string}.`> : never;
}[keyof T];
type Prev = [never, 0, 1, 2, 3, 4, 5];
type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends any[] ? false : true : false;
type NestedKeys<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
    [K in keyof T & string]: IsPlainObject<T[K]> extends true ? K | `${K}.${NestedKeys<T[K], Prev[D]>}` : K;
}[keyof T & string] : never;
type NestedValueFromPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? NestedValueFromPath<T[Key], Rest> : never : P extends keyof T ? T[P] : never;
type Split<S extends string, Delimiter extends string = "."> = S extends `${infer Head}${Delimiter}${infer Tail}` ? [Head, ...Split<Tail, Delimiter>] : [S];
type DeepValue<T, Parts extends string[]> = Parts extends [
    infer First,
    ...infer Rest
] ? First extends keyof T ? Rest extends string[] ? DeepValue<T[First], Rest> : T[First] : never : T;
type PathValue<T, P extends string> = DeepValue<T, Split<P>>;
type TableKeys<T> = keyof T;
type TableSchema<T> = {
    [tableName in TableKeys<T>]: string;
};
type UpdatesForTable<T> = {
    [K in NestedKeys<T>]?: PathValue<T, K>;
};
type PartialUpdatesForTable<Tables, T extends keyof Tables> = Partial<{
    [P in NestedKeys<Tables[T]>]: PathValue<Tables[T], P>;
}>;
type FieldType<Tables, T extends keyof Tables, P extends NestedKeys<Tables[T]>> = PathValue<Tables[T], P>;
type QueryWhere<Tables, K extends keyof Tables> = {
    field: keyof Tables[K];
    operator?: QueryOperator;
    value: any;
};
type QueryOptions<Tables, K extends keyof Tables> = {
    where?: QueryWhere<Tables, K>;
    sortBy?: keyof Tables[K];
    offset?: number;
    limit?: number;
    reverse?: boolean;
    count?: boolean;
    each?: (item: Tables[K]) => void;
    primaryKeys?: boolean;
    raw?: boolean;
};
interface IDatabaseChange<Tables = Record<string, any>> {
    source: any;
    table: keyof Tables;
    key: string;
    type: number;
    mods: Partial<Tables[keyof Tables]>;
    oldObj: Tables[keyof Tables];
    obj: Tables[keyof Tables];
    rev: number;
}

declare const equals: <T>(value: T) => {
    readonly op: "equals";
    readonly value: T;
};
declare const notEqual: <T>(value: T) => {
    readonly op: "notEqual";
    readonly value: T;
};
declare const startsWith: <T>(value: T) => {
    readonly op: "startsWith";
    readonly value: T;
};
declare const anyOf: <T>(value: T[]) => {
    readonly op: "anyOf";
    readonly value: T[];
};
declare const above: <T>(value: T) => {
    readonly op: "above";
    readonly value: T;
};
declare const below: <T>(value: T) => {
    readonly op: "below";
    readonly value: T;
};
declare const between: <T>(range: [T, T]) => {
    readonly op: "between";
    readonly value: [T, T];
};
declare const $gt: <T>(value: T) => {
    readonly op: "above";
    readonly value: T;
};
declare const $lt: <T>(value: T) => {
    readonly op: "below";
    readonly value: T;
};
declare const $gte: <T>(value: T) => {
    readonly op: "gte";
    readonly value: T;
};
declare const $lte: <T>(value: T) => {
    readonly op: "lte";
    readonly value: T;
};
type Operator<T> = ReturnType<typeof equals<T>> | ReturnType<typeof notEqual<T>> | ReturnType<typeof startsWith<T>> | ReturnType<typeof anyOf<T>> | ReturnType<typeof above<T>> | ReturnType<typeof below<T>> | ReturnType<typeof between<T>> | ReturnType<typeof $gt<T>> | ReturnType<typeof $lt<T>> | ReturnType<typeof $gte<T>> | ReturnType<typeof $lte<T>>;

type SmartWhere<T> = Partial<{
    [K in keyof T]?: Operator<T[K]> | {
        [key: string]: T[K];
    };
}>;
type JoinConfig<LocalTable, ForeignTable, LocalKey extends keyof LocalTable, ForeignKey extends keyof ForeignTable> = {
    store: string;
    localKey: LocalKey;
    foreignKey: ForeignKey;
    as: string;
};

type Row<Tables, TName extends keyof Tables> = Tables[TName] extends Dexie__default.Table<infer R, any> ? R : never;
type Key<Tables, TName extends keyof Tables> = Tables[TName] extends Dexie__default.Table<any, infer K> ? K : never;
declare class QueryBuilder<Tables extends Record<string, Dexie__default.Table<any, any>>, TableName extends keyof Tables> {
    private db;
    private tableName;
    private _limit?;
    private _offset?;
    private _orderBy?;
    private _select?;
    private whereClauses;
    private orClauses;
    private joinConfigs;
    constructor(db: Dexie__default & Tables, tableName: TableName);
    private get table();
    where(conditions: SmartWhere<Row<Tables, TableName>>): this;
    or(conditions: SmartWhere<Row<Tables, TableName>>[]): this;
    andWhere(conditions: SmartWhere<Row<Tables, TableName>>): this;
    orWhere(conditions: SmartWhere<Row<Tables, TableName>>): this;
    join<StoreName extends Exclude<keyof Tables, TableName>, LKey extends keyof Row<Tables, TableName>, FKey extends keyof Row<Tables, StoreName>>(config: JoinConfig<Row<Tables, TableName>, Row<Tables, StoreName>, LKey, FKey> & {
        store: StoreName;
    }): this;
    limit(value: number): this;
    offset(value: number): this;
    orderBy(field: keyof Row<Tables, TableName>): this;
    select<K extends keyof Row<Tables, TableName>>(fields: K[]): this;
    findMany(): Promise<Row<Tables, TableName>[]>;
    findOne(): Promise<Row<Tables, TableName> | undefined>;
    findById(id: Key<Tables, TableName>): Promise<Row<Tables, TableName> | undefined>;
    update(id: Key<Tables, TableName>, data: Partial<Row<Tables, TableName>>): Promise<number>;
    updateMany(ids: Key<Tables, TableName>[], data: Partial<Row<Tables, TableName>>): Promise<number[]>;
    delete(id: Key<Tables, TableName>): Promise<void>;
    deleteMany(ids: Key<Tables, TableName>[]): Promise<void[]>;
    findAndCount(): Promise<{
        data: Row<Tables, TableName>[] | undefined;
        count: number;
    }>;
}

declare class IDB<Tables extends {
    [key: string]: Table;
}> {
    private readonly tables;
    private db;
    constructor(tables: TableSchema<Tables>, name?: string, version?: number);
    private useObservable;
    getRawDb(): Dexie__default & Tables;
    private getPrimaryKeyForTable;
    has<T extends keyof Tables, Key extends PrimaryKeyType<Tables, T>>(table: T, key: Key): Promise<boolean>;
    openNewDatabase(dbName: string, version: number | undefined, objectStores: string[]): Promise<IDBDatabase>;
    closeDbConnection(): false | void;
    cleanDb(): Promise<Dexie__default>;
    private getTable;
    addItem<K extends keyof Tables>(table: K, item: Partial<TableValue<Tables[K]>>): Promise<Dexie.IndexableType>;
    bulkAddItems<K extends keyof Tables>(table: K, items: TableValue<Tables[K]>[]): Promise<Dexie.IndexableType>;
    putItem<K extends keyof Tables>(table: K, item: Partial<TableValue<Tables[K]>>): Promise<Dexie.IndexableType>;
    bulkPutItems<K extends keyof Tables>(table: K, item: Tables[K][]): Promise<Dexie.IndexableType>;
    getItemByKey<K extends keyof Tables>(table: K, value: string): Promise<TableValue<Tables[K]> | undefined>;
    getAllItems<K extends keyof Tables>(table: K, sorted?: boolean): Promise<Array<TableValue<Tables[K]>>>;
    getItemsByIndex<K extends keyof Tables>(table: K, where: keyof TableValue<Tables[K]>, equals: string, limit?: number): Promise<Array<TableValue<Tables[K]>> | undefined>;
    getItemsChunk<K extends keyof Tables>(table: K, offset: number, limit: number): Promise<any[]>;
    query<K extends keyof Tables>(table: K, options?: QueryOptions<Tables, K>): Promise<any>;
    updateItem<K extends keyof Tables>(table: K, field_value: string, updated: TableValue<Tables[K]>): Promise<number>;
    deleteItem<K extends keyof Tables>(table: K, field_value: any): Promise<void>;
    bulkDeleteItems<K extends keyof Tables>(table: K, keys: any[]): Promise<void>;
    pruneOldItems<K extends keyof Tables>(table: K, keyField: keyof Tables[K], maxLimit?: number): Promise<void>;
    getNestedValue<T extends keyof Tables, P extends NestedKeys<TableValue<Tables[T]>>>(obj: T, path: P): Promise<{
        success: boolean;
        path: P;
        value: PathValue<TableValue<Tables[T]>, P> | undefined;
    }>;
    getNestedItem<T extends keyof Tables, P extends NestedKeys<TableValue<Tables[T]>>>(tableName: T, primaryKey: PrimaryKeyType<Tables, T>, path: P): Promise<{
        success: boolean;
        path: P;
        value?: PathValue<TableValue<Tables[T]>, P> | undefined;
    }>;
    getMultiNestedItem<T extends keyof Tables, P extends NestedKeys<TableValue<Tables[T]>>>(tableName: T, primaryKey: string | number, paths: P[]): Promise<{
        paths: P[];
        value: DotPathToNested<{
            [key in P]: PathValue<TableValue<Tables[T]>, P>;
        }> | undefined;
        success: boolean;
    }>;
    addNestedItem<T extends keyof Tables, Updates extends UpdatesForTable<TableValue<Tables[T]>>>(tableName: T, primaryKeyValue: PrimaryKeyType<Tables, T>, updates: Updates): Promise<{
        success: boolean;
        created: boolean;
        updatedPaths: (keyof Updates)[];
        updates: Updates;
        oldValues: Partial<Updates>;
    }>;
    updateNestedItem<T extends keyof Tables, P extends NestedKeys<TableValue<Tables[T]>>>(tableName: T, primaryKey: PrimaryKeyType<Tables, T>, path: P, value: PathValue<TableValue<Tables[T]>, P>): Promise<{
        success: boolean;
        path: P;
        oldValue?: PathValue<TableValue<Tables[T]>, P>;
        newValue?: PathValue<TableValue<Tables[T]>, P>;
    }>;
    updateMultipleNestedItems<T extends keyof Tables, Updates extends UpdatesForTable<TableValue<Tables[T]>>>(tableName: T, primaryKey: PrimaryKeyType<Tables, T>, updates: Updates): Promise<Prettify<{
        success: false;
        updated: (keyof Updates)[];
        updates: null;
    } | {
        success: true;
        updated: (keyof Updates)[];
        updates: DotPathToNested<Updates>;
    }>>;
    deleteNestedItem<T extends keyof Tables, P extends NestedKeys<TableValue<Tables[T]>>>(tableName: T, primaryKey: PrimaryKeyType<Tables, T>, path: P): Promise<{
        success: boolean;
        path: P;
        deletedValue?: PathValue<TableValue<Tables[T]>, P>;
    }>;
    createTypeSchema<T extends keyof Tables, P extends NestedKeys<TableValue<Tables[T]>>>(table: T, path: P): PathValue<TableValue<Tables[T]>, P>;
    rawQuery<T extends keyof Tables>(table: T): QueryBuilder<Tables, T>;
}

declare function useDexieObservable(): void;

export { type BuildNested, type CreatePKTableSchema, type DotPathToNested, type FieldType, IDB, type IDatabaseChange, type Merge, type NestedKeys, type NestedToDotPath, type NestedValueFromPath, type OnlyNestedKeys, type PartialUpdatesForTable, type PathValue, type PrefixKeys, type PrimaryKeyType, type Primitive, type QueryOptions, type QueryWhere, type SchemaForTables, type Split, type TableSchema, type TableValue, type UpdatesForTable, useDexieObservable };