@type32/tauri-sqlite-orm 0.1.17 → 0.1.18-0

package/dist/index.d.ts

@@ -1,455 +1,155 @@
 import Database from '@tauri-apps/plugin-sql';
 
-type UpdateDeleteAction = "cascade" | "restrict" | "no action" | "set null" | "set default";
-interface SQLExpression {
-    raw: string;
-}
-declare function sql(strings: TemplateStringsArray, ...values: any[]): SQLExpression;
-interface Column<T = any> {
-    name: string;
-    type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "NUMERIC";
-    isPrimaryKey?: boolean;
-    autoIncrement?: boolean;
-    isNotNull?: boolean;
-    defaultValue?: T | SQLExpression;
-    defaultFn?: () => any;
-    onUpdateFn?: () => any;
+type ColumnDataType = "TEXT" | "INTEGER" | "REAL" | "BLOB" | "BOOLEAN";
+type Mode = "default" | "timestamp" | "timestamp_ms" | "json";
+type ColumnValueTypes<TType extends ColumnDataType, TMode extends Mode> = TType extends "TEXT" ? string : TType extends "INTEGER" ? TMode extends "timestamp" | "timestamp_ms" ? Date : number : TType extends "REAL" ? number : TType extends "BOOLEAN" ? boolean : TType extends "BLOB" ? Uint8Array : never;
+interface ColumnOptions<TData> {
+    notNull?: boolean;
+    default?: TData;
+    $defaultFn?: () => TData;
+    primaryKey?: boolean;
+    autoincrement?: boolean;
+    unique?: boolean;
     references?: {
-        table: string;
-        column: string;
-        onDelete?: UpdateDeleteAction;
-        onUpdate?: UpdateDeleteAction;
+        table: AnyTable;
+        column: AnySQLiteColumn;
     };
-    enumValues?: readonly string[];
-    mode?: string;
-    _dataType: T;
-    /**
-     * Populated by defineTable so we can reason about relations and aliasing.
-     */
-    tableName?: string;
+    mode?: Mode;
+    $onUpdateFn?: () => TData;
 }
-type ColumnBuilder<T> = Column<T> & {
-    primaryKey: (opts?: {
-        autoIncrement?: boolean;
-    }) => ColumnBuilder<T>;
-    notNull: () => ColumnBuilder<T>;
-    default: (value: T | SQLExpression) => ColumnBuilder<T>;
-    $type: <U>() => ColumnBuilder<U>;
-    $defaultFn: (fn: () => any) => ColumnBuilder<T>;
-    $default: (fn: () => any) => ColumnBuilder<T>;
-    $onUpdate: (fn: () => any) => ColumnBuilder<T>;
-    $onUpdateFn: (fn: () => any) => ColumnBuilder<T>;
-    references: (target: () => Column<any>, actions?: {
-        onDelete?: UpdateDeleteAction;
-        onUpdate?: UpdateDeleteAction;
-    }) => ColumnBuilder<T>;
-};
-type TextConfig<TEnum extends string> = {
-    enum?: readonly TEnum[];
-    mode?: "json";
-};
-declare function text<TEnum extends string>(name: string, config?: TextConfig<TEnum>): ColumnBuilder<TEnum extends string ? TEnum : string>;
-declare function text<TEnum extends string>(config?: TextConfig<TEnum>): ColumnBuilder<TEnum extends string ? TEnum : string>;
-type IntegerMode = "number" | "boolean" | "timestamp" | "timestamp_ms";
-declare function integer(name: string, config?: {
-    mode?: IntegerMode;
-}): ColumnBuilder<number | boolean | Date>;
-declare function integer(config?: {
-    mode?: IntegerMode;
-}): ColumnBuilder<number | boolean | Date>;
-declare function real(name: string): ColumnBuilder<number>;
-declare function real(): ColumnBuilder<number>;
-type BlobMode = "json" | "bigint" | "buffer";
-declare function blob(name: string, config?: {
-    mode?: BlobMode;
-}): ColumnBuilder<unknown | bigint | Uint8Array>;
-declare function blob(config?: {
-    mode?: BlobMode;
-}): ColumnBuilder<unknown | bigint | Uint8Array>;
-type NumericMode = "string" | "number" | "bigint";
-declare function numeric(name: string, config?: {
-    mode?: NumericMode;
-}): ColumnBuilder<string | number | bigint>;
-declare function numeric(config?: {
-    mode?: NumericMode;
-}): ColumnBuilder<string | number | bigint>;
-declare function boolean(name: string): ColumnBuilder<boolean>;
-declare function boolean(): ColumnBuilder<boolean>;
-declare function timestamp(name: string): ColumnBuilder<Date>;
-declare function timestamp(): ColumnBuilder<Date>;
-declare function increments(name: string): ColumnBuilder<number>;
-declare function increments(): ColumnBuilder<number>;
-type UniqueSpec = {
-    name?: string;
-    columns: string[];
-};
-type PrimaryKeySpec = {
-    name?: string;
-    columns: string[];
-};
-type CheckSpec = {
-    name: string;
-    expr: SQLExpression | {
-        raw: string;
-    };
-};
-type ForeignKeySpec = {
-    name?: string;
-    columns: string[];
-    foreignTable: string;
-    foreignColumns: string[];
-    onDelete?: UpdateDeleteAction;
-    onUpdate?: UpdateDeleteAction;
-};
-type IndexSpec = {
-    name: string;
-    columns: string[];
-    unique?: boolean;
-    where?: SQLExpression;
-};
-declare function unique(name?: string): {
-    on: (...cols: Column<any>[]) => UniqueSpec;
-};
-declare function primaryKey(opts: {
-    name?: string;
-    columns: Column<any>[];
-}): PrimaryKeySpec;
-declare function check(name: string, expr: SQLExpression): CheckSpec;
-declare function foreignKey(opts: {
-    name?: string;
-    columns: Column<any>[];
-    foreignColumns: Column<any>[];
-    onDelete?: UpdateDeleteAction;
-    onUpdate?: UpdateDeleteAction;
-}): ForeignKeySpec;
-declare function index(name: string): {
-    on: (...cols: Column<any>[]) => IndexSpec;
-    where: (expr: SQLExpression) => IndexSpec;
-};
-declare function uniqueIndex(name: string): {
-    on: (...cols: Column<any>[]) => IndexSpec;
-    where: (expr: SQLExpression) => IndexSpec;
-};
-type SchemaDefinition = Record<string, Column<any>>;
-type InferModel<T extends SchemaDefinition> = {
-    [K in keyof T]: T[K]["_dataType"];
-};
-declare function defineTable<T extends SchemaDefinition>(tableName: string, schema: T, extras?: (t: any) => Array<UniqueSpec | PrimaryKeySpec | CheckSpec | ForeignKeySpec | IndexSpec>): any & InferModel<T>;
-type Table<T extends SchemaDefinition> = ReturnType<typeof defineTable<T>>;
-
-interface SQL {
-    toSQL: () => {
-        clause: string;
-        bindings: any[];
+type ExtractColumnType<T extends AnySQLiteColumn> = T extends SQLiteColumn<infer _, infer TType, infer TMode, infer TNotNull, infer THasDefault> ? THasDefault extends true ? TNotNull extends true ? ColumnValueTypes<TType, TMode> : ColumnValueTypes<TType, TMode> | null | undefined : TNotNull extends true ? ColumnValueTypes<TType, TMode> : ColumnValueTypes<TType, TMode> | null | undefined : never;
+declare class SQLiteColumn<TName extends string = string, TType extends ColumnDataType = ColumnDataType, TMode extends Mode = "default", TNotNull extends boolean = false, THasDefault extends boolean = false, TAutoincrement extends boolean = false> {
+    type: TType;
+    options: ColumnOptions<ColumnValueTypes<TType, TMode>>;
+    _: {
+        name: TName;
+        dataType: TType;
+        mode: TMode;
+        notNull: TNotNull;
+        hasDefault: THasDefault;
+        autoincrement: TAutoincrement;
     };
+    constructor(name: TName, type: TType, options?: ColumnOptions<ColumnValueTypes<TType, TMode>>, mode?: TMode);
+    notNull(): SQLiteColumn<TName, TType, TMode, true, THasDefault, TAutoincrement>;
+    default(value: ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, true, TAutoincrement>;
+    $defaultFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, true, TAutoincrement>;
+    primaryKey(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
+    autoincrement(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, true>;
+    unique(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
+    references<T extends AnyTable, K extends keyof T["_"]["columns"] & string>(ref: T, column: K): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
+    $onUpdateFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement>;
 }
-declare function raw(strings: TemplateStringsArray, ...values: any[]): SQL;
-declare function getQualifiedName(column: Column): string;
-declare const and: (...conditions: SQL[]) => SQL;
-declare const or: (...conditions: SQL[]) => SQL;
-declare const not: (condition: SQL) => SQL;
-declare const eq: (column: Column, value: any) => SQL;
-declare const ne: (column: Column, value: any) => SQL;
-declare const gt: (column: Column, value: number | Date) => SQL;
-declare const gte: (column: Column, value: number | Date) => SQL;
-declare const lt: (column: Column, value: number | Date) => SQL;
-declare const lte: (column: Column, value: number | Date) => SQL;
-declare const like: (column: Column<string>, value: string) => SQL;
-declare const ilike: (column: Column<string>, value: string | Column) => SQL;
-declare const notIlike: (column: Column<string>, value: string | Column) => SQL;
-declare const isNull: (column: Column) => SQL;
-declare const isNotNull: (column: Column) => SQL;
-declare const between: (column: Column, from: number | string | Date | Column, to: number | string | Date | Column) => SQL;
-declare const notBetween: (column: Column, from: number | string | Date | Column, to: number | string | Date | Column) => SQL;
-declare const inArray: (column: Column, valuesOrQuery: any[] | SQL | {
-    toSQL: () => {
-        clause: string;
-        bindings: any[];
-    };
-}) => SQL;
-declare const notInArray: (column: Column, valuesOrQuery: any[] | SQL | {
-    toSQL: () => {
-        clause: string;
-        bindings: any[];
-    };
-}) => SQL;
-declare const exists: (subquery: SQL | {
-    toSQL: () => {
-        clause: string;
-        bindings: any[];
+declare const text: <TName extends string>(name: TName) => SQLiteColumn<TName, "TEXT", "default", false, false, false>;
+declare const integer: <TName extends string, TMode extends Mode = "default">(name: TName, config?: {
+    mode?: TMode;
+}) => SQLiteColumn<TName, "INTEGER", "default" | TMode, false, false, false>;
+declare const real: <TName extends string>(name: TName) => SQLiteColumn<TName, "REAL", "default", false, false, false>;
+declare const blob: <TName extends string>(name: TName) => SQLiteColumn<TName, "BLOB", "default", false, false, false>;
+declare const boolean: <TName extends string>(name: TName) => SQLiteColumn<TName, "BOOLEAN", "default", false, false, false>;
+type AnySQLiteColumn = SQLiteColumn<any, any, any, any, any, any>;
+type AnyTable = Table<Record<string, AnySQLiteColumn>, string>;
+type InferSelectModel<T extends AnyTable> = {
+    [K in keyof T["_"]["columns"]]: ExtractColumnType<T["_"]["columns"][K]>;
+};
+type RequiredColumns<TColumns extends Record<string, AnySQLiteColumn>> = {
+    [K in keyof TColumns]: TColumns[K]["_"]["notNull"] extends true ? TColumns[K]["_"]["hasDefault"] extends true ? never : K : never;
+}[keyof TColumns];
+type OptionalColumns<TColumns extends Record<string, AnySQLiteColumn>> = {
+    [K in keyof TColumns]: TColumns[K]["_"]["notNull"] extends true ? TColumns[K]["_"]["hasDefault"] extends true ? K : never : K;
+}[keyof TColumns];
+type InferInsertModel<T extends AnyTable> = {
+    [K in RequiredColumns<T["_"]["columns"]>]: ExtractColumnType<T["_"]["columns"][K]>;
+} & {
+    [K in OptionalColumns<T["_"]["columns"]>]?: ExtractColumnType<T["_"]["columns"][K]>;
+};
+declare class Table<TColumns extends Record<string, AnySQLiteColumn>, TTableName extends string> {
+    _: {
+        name: TTableName;
+        columns: TColumns;
     };
-}) => SQL;
-declare const notExists: (subquery: SQL | {
-    toSQL: () => {
-        clause: string;
-        bindings: any[];
+    constructor(name: TTableName, columns: TColumns);
+}
+declare const sqliteTable: <TTableName extends string, TColumns extends Record<string, AnySQLiteColumn>>(tableName: TTableName, columns: TColumns) => Table<TColumns, TTableName>;
+type SQLCondition = {
+    sql: string;
+    params: any[];
+};
+declare const eq: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const and: (...conditions: SQLCondition[]) => SQLCondition;
+declare const or: (...conditions: SQLCondition[]) => SQLCondition;
+declare const gt: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const gte: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const lt: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const lte: <T>(column: AnySQLiteColumn, value: T) => SQLCondition;
+declare const like: (column: AnySQLiteColumn, pattern: string) => SQLCondition;
+declare const isNull: (column: AnySQLiteColumn) => SQLCondition;
+declare const isNotNull: (column: AnySQLiteColumn) => SQLCondition;
+declare const inArray: <T>(column: AnySQLiteColumn, values: T[]) => SQLCondition;
+declare class BaseQueryBuilder {
+    protected db: Database;
+    protected query: string;
+    protected params: any[];
+    constructor(db: Database);
+    where(condition: SQLCondition): this;
+    orderBy(column: AnySQLiteColumn, direction?: "ASC" | "DESC"): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    build(): {
+        sql: string;
+        params: any[];
     };
-}) => SQL;
-declare const asc: (column: Column) => string;
-declare const desc: (column: Column) => string;
-
-type InferInsert<T> = T extends {
-    $inferInsert: infer I;
-} ? I : never;
-type InferSelect<T> = T extends {
-    $inferSelect: infer S;
-} ? S : never;
-type WithSpec = Record<string, boolean | {
-    with?: WithSpec;
-    columns?: string[];
-}>;
-type FindManyOptions<TTable extends Table<any>> = {
-    with?: WithSpec;
-    join?: boolean;
-    columns?: (keyof InferSelect<TTable>)[] | Record<keyof InferSelect<TTable>, boolean>;
-    where?: SQL | Partial<InferSelect<TTable>> | ((table: TTable, ops: {
-        eq: typeof eq;
-        ne: typeof ne;
-        gt: typeof gt;
-        gte: typeof gte;
-        lt: typeof lt;
-        lte: typeof lte;
-        like: typeof like;
-    }) => SQL);
-    orderBy?: (keyof InferSelect<TTable>)[] | ((table: TTable, ops: {
-        asc: typeof asc;
-        desc: typeof desc;
-    }) => (string | SQL)[]);
-    limit?: number;
-    offset?: number;
-};
-type FindFirstOptions<TTable extends Table<any>> = Omit<FindManyOptions<TTable>, "limit" | "offset">;
-declare class SelectQueryBuilder<T> {
-    private _table;
-    private _selectedColumns;
-    private _joins;
-    private _where;
-    private _orderBy;
-    private _limit;
-    private _offset;
-    private _groupBy;
-    private _having;
-    private _distinct;
-    private _dbProvider;
-    constructor(dbProvider: () => Promise<Database>, fields?: Record<string, Column<any>>);
-    distinct(): this;
-    select(fields: Record<string, Column<any> | SQL>): this;
-    from(table: Table<any>): this;
-    where(...conditions: (SQL | undefined)[]): this;
-    leftJoin(otherTable: Table<any>, on: SQL): this;
-    groupBy(...exprs: (Column | string)[]): this;
-    having(...conditions: SQL[]): this;
-    orderBy(...clauses: (string | Column<any> | SQL)[]): this;
-    limit(value: number): this;
-    offset(value: number): this;
-    execute(): Promise<T[]>;
-    iterator(): Promise<AsyncIterableIterator<T>>;
+}
+declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable["_"]["columns"])[] | undefined = undefined> extends BaseQueryBuilder {
+    private table;
+    private columns?;
+    constructor(db: Database, table: TTable, columns?: TSelectedColumns | undefined);
+    execute(): Promise<TSelectedColumns extends (keyof TTable["_"]["columns"])[] ? Pick<InferSelectModel<TTable>, TSelectedColumns[number]>[] : InferSelectModel<TTable>[]>;
+}
+declare class InsertQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
+    private table;
+    private dataSets;
+    constructor(db: Database, table: T);
+    values(data: Partial<InferInsertModel<T>> | Partial<InferInsertModel<T>>[]): this;
+    execute(): Promise<number>;
+}
+declare class UpdateQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
+    private table;
+    private updateData;
+    constructor(db: Database, table: T);
+    set(data: Partial<InferInsertModel<T>>): this;
+    execute(): Promise<number>;
+}
+declare class DeleteQueryBuilder<T extends AnyTable> extends BaseQueryBuilder {
+    private table;
+    constructor(db: Database, table: T);
+    execute(): Promise<number>;
 }
 declare class TauriORM {
-    query: Record<string, any>;
-    private _tables;
-    private _relations;
-    private _dbPromise;
-    constructor(dbUri: string);
-    private getDb;
-    configureQuery(tables: Record<string, Table<any>>, relations: Record<string, Record<string, RelationConfig>>): void;
-    select<TFields extends Record<string, Column<any>>>(fields: TFields): SelectQueryBuilder<{
-        [K in keyof TFields]: TFields[K]["_dataType"];
-    }>;
-    select<T = any>(fields?: undefined): SelectQueryBuilder<T>;
-    selectDistinct<TFields extends Record<string, Column<any>>>(fields: TFields): SelectQueryBuilder<{
-        [K in keyof TFields]: TFields[K]["_dataType"];
-    }>;
-    selectDistinct<T = any>(fields?: undefined): SelectQueryBuilder<T>;
-    insert<TTable extends Table<any>>(table: TTable): {
-        _table: TTable;
-        _rows: Array<InferInsert<TTable>>;
-        _selectSql: {
-            clause: string;
-            bindings: any[];
-        } | null;
-        _conflict: null | {
-            kind: "doNothing";
-            target?: string | string[];
-            where?: SQL;
-        } | {
-            kind: "doUpdate";
-            target: string | string[];
-            targetWhere?: SQL;
-            set: Record<string, any>;
-            setWhere?: SQL;
-        };
-        _returning: null | "__RETURNING_ID__" | Record<string, Column<any>>;
-        values(rowOrRows: InferInsert<TTable> | Array<InferInsert<TTable>>): /*elided*/ any;
-        select(qb: {
-            toSQL?: () => {
-                clause: string;
-                bindings: any[];
-            };
-        } | SQL): /*elided*/ any;
-        returning(fields?: Record<string, Column<any>>): any;
-        $returningId(): any;
-        onConflictDoNothing(opts?: {
-            target?: Column<any> | Column<any>[];
-            where?: SQL;
-        }): /*elided*/ any;
-        onConflictDoUpdate(opts: {
-            target: Column<any> | Column<any>[];
-            targetWhere?: SQL;
-            set: Record<string, any>;
-            setWhere?: SQL;
-        }): /*elided*/ any;
-        execute(): Promise<any>;
-        _buildConflictClause(): string;
-        _executeWithReturning(db: any, query: string, bindings: any[]): Promise<any>;
-    };
-    update<TTable extends Table<any>>(table: TTable): {
-        _table: TTable;
-        _data: Partial<InferInsert<TTable>> | null;
-        _where: Record<string, any> | SQL | null;
-        _orderBy: Array<string | SQL>;
-        _limit: number | null;
-        _from: Table<any> | null;
-        _returning: null | Record<string, Column<any>>;
-        set(data: Partial<InferInsert<TTable>>): /*elided*/ any;
-        where(cond: Record<string, any> | SQL): /*elided*/ any;
-        orderBy(...clauses: (string | Column<any> | SQL)[]): /*elided*/ any;
-        limit(n: number): /*elided*/ any;
-        from(tbl: Table<any>): /*elided*/ any;
-        returning(fields?: Record<string, Column<any>>): any;
-        execute(): Promise<unknown>;
-    };
-    delete<TTable extends Table<any>>(table: TTable): {
-        _table: TTable;
-        _where: Partial<InferInsert<TTable>> | SQL | null;
-        _orderBy: Array<string | SQL>;
-        _limit: number | null;
-        _returning: null | Record<string, Column<any>>;
-        where(cond: Partial<InferInsert<TTable>> | SQL): /*elided*/ any;
-        orderBy(...clauses: (string | Column<any> | SQL)[]): /*elided*/ any;
-        limit(n: number): /*elided*/ any;
-        returning(fields?: Record<string, Column<any>>): any;
-        execute(): Promise<unknown>;
-    };
-    run(query: string, bindings?: any[]): Promise<void>;
-    private formatDefaultValue;
-    private generateCreateTableSql;
-    createTableIfNotExists(table: Table<any>): Promise<void>;
-    createTablesIfNotExist(tables: Table<any>[]): Promise<void>;
-    private generateCreateIndexSqls;
-    private createIndexesForTable;
-    private ensureMigrationsTable;
-    private hasMigration;
-    private recordMigration;
-    migrate(tables: Table<any>[], options?: {
-        name?: string;
-        track?: boolean;
-    }): Promise<void>;
-    configure<TTables extends Record<string, Table<any>>, TRelDefs extends Record<string, Record<string, RelationConfig>> = Record<string, Record<string, RelationConfig>>>(tables: TTables, relDefs?: TRelDefs): this & {
-        query: {
-            [K in keyof TTables]: {
-                findMany: (opts?: FindManyOptions<TTables[K]>) => Promise<Array<InferSelect<TTables[K]>>>;
-                findFirst: (opts?: FindFirstOptions<TTables[K]>) => Promise<InferSelect<TTables[K]> | null>;
-            };
-        };
-    };
-    migrateConfigured(options?: {
-        name?: string;
-        track?: boolean;
-    }): Promise<void>;
-    diffSchema(): Promise<{
-        extraTables: string[];
-        missingTables: string[];
-        tables: Record<string, {
-            missingColumns: string[];
-            extraColumns: string[];
-            changedColumns: Array<{
-                name: string;
-                diffs: {
-                    type?: boolean;
-                    pk?: boolean;
-                    notNull?: boolean;
-                    default?: boolean;
-                };
-            }>;
-        }>;
-    }>;
-    generate(): Promise<{
-        statements: string[];
-    }>;
-    migrateCli(opts?: {
-        name?: string;
-        track?: boolean;
-    }): Promise<void>;
-    push(opts?: {
-        dropExtraColumns?: boolean;
-        preserveData?: boolean;
-    }): Promise<void>;
-    pull(): Promise<Record<string, any>>;
-    studio(): Promise<{
-        driver: string;
-        path: any;
-    }>;
+    private db;
+    private tables;
+    constructor(db: Database, schema?: Record<string, AnyTable> | undefined);
+    migrate(): Promise<void>;
+    select<T extends AnyTable, C extends (keyof T["_"]["columns"])[] | undefined = undefined>(table: T, columns?: C): SelectQueryBuilder<T, C>;
+    insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
+    update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;
+    delete<T extends AnyTable>(table: T): DeleteQueryBuilder<T>;
+    transaction<T>(callback: (tx: TauriORM) => Promise<T>): Promise<T>;
     private ensureSchemaMeta;
     private getSchemaMeta;
     private setSchemaMeta;
     private normalizeColumn;
     private computeModelSignature;
     getSchemaSignature(): string;
-    printSchemaDiff(): Promise<void>;
     isSchemaDirty(): Promise<{
         dirty: boolean;
         current: string;
         stored: string | null;
     }>;
-    migrateIfDirty(options?: {
-        name?: string;
-        track?: boolean;
-    }): Promise<boolean>;
-    pullSchema(): Promise<Record<string, any>>;
-    private buildCreateTableSQL;
-    private tableExists;
-    forcePush(options?: {
-        dropExtraColumns?: boolean;
-        preserveData?: boolean;
-    }): Promise<void>;
-    private forcePushForTables;
+    migrateIfDirty(): Promise<boolean>;
 }
-type OneConfig = {
-    fields?: Column[];
-    references?: Column[];
-    relationName?: string;
-};
-type ManyConfig = {
-    relationName?: string;
-};
-type RelationBuilderCtx = {
-    one: (table: Table<any>, cfg?: OneConfig) => OneRelation;
-    many: (table: Table<any>, cfg?: ManyConfig) => ManyRelation;
-};
-type OneRelation = {
-    kind: "one";
-    table: Table<any>;
-    cfg?: OneConfig;
-};
-type ManyRelation = {
-    kind: "many";
-    table: Table<any>;
-    cfg?: ManyConfig;
-};
-declare function relations(baseTable: Table<any>, builder: (ctx: RelationBuilderCtx) => Record<string, OneRelation | ManyRelation>): Record<string, OneRelation | ManyRelation>;
-type RelationConfig = OneRelation | ManyRelation;
-declare function makeQueryAPI(tables: Record<string, Table<any>>, relDefs: Record<string, Record<string, RelationConfig>>, dbProvider: () => Promise<Database>): { [K in keyof typeof tables]: {
-    findMany: (opts?: {
-        with?: WithSpec;
-        join?: boolean;
-        columns?: string[];
-    }) => Promise<any[]>;
-    findFirst: (opts?: {
-        with?: WithSpec;
-        join?: boolean;
-        columns?: string[];
-    }) => Promise<any | null>;
-}; };
+declare const relations: <T extends AnyTable, R extends Record<string, any>>(table: T, relationsCallback: (helpers: {
+    one: any;
+    many: any;
+}) => R) => R;
 
-export { type BlobMode, type CheckSpec, type Column, type ColumnBuilder, type ForeignKeySpec, type IndexSpec, type IntegerMode, type ManyRelation, type NumericMode, type OneRelation, type PrimaryKeySpec, type SQL, type SQLExpression, type Table, TauriORM, type UniqueSpec, type UpdateDeleteAction, and, asc, between, blob, boolean, check, defineTable, desc, eq, exists, foreignKey, getQualifiedName, gt, gte, ilike, inArray, increments, index, integer, isNotNull, isNull, like, lt, lte, makeQueryAPI, ne, not, notBetween, notExists, notIlike, notInArray, numeric, or, primaryKey, raw, real, relations, sql, text, timestamp, unique, uniqueIndex };
+export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, type ColumnOptions, DeleteQueryBuilder, type InferInsertModel, type InferSelectModel, InsertQueryBuilder, type Mode, type SQLCondition, SQLiteColumn, SelectQueryBuilder, Table, TauriORM, UpdateQueryBuilder, and, blob, boolean, eq, gt, gte, inArray, integer, isNotNull, isNull, like, lt, lte, or, real, relations, sqliteTable, text };