@anfenn/dync 1.0.0

package/dist/chunk-SQB6E7V2.js

@@ -0,0 +1,191 @@
+// src/storage/sqlite/drivers/CapacitorSQLiteDriver.ts
+var sqliteModuleCache = null;
+async function getSqliteModule() {
+  if (!sqliteModuleCache) {
+    sqliteModuleCache = await import("@capacitor-community/sqlite");
+  }
+  return sqliteModuleCache;
+}
+var CapacitorSQLiteDriver = class {
+  type = "CapacitorSQLiteDriver";
+  connectionFactory;
+  config;
+  db;
+  openPromise;
+  opened = false;
+  name;
+  constructor(databaseName, config = {}) {
+    this.name = databaseName;
+    this.config = config;
+  }
+  async getConnectionFactory() {
+    if (!this.connectionFactory) {
+      const { CapacitorSQLite, SQLiteConnection } = await getSqliteModule();
+      this.connectionFactory = new SQLiteConnection(CapacitorSQLite);
+    }
+    return this.connectionFactory;
+  }
+  async ensureDb() {
+    if (!this.db) {
+      const connectionFactory = await this.getConnectionFactory();
+      const readonly = this.config.readonly ?? false;
+      const existsResult = await connectionFactory.isConnection(this.name, readonly);
+      if (existsResult.result) {
+        this.db = await connectionFactory.retrieveConnection(this.name, readonly);
+      } else {
+        await connectionFactory.closeConnection(this.name, readonly).catch(() => {
+        });
+        this.db = await connectionFactory.createConnection(
+          this.name,
+          this.config.encrypted ?? false,
+          this.config.mode ?? "no-encryption",
+          this.config.version ?? 1,
+          readonly
+        );
+      }
+      this.opened = false;
+    }
+    return this.db;
+  }
+  async open() {
+    if (this.opened) return;
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = (async () => {
+      const connectionFactory = await this.getConnectionFactory();
+      if (this.config.getEncryptionKey) {
+        const { result: isStored } = await connectionFactory.isSecretStored();
+        if (!isStored) {
+          const key = this.config.getEncryptionKey();
+          if (!key && this.config.encrypted) {
+            throw new Error("CapacitorSQLiteDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).");
+          }
+          await connectionFactory.setEncryptionSecret(key);
+        }
+      }
+      const db = await this.ensureDb();
+      await db.open();
+      this.opened = true;
+    })();
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = void 0;
+    }
+  }
+  async close() {
+    if (!this.db) return;
+    await this.db.close();
+    const connectionFactory = await this.getConnectionFactory();
+    await connectionFactory.closeConnection(this.name, this.config.readonly ?? false);
+    this.db = void 0;
+    this.opened = false;
+    this.openPromise = void 0;
+  }
+  async execute(statement) {
+    await this.open();
+    const db = await this.ensureDb();
+    await db.execute(statement, false);
+  }
+  async run(statement, values = []) {
+    await this.open();
+    const db = await this.ensureDb();
+    const result = await db.run(statement, values, false, "no");
+    const changes = result?.changes?.changes ?? result?.changes ?? 0;
+    const lastId = result?.changes?.lastId ?? void 0;
+    return { changes, lastId };
+  }
+  async query(statement, values = []) {
+    await this.open();
+    const db = await this.ensureDb();
+    const result = await db.query(statement, values, true);
+    if (Array.isArray(result?.values) && result.values.length > 0 && !Array.isArray(result.values[0])) {
+      const columns = Object.keys(result.values[0]);
+      const rows = result.values.map((row) => columns.map((column) => row[column]));
+      return { columns, values: rows };
+    }
+    return { columns: result?.columns ?? [], values: result?.values ?? [] };
+  }
+};
+
+// src/storage/sqlite/drivers/CapacitorFastSqlDriver.ts
+var fastSqlModuleCache = null;
+async function getFastSqlModule() {
+  if (!fastSqlModuleCache) {
+    fastSqlModuleCache = await import("@capgo/capacitor-fast-sql");
+  }
+  return fastSqlModuleCache;
+}
+var CapacitorFastSqlDriver = class {
+  type = "CapacitorFastSqlDriver";
+  options;
+  db;
+  openPromise;
+  opened = false;
+  name;
+  constructor(databaseName, options = {}) {
+    this.name = databaseName;
+    this.options = options;
+  }
+  async open() {
+    if (this.opened) return;
+    if (this.openPromise) return this.openPromise;
+    this.openPromise = (async () => {
+      if (!this.db) {
+        const { FastSQL } = await getFastSqlModule();
+        const encryptionKey = this.options.getEncryptionKey?.();
+        if (!encryptionKey && this.options.encrypted) {
+          throw new Error("FastSqlDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).");
+        }
+        this.db = await FastSQL.connect({
+          database: this.name,
+          encrypted: this.options.encrypted,
+          encryptionKey,
+          readOnly: this.options.readonly
+        });
+        this.opened = true;
+      }
+    })();
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = void 0;
+    }
+  }
+  async close() {
+    if (this.db) {
+      const { FastSQL } = await getFastSqlModule();
+      await FastSQL.disconnect(this.name);
+      this.db = void 0;
+      this.opened = false;
+      this.openPromise = void 0;
+    }
+  }
+  async execute(statement) {
+    await this.open();
+    await this.db.execute(statement);
+  }
+  async run(statement, values = []) {
+    await this.open();
+    const result = await this.db.run(statement, values);
+    return {
+      changes: result.rowsAffected,
+      lastId: result.insertId
+    };
+  }
+  async query(statement, values = []) {
+    await this.open();
+    const rows = await this.db.query(statement, values);
+    if (!rows.length) {
+      return { columns: [], values: [] };
+    }
+    const columns = Object.keys(rows[0]);
+    const resultValues = rows.map((row) => columns.map((col) => row[col]));
+    return { columns, values: resultValues };
+  }
+};
+
+export {
+  CapacitorSQLiteDriver,
+  CapacitorFastSqlDriver
+};
+//# sourceMappingURL=chunk-SQB6E7V2.js.map

package/dist/chunk-SQB6E7V2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/sqlite/drivers/CapacitorSQLiteDriver.ts","../src/storage/sqlite/drivers/CapacitorFastSqlDriver.ts"],"sourcesContent":["import type { SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite';\nimport type { SQLiteDatabaseDriver, SQLiteRunResult, SQLiteQueryResult } from '../types';\n\n// Lazily loaded module cache to avoid top-level imports that break web bundlers\nlet sqliteModuleCache: typeof import('@capacitor-community/sqlite') | null = null;\n\nasync function getSqliteModule(): Promise<typeof import('@capacitor-community/sqlite')> {\n    if (!sqliteModuleCache) {\n        sqliteModuleCache = await import('@capacitor-community/sqlite');\n    }\n    return sqliteModuleCache;\n}\n\nexport interface CapacitorSQLiteDriverOptions {\n    encrypted?: boolean;\n    getEncryptionKey?: () => string;\n    readonly?: boolean;\n    mode?: string;\n    version?: number;\n}\n\nexport class CapacitorSQLiteDriver implements SQLiteDatabaseDriver {\n    readonly type = 'CapacitorSQLiteDriver';\n    private connectionFactory?: SQLiteConnection;\n    private readonly config: CapacitorSQLiteDriverOptions;\n    private db?: SQLiteDBConnection;\n    private openPromise?: Promise<void>;\n    private opened = false;\n    readonly name: string;\n\n    constructor(databaseName: string, config: CapacitorSQLiteDriverOptions = {}) {\n        this.name = databaseName;\n        this.config = config;\n    }\n\n    private async getConnectionFactory(): Promise<SQLiteConnection> {\n        if (!this.connectionFactory) {\n            const { CapacitorSQLite, SQLiteConnection } = await getSqliteModule();\n            this.connectionFactory = new SQLiteConnection(CapacitorSQLite);\n        }\n        return this.connectionFactory;\n    }\n\n    private async ensureDb(): Promise<SQLiteDBConnection> {\n        if (!this.db) {\n            const connectionFactory = await this.getConnectionFactory();\n            const readonly = this.config.readonly ?? false;\n\n            // Check if a connection already exists (e.g., after page reload)\n            const existsResult = await connectionFactory.isConnection(this.name, readonly);\n            if (existsResult.result) {\n                // Connection exists - retrieve it instead of creating a new one\n                this.db = await connectionFactory.retrieveConnection(this.name, readonly);\n            } else {\n                // Close any stale native connection (e.g., after page reload) before creating\n                await connectionFactory.closeConnection(this.name, readonly).catch(() => {});\n                this.db = await connectionFactory.createConnection(\n                    this.name,\n                    this.config.encrypted ?? false,\n                    this.config.mode ?? 'no-encryption',\n                    this.config.version ?? 1,\n                    readonly,\n                );\n            }\n\n            // New/retrieved connection means we need to (re)open it.\n            this.opened = false;\n        }\n        return this.db;\n    }\n\n    async open(): Promise<void> {\n        if (this.opened) return;\n        if (this.openPromise) return this.openPromise;\n\n        this.openPromise = (async () => {\n            const connectionFactory = await this.getConnectionFactory();\n            // Set encryption secret if provided and not already stored (must be done before opening)\n            if (this.config.getEncryptionKey) {\n                const { result: isStored } = await connectionFactory.isSecretStored();\n                if (!isStored) {\n                    const key = this.config.getEncryptionKey();\n                    if (!key && this.config.encrypted) {\n                        throw new Error('CapacitorSQLiteDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).');\n                    }\n                    await connectionFactory.setEncryptionSecret(key);\n                }\n            }\n            const db = await this.ensureDb();\n            await db.open();\n            this.opened = true;\n        })();\n\n        try {\n            await this.openPromise;\n        } finally {\n            this.openPromise = undefined;\n        }\n    }\n\n    async close(): Promise<void> {\n        if (!this.db) return;\n        await this.db.close();\n        const connectionFactory = await this.getConnectionFactory();\n        await connectionFactory.closeConnection(this.name, this.config.readonly ?? false);\n        this.db = undefined;\n        this.opened = false;\n        this.openPromise = undefined;\n    }\n\n    async execute(statement: string): Promise<void> {\n        await this.open();\n        const db = await this.ensureDb();\n        await db.execute(statement, false);\n    }\n\n    async run(statement: string, values: any[] = []): Promise<SQLiteRunResult> {\n        await this.open();\n        const db = await this.ensureDb();\n        const result = await db.run(statement, values, false, 'no');\n        const changes = (result as any)?.changes?.changes ?? (result as any)?.changes ?? 0;\n        const lastId = (result as any)?.changes?.lastId ?? undefined;\n        return { changes, lastId };\n    }\n\n    async query(statement: string, values: any[] = []): Promise<SQLiteQueryResult> {\n        await this.open();\n        const db = await this.ensureDb();\n        const result: any = await db.query(statement, values, true);\n        if (Array.isArray(result?.values) && result.values.length > 0 && !Array.isArray(result.values[0])) {\n            const columns = Object.keys(result.values[0]);\n            const rows = result.values.map((row: Record<string, any>) => columns.map((column) => row[column]));\n            return { columns, values: rows };\n        }\n        return { columns: result?.columns ?? [], values: result?.values ?? [] };\n    }\n}\n","import type { SQLConnection, SQLValue } from '@capgo/capacitor-fast-sql';\n\nimport type { SQLiteDatabaseDriver, SQLiteRunResult, SQLiteQueryResult } from '../types';\n\nexport interface FastSqlDriverOptions {\n    encrypted?: boolean;\n    getEncryptionKey?: () => string;\n    readonly?: boolean;\n}\n\n// Lazily loaded module cache to avoid top-level imports that break web bundlers\nlet fastSqlModuleCache: typeof import('@capgo/capacitor-fast-sql') | null = null;\n\nasync function getFastSqlModule(): Promise<typeof import('@capgo/capacitor-fast-sql')> {\n    if (!fastSqlModuleCache) {\n        fastSqlModuleCache = await import('@capgo/capacitor-fast-sql');\n    }\n    return fastSqlModuleCache;\n}\n\n/**\n * SQLiteDatabaseDriver implementation for @capgo/capacitor-fast-sql plugin.\n *\n * This driver provides a compatible interface with the existing SQLiteAdapter\n * while using the Capgo Fast SQL plugin which offers better performance through\n * a local HTTP server approach that bypasses Capacitor's bridge.\n * \n * Update your AndroidManifest.xml to allow cleartext traffic:\n * <application\n        ...\n        android:usesCleartextTraffic=\"true\">\n\n    Requires Capacitor HTTP plugin to prevent CORS, as FastSql server runs on localhost:9000, not Capacitor's localhost\n */\nexport class CapacitorFastSqlDriver implements SQLiteDatabaseDriver {\n    readonly type = 'CapacitorFastSqlDriver';\n    private readonly options: FastSqlDriverOptions;\n    private db?: SQLConnection;\n    private openPromise?: Promise<void>;\n    private opened = false;\n    readonly name: string;\n\n    constructor(databaseName: string, options: FastSqlDriverOptions = {}) {\n        this.name = databaseName;\n        this.options = options;\n    }\n\n    async open(): Promise<void> {\n        if (this.opened) return;\n        if (this.openPromise) return this.openPromise;\n\n        this.openPromise = (async () => {\n            if (!this.db) {\n                const { FastSQL } = await getFastSqlModule();\n                const encryptionKey = this.options.getEncryptionKey?.();\n                if (!encryptionKey && this.options.encrypted) {\n                    throw new Error('FastSqlDriverOptions.encrypted=true but no encryption key was provided (getEncryptionKey).');\n                }\n                this.db = await FastSQL.connect({\n                    database: this.name,\n                    encrypted: this.options.encrypted,\n                    encryptionKey,\n                    readOnly: this.options.readonly,\n                });\n                this.opened = true;\n            }\n        })();\n\n        try {\n            await this.openPromise;\n        } finally {\n            this.openPromise = undefined;\n        }\n    }\n\n    async close(): Promise<void> {\n        if (this.db) {\n            const { FastSQL } = await getFastSqlModule();\n            await FastSQL.disconnect(this.name);\n            this.db = undefined;\n            this.opened = false;\n            this.openPromise = undefined;\n        }\n    }\n\n    async execute(statement: string): Promise<void> {\n        await this.open();\n        await this.db!.execute(statement);\n    }\n\n    async run(statement: string, values: any[] = []): Promise<SQLiteRunResult> {\n        await this.open();\n        const result = await this.db!.run(statement, values as SQLValue[]);\n        return {\n            changes: result.rowsAffected,\n            lastId: result.insertId,\n        };\n    }\n\n    async query(statement: string, values: any[] = []): Promise<SQLiteQueryResult> {\n        await this.open();\n        const rows = await this.db!.query(statement, values as SQLValue[]);\n\n        // Convert array of objects to columns + values format expected by adapter\n        if (!rows.length) {\n            return { columns: [], values: [] };\n        }\n\n        const columns = Object.keys(rows[0]!);\n        const resultValues = rows.map((row) => columns.map((col) => (row as Record<string, any>)[col]));\n\n        return { columns, values: resultValues };\n    }\n}\n"],"mappings":"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","names":[]}

package/dist/dexie-Bv-fV10P.d.cts

@@ -0,0 +1,444 @@
+import dexie from 'dexie';
+import { d as StorageSchemaDefinitionOptions, S as SQLiteDatabaseDriver, e as SQLiteAdapterOptions, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-CSbIAfu2.cjs';
+
+type TableSchemaDefinition = string | SQLiteTableDefinition;
+interface SQLiteTableDefinition {
+    columns: Record<string, SQLiteColumnDefinition>;
+    indexes?: SQLiteIndexDefinition[];
+    tableConstraints?: string[];
+    withoutRowId?: boolean;
+    strict?: boolean;
+}
+interface SQLiteColumnDefinition {
+    type?: string;
+    length?: number;
+    nullable?: boolean;
+    unique?: boolean;
+    default?: SQLiteDefaultValue;
+    check?: string;
+    references?: SQLiteForeignKeyReference | string;
+    collate?: string;
+    generatedAlwaysAs?: string;
+    stored?: boolean;
+    constraints?: string[];
+}
+type SQLiteDefaultValue = string | number | boolean | null;
+interface SQLiteForeignKeyReference {
+    table: string;
+    column?: string;
+    onDelete?: SQLiteForeignKeyAction;
+    onUpdate?: SQLiteForeignKeyAction;
+    match?: string;
+}
+type SQLiteForeignKeyAction = 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION' | 'CASCADE';
+interface SQLiteIndexDefinition {
+    name?: string;
+    columns: string[];
+    unique?: boolean;
+    where?: string;
+    collate?: string;
+    orders?: Array<'ASC' | 'DESC'>;
+}
+
+declare class DexieQueryContext {
+    private readonly adapter;
+    constructor(adapter: DexieAdapter);
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+}
+
+interface MemoryRecord {
+    _localId?: string;
+    id?: unknown;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+interface MemoryCollectionState<T extends MemoryRecord> {
+    predicate: (record: T, key: string) => boolean;
+    orderBy?: {
+        index: string | string[];
+        direction: 'asc' | 'desc';
+    };
+    reverse: boolean;
+    offset: number;
+    limit?: number;
+    distinct: boolean;
+}
+
+declare class MemoryCollection<T extends MemoryRecord = MemoryRecord> implements StorageCollection<T> {
+    private readonly table;
+    private readonly state;
+    constructor(table: MemoryTable<T>, state: MemoryCollectionState<T>);
+    getState(): MemoryCollectionState<T>;
+    matches(record: T, key: string): boolean;
+    clone(_props?: Record<string, unknown>): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    toCollection(): StorageCollection<T>;
+    distinct(): StorageCollection<T>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    or(index: string): StorageWhereClause<T>;
+    first(): Promise<T | undefined>;
+    last(): Promise<T | undefined>;
+    each(callback: (item: T, index: number) => void | Promise<void>): Promise<void>;
+    eachKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachPrimaryKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachUniqueKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    keys(): Promise<unknown[]>;
+    primaryKeys(): Promise<unknown[]>;
+    uniqueKeys(): Promise<unknown[]>;
+    count(): Promise<number>;
+    sortBy(key: string): Promise<T[]>;
+    delete(): Promise<number>;
+    modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number>;
+    toArray(): Promise<T[]>;
+    private withState;
+    private combinePredicate;
+    private materializeEntries;
+}
+
+declare class MemoryWhereClause<T extends MemoryRecord = MemoryRecord> implements StorageWhereClause<T> {
+    private readonly table;
+    private readonly index;
+    private readonly baseCollection?;
+    constructor(table: MemoryTable<T>, index: string | string[], baseCollection?: MemoryCollection<T>);
+    equals(value: any): StorageCollection<T>;
+    above(value: any): StorageCollection<T>;
+    aboveOrEqual(value: any): StorageCollection<T>;
+    below(value: any): StorageCollection<T>;
+    belowOrEqual(value: any): StorageCollection<T>;
+    between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): StorageCollection<T>;
+    inAnyRange(ranges: Array<[any, any]>, options?: {
+        includeLower?: boolean;
+        includeUpper?: boolean;
+    }): StorageCollection<T>;
+    startsWith(prefix: string): StorageCollection<T>;
+    startsWithIgnoreCase(prefix: string): StorageCollection<T>;
+    startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
+    equalsIgnoreCase(value: string): StorageCollection<T>;
+    anyOf(...values: any[]): StorageCollection<T>;
+    anyOf(values: any[]): StorageCollection<T>;
+    anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(values: string[]): StorageCollection<T>;
+    noneOf(...values: any[]): StorageCollection<T>;
+    noneOf(values: any[]): StorageCollection<T>;
+    notEqual(value: any): StorageCollection<T>;
+    private createCollection;
+    private flattenArgs;
+}
+
+declare class MemoryTable<T extends MemoryRecord = MemoryRecord> implements StorageTable<T> {
+    readonly name: string;
+    readonly schema: unknown;
+    readonly primaryKey: unknown;
+    readonly hook: unknown;
+    readonly raw: {
+        add: (item: T) => Promise<unknown>;
+        put: (item: T) => Promise<unknown>;
+        update: (key: unknown, changes: Partial<T>) => Promise<number>;
+        delete: (key: unknown) => Promise<void>;
+        get: (key: unknown) => Promise<T | undefined>;
+        bulkAdd: (items: T[]) => Promise<unknown>;
+        bulkPut: (items: T[]) => Promise<unknown>;
+        bulkUpdate: (keysAndChanges: Array<{
+            key: unknown;
+            changes: Partial<T>;
+        }>) => Promise<number>;
+        bulkDelete: (keys: Array<unknown>) => Promise<void>;
+        clear: () => Promise<void>;
+    };
+    private readonly records;
+    constructor(name: string);
+    add(item: T): Promise<unknown>;
+    put(item: T): Promise<unknown>;
+    update(key: unknown, changes: Partial<T>): Promise<number>;
+    delete(key: unknown): Promise<void>;
+    clear(): Promise<void>;
+    private baseClear;
+    get(key: unknown): Promise<T | undefined>;
+    toArray(): Promise<T[]>;
+    count(): Promise<number>;
+    bulkAdd(items: T[]): Promise<unknown>;
+    private baseBulkAdd;
+    bulkPut(items: T[]): Promise<unknown>;
+    private baseBulkPut;
+    bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>>;
+    bulkUpdate(keysAndChanges: Array<{
+        key: unknown;
+        changes: Partial<T>;
+    }>): Promise<number>;
+    private baseBulkUpdate;
+    bulkDelete(keys: Array<unknown>): Promise<void>;
+    private baseBulkDelete;
+    where(index: string | string[]): StorageWhereClause<T>;
+    orderBy(index: string | string[]): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    mapToClass(_ctor: new (...args: any[]) => any): StorageTable<T>;
+    each(callback: (item: T) => void | Promise<void>): Promise<void>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    private createCollection;
+    createCollectionFromPredicate(predicate: (record: T, key: string) => boolean, template?: MemoryCollection<T>): MemoryCollection<T>;
+    createWhereClause(index: string | string[], baseCollection?: MemoryCollection<T>): MemoryWhereClause<T>;
+    entries(): Array<[string, T]>;
+    cloneRecord(record: T): T;
+    deleteByKey(key: string): void;
+    getMutableRecord(key: string): T | undefined;
+    setMutableRecord(key: string, record: T): void;
+    resolvePublicKey(record: T, key: string): unknown;
+    getIndexValue(record: T, index: string | string[]): unknown;
+    compareEntries(left: T, right: T, index: string | string[]): number;
+    compareValues(left: unknown, right: unknown): number;
+    private normalizeComparableValue;
+    private baseAdd;
+    private basePut;
+    private baseUpdate;
+    private baseDelete;
+    private baseGet;
+    private createPrimaryKey;
+    private resolveKey;
+}
+
+declare class MemoryAdapter implements StorageAdapter {
+    readonly type = "MemoryAdapter";
+    readonly name: string;
+    readonly tables: Map<string, MemoryTable<any>>;
+    constructor(name: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    query<R>(callback: (ctx: MemoryQueryContext) => Promise<R>): Promise<R>;
+    defineSchema(_version: number, schema: Record<string, string>, _options?: StorageSchemaDefinitionOptions): void;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(_mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    private ensureTable;
+}
+
+declare class MemoryQueryContext {
+    private readonly adapter;
+    constructor(adapter: MemoryAdapter);
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+}
+
+declare class SQLiteAdapter implements StorageAdapter {
+    readonly type = "SQLiteAdapter";
+    readonly name: string;
+    private readonly options;
+    private readonly schemas;
+    private readonly versionSchemas;
+    private readonly versionOptions;
+    private readonly tableCache;
+    private driver;
+    private openPromise?;
+    private isOpen;
+    private schemaApplied;
+    private transactionDepth;
+    private targetVersion;
+    constructor(driver: SQLiteDatabaseDriver, options?: SQLiteAdapterOptions);
+    get driverType(): string;
+    /**
+     * Opens the database connection and applies schema.
+     * This is called automatically when performing operations,
+     * so explicit calls are optional but safe (idempotent).
+     * When called explicitly after schema changes, it will run any pending migrations.
+     */
+    open(): Promise<void>;
+    private ensureOpen;
+    private performOpen;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, options?: StorageSchemaDefinitionOptions): void;
+    private refreshActiveSchema;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(_mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    execute(statement: string, values?: any[]): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    query<R>(callback: (ctx: SqliteQueryContext) => Promise<R>): Promise<R>;
+    query(statement: string, values?: any[]): Promise<SQLiteQueryResult>;
+    queryRows(statement: string, values?: any[]): Promise<Array<Record<string, any>>>;
+    /**
+     * Ensures the database is open and returns the driver.
+     * This is the main entry point for all public database operations.
+     */
+    private getDriver;
+    /**
+     * Internal execute that uses driver directly.
+     * Used during the open process to avoid recursion.
+     */
+    private internalExecute;
+    /**
+     * Internal run that uses driver directly.
+     * Used during the open process to avoid recursion.
+     */
+    private internalRun;
+    /**
+     * Internal queryRows that uses driver directly.
+     * Used during the open process to avoid recursion.
+     */
+    private internalQueryRows;
+    /**
+     * Internal query that uses driver directly.
+     * Used during migrations to avoid recursion.
+     */
+    private internalQuery;
+    private logSql;
+    private getStoredSchemaVersion;
+    private setStoredSchemaVersion;
+    private runPendingMigrations;
+    private runMigrationStep;
+    private getMigrationHandler;
+    private applySchema;
+    private buildCreateTableStatement;
+    private buildStructuredColumnDefinition;
+    private formatColumnType;
+    private formatDefaultValue;
+    private buildReferencesClause;
+    private buildIndexStatements;
+    private generateIndexName;
+    private parseStructuredSchema;
+    private normalizeColumns;
+}
+
+declare class SqliteQueryContext {
+    private readonly driver;
+    private readonly adapter;
+    constructor(driver: SQLiteDatabaseDriver, adapter: SQLiteAdapter);
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    queryRows(statement: string, values?: any[]): Promise<Array<Record<string, any>>>;
+}
+
+type TransactionMode = 'r' | 'rw';
+interface StorageAdapter {
+    readonly type: string;
+    readonly name: string;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, options?: StorageSchemaDefinitionOptions): void;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    query<R>(callback: (ctx: DexieQueryContext | SqliteQueryContext | MemoryQueryContext) => Promise<R>): Promise<R>;
+}
+interface StorageTransactionContext {
+    tables: Record<string, StorageTable<any>>;
+}
+interface StorageCollection<T = any> {
+    first(): Promise<T | undefined>;
+    last(): Promise<T | undefined>;
+    each(callback: (item: T, index: number) => void | Promise<void>): Promise<void>;
+    eachKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachPrimaryKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachUniqueKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    keys(): Promise<unknown[]>;
+    primaryKeys(): Promise<unknown[]>;
+    uniqueKeys(): Promise<unknown[]>;
+    count(): Promise<number>;
+    sortBy(key: string): Promise<T[]>;
+    distinct(): StorageCollection<T>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    or(index: string): StorageWhereClause<T>;
+    clone(props?: Record<string, unknown>): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    toCollection(): StorageCollection<T>;
+    delete(): Promise<number>;
+    modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number>;
+    toArray(): Promise<T[]>;
+}
+interface StorageWhereClause<T = any> {
+    equals(value: any): StorageCollection<T>;
+    above(value: any): StorageCollection<T>;
+    aboveOrEqual(value: any): StorageCollection<T>;
+    below(value: any): StorageCollection<T>;
+    belowOrEqual(value: any): StorageCollection<T>;
+    between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): StorageCollection<T>;
+    inAnyRange(ranges: Array<[any, any]>, options?: {
+        includeLower?: boolean;
+        includeUpper?: boolean;
+    }): StorageCollection<T>;
+    startsWith(prefix: string): StorageCollection<T>;
+    startsWithIgnoreCase(prefix: string): StorageCollection<T>;
+    startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
+    equalsIgnoreCase(value: string): StorageCollection<T>;
+    anyOf(...values: any[]): StorageCollection<T>;
+    anyOf(values: any[]): StorageCollection<T>;
+    anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(values: string[]): StorageCollection<T>;
+    noneOf(...values: any[]): StorageCollection<T>;
+    noneOf(values: any[]): StorageCollection<T>;
+    notEqual(value: any): StorageCollection<T>;
+}
+interface StorageTable<T = any> {
+    readonly name: string;
+    readonly schema: unknown;
+    readonly hook: unknown;
+    add(item: T): Promise<unknown>;
+    put(item: T): Promise<unknown>;
+    update(key: unknown, changes: Partial<T>): Promise<number>;
+    delete(key: unknown): Promise<void>;
+    clear(): Promise<void>;
+    get(key: unknown): Promise<T | undefined>;
+    toArray(): Promise<T[]>;
+    count(): Promise<number>;
+    bulkAdd(items: T[]): Promise<unknown>;
+    bulkPut(items: T[]): Promise<unknown>;
+    bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>>;
+    bulkUpdate(keysAndChanges: Array<{
+        key: unknown;
+        changes: Partial<T>;
+    }>): Promise<number>;
+    bulkDelete(keys: Array<unknown>): Promise<void>;
+    where(index: string | string[]): StorageWhereClause<T>;
+    orderBy(index: string | string[]): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    mapToClass(ctor: new (...args: any[]) => any): StorageTable<T>;
+    each(callback: (item: T) => void | Promise<void>): Promise<void>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    readonly raw: {
+        add(item: T): Promise<unknown>;
+        put(item: T): Promise<unknown>;
+        update(key: unknown, changes: Partial<T>): Promise<number>;
+        delete(key: unknown): Promise<void>;
+        get(key: unknown): Promise<T | undefined>;
+        bulkAdd(items: T[]): Promise<unknown>;
+        bulkPut(items: T[]): Promise<unknown>;
+        bulkUpdate(keysAndChanges: Array<{
+            key: unknown;
+            changes: Partial<T>;
+        }>): Promise<number>;
+        bulkDelete(keys: Array<unknown>): Promise<void>;
+        clear(): Promise<void>;
+    };
+}
+
+declare class DexieAdapter implements StorageAdapter {
+    readonly type = "DexieAdapter";
+    readonly name: string;
+    readonly db: dexie;
+    private readonly tableCache;
+    constructor(databaseName: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    query<R>(callback: (ctx: DexieQueryContext) => Promise<R>): Promise<R>;
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, _options?: StorageSchemaDefinitionOptions): void;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+}
+
+export { DexieQueryContext as D, MemoryAdapter as M, SQLiteAdapter as S, type TableSchemaDefinition as T, MemoryQueryContext as a, SqliteQueryContext as b, type StorageAdapter as c, type StorageTable as d, DexieAdapter as e };