bun-query-builder 0.2.26 → 0.2.27

package/dist/browser.d.ts

@@ -14,6 +14,14 @@ export declare function getBrowserConfig(): BrowserConfig;
  * Check if we're in a browser environment
  */
 export declare function isBrowser(): boolean;
+/**
+ * Get the current auth token
+ */
+declare function getAuthToken(): Promise<string | null>;
+/**
+ * Build fetch headers with auth
+ */
+declare function buildHeaders(): Promise<HeadersInit>;
 /**
  * Create a browser query builder for a table
  */
@@ -53,19 +61,17 @@ export declare function createBrowserDb<Tables extends Record<string, any>>(): {
  * // type: ('admin' | 'user' | 'moderator')[]
  * ```
  */
-export declare function createBrowserModel<const TDef extends BrowserModelDefinition>(definition: TDef): void;
+export declare function createBrowserModel<const TDef extends BrowserModelDefinition>(definition: TDef): unknown;
 /**
  * Auth helpers for browser
  * @defaultValue
  * ```ts
  * {
- *   login: (credentials?: { email: string, password: string }): Promise<{ user: Record<string, unknown>, token: string }> {
- *     const response) => Promise<unknown>,
- *   register: (data?: { name: string, email: string, password: string }): Promise<{ user: Record<string, unknown>, token: string }> {
- *     const response) => Promise<unknown>,
- *   logout: () => unknown,
- *   user: () => unknown,
- *   check: () => unknown
+ *   login: (credentials: { email: string, password: string }) => Promise<{ user: Record<string, unknown>, token: string }>,
+ *   register: (data: { name: string, email: string, password: string }) => Promise<{ user: Record<string, unknown>, token: string }>,
+ *   logout: () => Promise<void>,
+ *   user: () => Promise<Record<string, unknown> | null>,
+ *   check: () => Promise<boolean>
  * }
  * ```
  */

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { config } from './config';
 import { resetConnection } from './db';
 import type { DatabaseSchema } from './schema';
+import type { DriverConnection } from './db';
 import type { QueryHooks } from './types';
 import type { SchemaMeta } from './meta';
 /**
@@ -59,20 +60,24 @@ declare interface RawExpression {
   raw: string
 }
 export declare interface WhereRaw {
-  raw: any
+  raw: SqlFragment
 }
 export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> {
   distinct: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   distinctOn: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   selectRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  where: (expr: WhereExpression<DB[TTable]['columns']> | string, op?: WhereOperator, value?: any) => SelectQueryBuilder<DB, TTable, TSelected>
+  where: <K extends keyof DB[TTable]['columns'] & string>(
+    expr: WhereExpression<DB[TTable]['columns']> | K,
+    op?: WhereOperator,
+    value?: WhereValue<DB[TTable]['columns'][K]>,
+  ) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereColumn: (left: string, op: WhereOperator, right: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereColumn: (left: string, op: WhereOperator, right: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereIn: (column: keyof DB[TTable]['columns'] & string, values: any[] | { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orWhereIn: (column: keyof DB[TTable]['columns'] & string, values: any[] | { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereNotIn: (column: keyof DB[TTable]['columns'] & string, values: any[] | { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orWhereNotIn: (column: keyof DB[TTable]['columns'] & string, values: any[] | { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereIn: <K extends keyof DB[TTable]['columns'] & string>(column: K, values: DB[TTable]['columns'][K][] | { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orWhereIn: <K extends keyof DB[TTable]['columns'] & string>(column: K, values: DB[TTable]['columns'][K][] | { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereNotIn: <K extends keyof DB[TTable]['columns'] & string>(column: K, values: DB[TTable]['columns'][K][] | { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orWhereNotIn: <K extends keyof DB[TTable]['columns'] & string>(column: K, values: DB[TTable]['columns'][K][] | { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereLike: (column: keyof DB[TTable]['columns'] & string, pattern: string, caseSensitive?: boolean) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereILike?: (column: keyof DB[TTable]['columns'] & string, pattern: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereLike: (column: keyof DB[TTable]['columns'] & string, pattern: string, caseSensitive?: boolean) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -81,18 +86,26 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   whereNotILike?: (column: keyof DB[TTable]['columns'] & string, pattern: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereNotLike: (column: keyof DB[TTable]['columns'] & string, pattern: string, caseSensitive?: boolean) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereNotILike?: (column: keyof DB[TTable]['columns'] & string, pattern: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereAny: (columns: (keyof DB[TTable]['columns'] & string)[], op: WhereOperator, value: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereAll: (columns: (keyof DB[TTable]['columns'] & string)[], op: WhereOperator, value: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereNone: (columns: (keyof DB[TTable]['columns'] & string)[], op: WhereOperator, value: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereNested: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orWhereNested: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereAny: <K extends keyof DB[TTable]['columns'] & string>(columns: K[], op: WhereOperator, value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereAll: <K extends keyof DB[TTable]['columns'] & string>(columns: K[], op: WhereOperator, value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereNone: <K extends keyof DB[TTable]['columns'] & string>(columns: K[], op: WhereOperator, value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereNested: (fragment: { toSQL: () => string } | SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orWhereNested: (fragment: { toSQL: () => string } | SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereDate: (column: string, op: WhereOperator, date: string | Date) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereBetween: (column: string, start: any, end: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereNotBetween: (column: string, start: any, end: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereBetween: <K extends keyof DB[TTable]['columns'] & string>(column: K, start: DB[TTable]['columns'][K], end: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereNotBetween: <K extends keyof DB[TTable]['columns'] & string>(column: K, start: DB[TTable]['columns'][K], end: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonContains: (column: string, json: unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonPath?: (path: string, op: WhereOperator, value: unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  andWhere: (expr: WhereExpression<DB[TTable]['columns']> | string, op?: WhereOperator, value?: any) => SelectQueryBuilder<DB, TTable, TSelected>
-  orWhere: (expr: WhereExpression<DB[TTable]['columns']> | string, op?: WhereOperator, value?: any) => SelectQueryBuilder<DB, TTable, TSelected>
+  andWhere: <K extends keyof DB[TTable]['columns'] & string>(
+    expr: WhereExpression<DB[TTable]['columns']> | K,
+    op?: WhereOperator,
+    value?: WhereValue<DB[TTable]['columns'][K]>,
+  ) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orWhere: <K extends keyof DB[TTable]['columns'] & string>(
+    expr: WhereExpression<DB[TTable]['columns']> | K,
+    op?: WhereOperator,
+    value?: WhereValue<DB[TTable]['columns'][K]>,
+  ) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orderBy: (column: ColumnName<DB, TTable>, direction?: SortDirection) => SelectQueryBuilder<DB, TTable, TSelected>
   orderByDesc: (column: ColumnName<DB, TTable>) => SelectQueryBuilder<DB, TTable, TSelected>
   inRandomOrder: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -102,14 +115,14 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   limit: (n: number) => SelectQueryBuilder<DB, TTable, TSelected>
   offset: (n: number) => SelectQueryBuilder<DB, TTable, TSelected>
   withTimeout?: (ms: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  abort?: (signal: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  abort?: (signal: AbortSignal) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   join: <T2 extends keyof DB & string>(
     table: T2,
     onLeft: JoinColumn<DB, TJoined | T2>,
     operator: '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like',
     onRight: JoinColumn<DB, TJoined | T2>,
   ) => SelectQueryBuilder<DB, TTable, TSelected, TJoined | T2>
-  joinSub: (sub: { toSQL: () => any }, alias: string, onLeft: string, operator: WhereOperator, onRight: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  joinSub: (sub: { toSQL: () => string }, alias: string, onLeft: string, operator: WhereOperator, onRight: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   innerJoin: <T2 extends keyof DB & string>(
     table: T2,
     onLeft: JoinColumn<DB, TJoined | T2>,
@@ -122,7 +135,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
     operator: '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like',
     onRight: JoinColumn<DB, TJoined | T2>,
   ) => SelectQueryBuilder<DB, TTable, TSelected, TJoined | T2>
-  leftJoinSub: (sub: { toSQL: () => any }, alias: string, onLeft: string, operator: WhereOperator, onRight: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  leftJoinSub: (sub: { toSQL: () => string }, alias: string, onLeft: string, operator: WhereOperator, onRight: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   rightJoin: <T2 extends keyof DB & string>(
     table: T2,
     onLeft: JoinColumn<DB, TJoined | T2>,
@@ -130,10 +143,10 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
     onRight: JoinColumn<DB, TJoined | T2>,
   ) => SelectQueryBuilder<DB, TTable, TSelected, TJoined | T2>
   crossJoin: <T2 extends keyof DB & string>(table: T2) => SelectQueryBuilder<DB, TTable, TSelected, TJoined | T2>
-  crossJoinSub: (sub: { toSQL: () => any }, alias: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  crossJoinSub: (sub: { toSQL: () => string }, alias: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   groupBy: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   groupByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  having: (expr: WhereExpression<any>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  having: (expr: WhereExpression<TSelected>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   havingRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   addSelect: (...columns: ((keyof DB[TTable]['columns'] & string) | string | SqlFragment)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   select?: {
@@ -142,38 +155,38 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   }
   selectAll?: () => SelectQueryBuilder<DB, TTable, DB[TTable]['columns'], TJoined>
   orderByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  union: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  unionAll: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  union: (other: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  unionAll: (other: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   forPage: (page: number, perPage: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  selectAllRelations?: () => SelectQueryBuilder<DB, TTable, any, TJoined>
+  selectAllRelations?: () => SelectQueryBuilder<DB, TTable, TSelected & Record<string, unknown>, TJoined>
   whereNull?: (column: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereNotNull?: (column: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  whereExists?: (subquery: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereExists?: (subquery: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonDoesntContain?: (column: string, json: unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonContainsKey?: (path: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonDoesntContainKey?: (path: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonLength?: (path: string, opOrLen: WhereOperator | number, len?: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  with?: (...relations: WithRelationArg<DB, TTable>[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  whereHas?: (relation: TableRelationName<DB, TTable>, callback?: (qb: any) => any) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  whereDoesntHave?: (relation: TableRelationName<DB, TTable>, callback?: (qb: any) => any) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  has?: (relation: TableRelationName<DB, TTable>) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  doesntHave?: (relation: TableRelationName<DB, TTable>) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  withCount?: (...relations: TableRelationName<DB, TTable>[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  withSum?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  withAvg?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  withMax?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  withMin?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  withPivot?: (relation: TableRelationName<DB, TTable>, ...columns: string[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  wherePivot?: (relation: TableRelationName<DB, TTable>, column: string, opOrValue: any, value?: any) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  wherePivotIn?: (relation: TableRelationName<DB, TTable>, column: string, values: any[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  wherePivotNotIn?: (relation: TableRelationName<DB, TTable>, column: string, values: any[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  wherePivotNull?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  wherePivotNotNull?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, any>
-  applyPivotColumns?: () => SelectQueryBuilder<DB, TTable, TSelected, any>
+  with?: (...relations: WithRelationArg<DB, TTable>[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereHas?: <R extends TableRelationName<DB, TTable>>(relation: R, callback?: (qb: RelationQueryBuilder<DB, TTable, R>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereDoesntHave?: <R extends TableRelationName<DB, TTable>>(relation: R, callback?: (qb: RelationQueryBuilder<DB, TTable, R>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  has?: (relation: TableRelationName<DB, TTable>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  doesntHave?: (relation: TableRelationName<DB, TTable>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  withCount?: <R extends TableRelationName<DB, TTable>>(...relations: R[]) => SelectQueryBuilder<DB, TTable, TSelected & { [K in `${R}_count`]: number }, TJoined>
+  withSum?: <R extends TableRelationName<DB, TTable>, K extends keyof DB[RelatedTableName<DB, TTable, R>]['columns'] & string>(relation: R, column: K) => SelectQueryBuilder<DB, TTable, TSelected & { [P in `${R}_sum_${K}`]: number }, TJoined>
+  withAvg?: <R extends TableRelationName<DB, TTable>, K extends keyof DB[RelatedTableName<DB, TTable, R>]['columns'] & string>(relation: R, column: K) => SelectQueryBuilder<DB, TTable, TSelected & { [P in `${R}_avg_${K}`]: number }, TJoined>
+  withMax?: <R extends TableRelationName<DB, TTable>, K extends keyof DB[RelatedTableName<DB, TTable, R>]['columns'] & string>(relation: R, column: K) => SelectQueryBuilder<DB, TTable, TSelected & { [P in `${R}_max_${K}`]: DB[RelatedTableName<DB, TTable, R>]['columns'][K] | null }, TJoined>
+  withMin?: <R extends TableRelationName<DB, TTable>, K extends keyof DB[RelatedTableName<DB, TTable, R>]['columns'] & string>(relation: R, column: K) => SelectQueryBuilder<DB, TTable, TSelected & { [P in `${R}_min_${K}`]: DB[RelatedTableName<DB, TTable, R>]['columns'][K] | null }, TJoined>
+  withPivot?: (relation: TableRelationName<DB, TTable>, ...columns: string[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  wherePivot?: (relation: TableRelationName<DB, TTable>, column: string, opOrValue: unknown, value?: unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  wherePivotIn?: (relation: TableRelationName<DB, TTable>, column: string, values: unknown[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  wherePivotNotIn?: (relation: TableRelationName<DB, TTable>, column: string, values: unknown[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  wherePivotNull?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  wherePivotNotNull?: (relation: TableRelationName<DB, TTable>, column: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  applyPivotColumns?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   lockForUpdate: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   sharedLock: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  withCTE: (name: string, sub: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  withRecursive: (name: string, sub: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  withCTE: (name: string, sub: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  withRecursive: (name: string, sub: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   value: <K extends keyof TSelected & string>(column: K) => Promise<SelectedRow<DB, TTable, TSelected>[K]>
   pluck: {
     <K extends keyof TSelected & string>(column: K): Promise<SelectedRow<DB, TTable, TSelected>[K][]>
@@ -182,17 +195,17 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   exists: () => Promise<boolean>
   doesntExist: () => Promise<boolean>
   cursorPaginate: (perPage: number, cursor?: string | number, column?: string, direction?: 'asc' | 'desc') => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, nextCursor: string | number | null } }>
-  chunk: (size: number, handler: (rows: any[]) => Promise<void> | void) => Promise<void>
-  chunkById: (size: number, column?: string, handler?: (rows: any[]) => Promise<void> | void) => Promise<void>
-  eachById: (size: number, column?: string, handler?: (row: any) => Promise<void> | void) => Promise<void>
-  when: (condition: any, then: (qb: any) => any, otherwise?: (qb: any) => any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  tap: (fn: (qb: any) => any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  chunk: (size: number, handler: (rows: SelectedRow<DB, TTable, TSelected>[]) => Promise<void> | void) => Promise<void>
+  chunkById: (size: number, column?: keyof DB[TTable]['columns'] & string, handler?: (rows: SelectedRow<DB, TTable, TSelected>[]) => Promise<void> | void) => Promise<void>
+  eachById: (size: number, column?: keyof DB[TTable]['columns'] & string, handler?: (row: SelectedRow<DB, TTable, TSelected>) => Promise<void> | void) => Promise<void>
+  when: (condition: unknown, then: (qb: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => unknown, otherwise?: (qb: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  tap: (fn: (qb: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   dump: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   dd: () => never
-  explain: () => Promise<any[]>
-  simple: () => any
+  explain: () => Promise<Record<string, unknown>[]>
+  simple: () => unknown
   toText?: () => string
-  paginate: (perPage: number, page?: number, opts?: { tx?: { unsafe: (sql: string, params?: any[]) => any } }) => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, page: number, total: number, lastPage: number } }>
+  paginate: (perPage: number, page?: number, opts?: { tx?: { unsafe: (sql: string, params?: unknown[]) => unknown } }) => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, page: number, total: number, lastPage: number } }>
   simplePaginate: (perPage: number, page?: number) => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, page: number, hasMore: boolean } }>
   toSQL: () => string
   execute: () => Promise<SelectedRow<DB, TTable, TSelected>[]>
@@ -201,26 +214,26 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   get: () => Promise<SelectedRow<DB, TTable, TSelected>[]>
   first: () => Promise<SelectedRow<DB, TTable, TSelected> | undefined>
   firstOrFail: () => Promise<SelectedRow<DB, TTable, TSelected>>
-  find: (id: any) => Promise<SelectedRow<DB, TTable, TSelected> | undefined>
-  findOrFail: (id: any) => Promise<SelectedRow<DB, TTable, TSelected>>
-  findMany: (ids: any[]) => Promise<TSelected[]>
-  lazy: () => AsyncIterable<TSelected>
-  lazyById: () => AsyncIterable<TSelected>
+  find: (id: PrimaryKeyValue<DB, TTable>) => Promise<SelectedRow<DB, TTable, TSelected> | undefined>
+  findOrFail: (id: PrimaryKeyValue<DB, TTable>) => Promise<SelectedRow<DB, TTable, TSelected>>
+  findMany: (ids: PrimaryKeyValue<DB, TTable>[]) => Promise<SelectedRow<DB, TTable, TSelected>[]>
+  lazy: () => AsyncIterable<SelectedRow<DB, TTable, TSelected>>
+  lazyById: () => AsyncIterable<SelectedRow<DB, TTable, TSelected>>
   pipe: <R>(fn: (qb: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => R) => R
   count: () => Promise<number>
-  avg: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
-  sum: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
+  avg: (column: NumericColumnName<DB[TTable]['columns']>) => Promise<number>
+  sum: (column: NumericColumnName<DB[TTable]['columns']>) => Promise<number>
   max: <K extends keyof DB[TTable]['columns'] & string>(column: K) => Promise<DB[TTable]['columns'][K] | null>
   min: <K extends keyof DB[TTable]['columns'] & string>(column: K) => Promise<DB[TTable]['columns'][K] | null>
   readonly rows: TSelected[]
   readonly row: TSelected
-  values: () => Promise<any[][]>
-  toParams?: () => any[]
-  raw: () => Promise<any[][]>
+  values: () => Promise<unknown[][]>
+  toParams?: () => unknown[]
+  raw: () => Promise<unknown[][]>
   cancel: () => void
   withTrashed?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   onlyTrashed?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  scope?: (name: string, value?: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  scope?: (name: string, value?: unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   clone?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   cache?: (ttlMs?: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   rowNumber?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -238,7 +251,11 @@ export declare interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTab
 }
 export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
   set: (values: Partial<{ [K in keyof DB[TTable]['columns']]: DB[TTable]['columns'][K] | SqlFragment }>) => UpdateQueryBuilder<DB, TTable>
-  where: (expr: WhereExpression<DB[TTable]['columns']> | string | SqlFragment, op?: WhereOperator, value?: any) => UpdateQueryBuilder<DB, TTable>
+  where: <K extends keyof DB[TTable]['columns'] & string>(
+    expr: WhereExpression<DB[TTable]['columns']> | K | SqlFragment,
+    op?: WhereOperator,
+    value?: WhereValue<DB[TTable]['columns'][K]>,
+  ) => UpdateQueryBuilder<DB, TTable>
   whereNull: <K extends keyof DB[TTable]['columns'] & string>(column: K) => UpdateQueryBuilder<DB, TTable>
   whereNotNull: <K extends keyof DB[TTable]['columns'] & string>(column: K) => UpdateQueryBuilder<DB, TTable>
   returning: <K extends keyof DB[TTable]['columns'] & string>(...cols: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
@@ -249,7 +266,11 @@ export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirstOrThrow: () => Promise<{ numUpdatedRows: number }>
 }
 export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
-  where: (expr: WhereExpression<DB[TTable]['columns']> | string, op?: WhereOperator, value?: any) => DeleteQueryBuilder<DB, TTable>
+  where: <K extends keyof DB[TTable]['columns'] & string>(
+    expr: WhereExpression<DB[TTable]['columns']> | K,
+    op?: WhereOperator,
+    value?: WhereValue<DB[TTable]['columns'][K]>,
+  ) => DeleteQueryBuilder<DB, TTable>
   whereNull: <K extends keyof DB[TTable]['columns'] & string>(column: K) => DeleteQueryBuilder<DB, TTable>
   whereNotNull: <K extends keyof DB[TTable]['columns'] & string>(column: K) => DeleteQueryBuilder<DB, TTable>
   returning: <K extends keyof DB[TTable]['columns'] & string>(...cols: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
@@ -274,26 +295,26 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
     <TTable extends keyof DB & string>(
       table: TTable,
       ...columns: ((keyof DB[TTable]['columns'] & string) | `${string} as ${string}`)[]
-    ): SelectQueryBuilder<DB, TTable, any>
+    ): SelectQueryBuilder<DB, TTable, Record<string, unknown>>
   }
   selectFrom: <TTable extends keyof DB & string>(table: TTable) => TypedSelectQueryBuilder<DB, TTable, DB[TTable]['columns'], TTable, `SELECT * FROM ${TTable}`>
   insertInto: <TTable extends keyof DB & string>(table: TTable) => TypedInsertQueryBuilder<DB, TTable>
   updateTable: <TTable extends keyof DB & string>(table: TTable) => UpdateQueryBuilder<DB, TTable>
   deleteFrom: <TTable extends keyof DB & string>(table: TTable) => DeleteQueryBuilder<DB, TTable>
   table: <TTable extends keyof DB & string>(table: TTable) => TableQueryBuilder<DB, TTable>
-  selectFromSub: (sub: { toSQL: () => any }, alias: string) => SelectQueryBuilder<DB, keyof DB & string, any>
-  sql: any
-  raw: (strings: TemplateStringsArray, ...values: any[]) => any
-  simple: (strings: TemplateStringsArray, ...values: any[]) => any
-  unsafe: (query: string, params?: any[]) => Promise<any>
-  file: (path: string, params?: any[]) => Promise<any>
+  selectFromSub: (sub: { toSQL: () => string }, alias: string) => SelectQueryBuilder<DB, keyof DB & string, Record<string, unknown>>
+  sql: DriverConnection
+  raw: (strings: TemplateStringsArray, ...values: unknown[]) => SqlFragment
+  simple: (strings: TemplateStringsArray, ...values: unknown[]) => unknown
+  unsafe: <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, params?: unknown[]) => Promise<TRow[]>
+  file: <TRow extends Record<string, unknown> = Record<string, unknown>>(path: string, params?: unknown[]) => Promise<TRow[]>
   reserve: () => Promise<(QueryBuilder<DB> & { release: () => void })>
   close: (opts?: { timeout?: number }) => Promise<void>
-  listen: (channel: string, handler?: (payload: any) => void) => Promise<void>
+  listen: (channel: string, handler?: (payload: unknown) => void) => Promise<void>
   unlisten: (channel?: string) => Promise<void>
-  notify: (channel: string, payload?: any) => Promise<void>
-  copyTo: (queryOrTable: string, options?: Record<string, any>) => Promise<any>
-  copyFrom: (queryOrTable: string, source: AsyncIterable<any> | Iterable<any>, options?: Record<string, any>) => Promise<any>
+  notify: (channel: string, payload?: unknown) => Promise<void>
+  copyTo: (queryOrTable: string, options?: Record<string, unknown>) => Promise<unknown>
+  copyFrom: (queryOrTable: string, source: AsyncIterable<unknown> | Iterable<unknown>, options?: Record<string, unknown>) => Promise<unknown>
   ping: () => Promise<boolean>
   waitForReady: (opts?: { attempts?: number, delayMs?: number }) => Promise<void>
   transaction: <T>(fn: (tx: QueryBuilder<DB>) => Promise<T> | T, options?: TransactionOptions) => Promise<T>
@@ -303,16 +324,16 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   rollbackDistributed: (name: string) => Promise<void>
   configure: (opts: Partial<typeof config>) => QueryBuilder<DB>
   setTransactionDefaults: (defaults: TransactionOptions) => void
-  transactional: <TArgs extends any[], R>(fn: (tx: QueryBuilder<DB>, ...args: TArgs) => Promise<R> | R, options?: TransactionOptions) => (...args: TArgs) => Promise<R>
+  transactional: <TArgs extends unknown[], R>(fn: (tx: QueryBuilder<DB>, ...args: TArgs) => Promise<R> | R, options?: TransactionOptions) => (...args: TArgs) => Promise<R>
   count: <TTable extends keyof DB & string>(table: TTable, column?: keyof DB[TTable]['columns'] & string) => Promise<number>
   sum: <TTable extends keyof DB & string>(table: TTable, column: keyof DB[TTable]['columns'] & string) => Promise<number>
   avg: <TTable extends keyof DB & string>(table: TTable, column: keyof DB[TTable]['columns'] & string) => Promise<number>
-  min: <TTable extends keyof DB & string>(table: TTable, column: keyof DB[TTable]['columns'] & string) => Promise<any>
-  max: <TTable extends keyof DB & string>(table: TTable, column: keyof DB[TTable]['columns'] & string) => Promise<any>
-  insertOrIgnore: <TTable extends keyof DB & string>(table: TTable, values: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => Promise<any>
-  insertGetId: <TTable extends keyof DB & string>(table: TTable, values: Partial<DB[TTable]['columns']>, idColumn?: keyof DB[TTable]['columns'] & string) => Promise<any>
+  min: <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(table: TTable, column: K) => Promise<DB[TTable]['columns'][K] | null>
+  max: <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(table: TTable, column: K) => Promise<DB[TTable]['columns'][K] | null>
+  insertOrIgnore: <TTable extends keyof DB & string>(table: TTable, values: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => Promise<number>
+  insertGetId: <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string = DB[TTable]['primaryKey'] & keyof DB[TTable]['columns'] & string>(table: TTable, values: Partial<DB[TTable]['columns']>, idColumn?: K) => Promise<DB[TTable]['columns'][K]>
   updateOrInsert: <TTable extends keyof DB & string>(table: TTable, match: Partial<DB[TTable]['columns']>, values: Partial<DB[TTable]['columns']>) => Promise<boolean>
-  upsert: <TTable extends keyof DB & string>(table: TTable, rows: Partial<DB[TTable]['columns']>[], conflictColumns: (keyof DB[TTable]['columns'] & string)[], mergeColumns?: (keyof DB[TTable]['columns'] & string)[]) => Promise<any>
+  upsert: <TTable extends keyof DB & string>(table: TTable, rows: Partial<DB[TTable]['columns']>[], conflictColumns: (keyof DB[TTable]['columns'] & string)[], mergeColumns?: (keyof DB[TTable]['columns'] & string)[]) => Promise<number>
   create: <TTable extends keyof DB & string>(
     table: TTable,
     values: Partial<DB[TTable]['columns']>,
@@ -332,7 +353,7 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   ) => Promise<number>
   deleteMany: <TTable extends keyof DB & string>(
     table: TTable,
-    ids: any[],
+    ids: PrimaryKeyValue<DB, TTable>[],
   ) => Promise<number>
   firstOrCreate: <TTable extends keyof DB & string>(
     table: TTable,
@@ -350,19 +371,19 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   ) => Promise<DB[TTable]['columns']>
   remove: <TTable extends keyof DB & string>(
     table: TTable,
-    id: DB[TTable]['columns'][DB[TTable]['primaryKey'] & keyof DB[TTable]['columns']] | any,
-  ) => Promise<any>
+    id: PrimaryKeyValue<DB, TTable>,
+  ) => Promise<unknown>
   find: <TTable extends keyof DB & string>(
     table: TTable,
-    id: DB[TTable]['columns'][DB[TTable]['primaryKey'] & keyof DB[TTable]['columns']] | any,
+    id: PrimaryKeyValue<DB, TTable>,
   ) => Promise<DB[TTable]['columns'] | undefined>
   findOrFail: <TTable extends keyof DB & string>(
     table: TTable,
-    id: DB[TTable]['columns'][DB[TTable]['primaryKey'] & keyof DB[TTable]['columns']] | any,
+    id: PrimaryKeyValue<DB, TTable>,
   ) => Promise<DB[TTable]['columns']>
   findMany: <TTable extends keyof DB & string>(
     table: TTable,
-    ids: any[],
+    ids: PrimaryKeyValue<DB, TTable>[],
   ) => Promise<DB[TTable]['columns'][]>
   latest: <TTable extends keyof DB & string>(
     table: TTable,
@@ -376,13 +397,13 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
     table: TTable,
     count: number,
   ) => SelectQueryBuilder<DB, TTable, DB[TTable]['columns'], TTable>
-  rawQuery: (query: string) => Promise<any>
-  id?: (name: string) => any
-  ids?: (...names: string[]) => any
+  rawQuery: (query: string) => Promise<Record<string, unknown>[]>
+  id?: (name: string) => SqlFragment
+  ids?: (...names: string[]) => SqlFragment
   advisoryLock?: (key: number | string) => Promise<void>
   tryAdvisoryLock?: (key: number | string) => Promise<boolean>
   advisoryUnlock?: (key: number | string) => Promise<boolean>
-  getRelationships?: (table: string) => Record<string, any>
+  getRelationships?: (table: string) => Record<string, unknown>
   hasRelationship?: (table: string, relationName: string) => boolean
   getRelationshipType?: (table: string, relationName: string) => string | null
   getRelationshipTarget?: (table: string, relationName: string) => string | null
@@ -435,10 +456,11 @@ export type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in'
  * See stacksjs/stacks#1858 Q-3.
  */
 export type SqlFragment = object;
-export type WhereExpression<TableColumns> = | Partial<{ [K in keyof TableColumns & string]: ValueOrRef | ValueOrRef[] }>
-  | [key: keyof TableColumns & string, op: WhereOperator, value: ValueOrRef | ValueOrRef[]]
+declare type WhereValue<T> = T | T[] | SqlFragment;
+export type WhereExpression<TableColumns> = | Partial<{ [K in keyof TableColumns & string]: WhereValue<TableColumns[K]> }>
+  | { [K in keyof TableColumns & string]: [key: K, op: WhereOperator, value: WhereValue<TableColumns[K]>] }[keyof TableColumns & string]
   | WhereRaw;
-export type QueryResult = any;
+export type QueryResult = unknown;
 /**
  * # `SortDirection`
  *
@@ -453,6 +475,14 @@ export type SortDirection = 'asc' | 'desc';
 export type ColumnName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = keyof DB[TTable]['columns'] & string;
 // Named row alias to improve IDE hover readability
 export type SelectedRow<DB extends DatabaseSchema<any>, _TTable extends keyof DB & string, TSelected,> = Readonly<TSelected>;
+declare type PrimaryKeyValue<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = DB[TTable]['primaryKey'] extends keyof DB[TTable]['columns']
+    ? DB[TTable]['columns'][DB[TTable]['primaryKey']]
+    : unknown;
+declare type NumericColumnName<Columns> = {
+  [K in keyof Columns & string]: unknown extends Columns[K]
+    ? K
+    : Exclude<Columns[K], null | undefined> extends number ? K : never
+}[keyof Columns & string];
 declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string> = TTables extends any
   ? `${TTables}.${keyof DB[TTables]['columns'] & string}`
   : never;
@@ -469,6 +499,19 @@ declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string>
 export type TableRelationName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = DB[TTable] extends { relations?: infer R }
     ? unknown extends R ? string : keyof NonNullable<R> & string
     : string;
+declare type RelatedTableName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TRelation extends TableRelationName<DB, TTable>,> = DB[TTable] extends { relations?: infer Relations }
+  ? TRelation extends keyof NonNullable<Relations>
+    ? Extract<NonNullable<Relations>[TRelation], keyof DB & string>
+    : keyof DB & string
+  : keyof DB & string;
+declare type RelationQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TRelation extends TableRelationName<DB, TTable>,> = SelectQueryBuilder<
+  DB,
+  RelatedTableName<DB, TTable, TRelation>,
+  DB[RelatedTableName<DB, TTable, TRelation>]['columns']
+>;
+declare type RelationConstraintRecord<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = {
+  [R in TableRelationName<DB, TTable>]: Partial<Record<R, (qb: RelationQueryBuilder<DB, TTable, R>) => unknown>>
+}[TableRelationName<DB, TTable>];
 /**
  * # `WithRelationArg<DB, TTable>`
  *
@@ -483,7 +526,7 @@ export type WithRelationArg<DB extends DatabaseSchema<any>, TTable extends keyof
     :
       | TableRelationName<DB, TTable>
       | `${TableRelationName<DB, TTable>}.${string}`
-      | Partial<Record<TableRelationName<DB, TTable>, (qb: any) => any>>;
+      | RelationConstraintRecord<DB, TTable>;
 // Convert snake_case to PascalCase at the type level (e.g. created_at -> CreatedAt)
 declare type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}`
   ? `${Capitalize<H>}${SnakeToPascal<T>}`
@@ -518,29 +561,29 @@ export type TypedSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
   where: (<K extends keyof DB[TTable]['columns'] & string>(
     expr: Record<K, DB[TTable]['columns'][K]>,
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
-    expr: [K, OP, any],
+    expr: [K, OP, WhereValue<DB[TTable]['columns'][K]>],
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
     expr: WhereExpression<DB[TTable]['columns']> | string,
     op?: WhereOperator,
-    value?: any,
+    value?: WhereValue<DB[TTable]['columns'][keyof DB[TTable]['columns'] & string]>,
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${string}`>)
   andWhere: (<K extends keyof DB[TTable]['columns'] & string>(
     expr: Record<K, DB[TTable]['columns'][K]>,
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
-    expr: [K, OP, any],
+    expr: [K, OP, WhereValue<DB[TTable]['columns'][K]>],
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
     expr: WhereExpression<DB[TTable]['columns']> | string,
     op?: WhereOperator,
-    value?: any,
+    value?: WhereValue<DB[TTable]['columns'][keyof DB[TTable]['columns'] & string]>,
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${string}`>)
   orWhere: (<K extends keyof DB[TTable]['columns'] & string>(
     expr: Record<K, DB[TTable]['columns'][K]>,
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
-    expr: [K, OP, any],
+    expr: [K, OP, WhereValue<DB[TTable]['columns'][K]>],
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
     expr: WhereExpression<DB[TTable]['columns']> | string,
     op?: WhereOperator,
-    value?: any,
+    value?: WhereValue<DB[TTable]['columns'][keyof DB[TTable]['columns'] & string]>,
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${string}`>)
   orderBy: <C extends keyof DB[TTable]['columns'] & string, D extends 'asc' | 'desc' = 'asc'>(
     column: C,

package/dist/config.d.ts

@@ -9,6 +9,54 @@ import type { QueryBuilderConfig, QueryBuilderOptions, SupportedDialect } from '
  * `SingleStoreDriver` / `VitessDriver`) diverges.
  */
 export declare function isMysqlLike(dialect?: SupportedDialect): boolean;
+/**
+ * Recursively merge `source` over `target`, returning a NEW object. Neither
+ * argument is mutated.
+ *
+ * The semantics below are load-bearing — each is pinned by a test or by a
+ * documented promise, so do not "simplify" them:
+ *
+ *  - ARRAYS REPLACE. They do not concatenate or union. `SqliteConfig.pragmas`
+ *    says so in its own doc comment, and `sqlite-bootstrap-pragmas.test.ts`
+ *    asserts it by checking that `foreign_keys` is still 0 after an override
+ *    that omits it — concatenation would flip that to 1.
+ *    `transactionDefaults.sqlStates` is the same shape: a user narrowing
+ *    retries to `['40002']` must stop retrying on `40001`, not keep it.
+ *
+ *  - FUNCTIONS REPLACE. `isPlainObject` rejects them, so `QueryHooks` members
+ *    and `BrowserConfig.getToken` / `transformResponse` stay opaque leaves. We
+ *    never recurse into a function's own enumerable properties.
+ *
+ *  - AN EXPLICIT `undefined` ASSIGNS; AN ABSENT KEY DOES NOT. The rule is
+ *    PRESENCE, not value — `Object.keys(source)` contains a key written as
+ *    `undefined` and does not contain one that was never written. Not a style
+ *    choice: `resolve-dialect.test.ts` calls `setConfig({ dialect: undefined })`
+ *    and expects `resolveDialect()` to fall back to `'postgres'`, and
+ *    `sqlite-bootstrap-pragmas.test.ts` uses `sqlite: undefined` as the restore
+ *    that un-does a pragma override for the rest of a shared-process run.
+ *    Skipping `undefined` breaks both, and now that `hooks` deep-merges, an
+ *    explicit `undefined` is also the only way to REMOVE a hook.
+ *
+ *  - `null` ASSIGNS and is never recursed into. No field in
+ *    `QueryBuilderConfig` is nullable, so a `null` arriving here is a caller
+ *    mistake; assigning it surfaces that at the read site instead of hiding it.
+ *
+ * Arrays are copied by REFERENCE, being leaves — `config.transactionDefaults
+ * .sqlStates` is the same array as `defaultConfig`'s until something replaces
+ * it. Nothing in `src/` mutates a config array in place (the only read is an
+ * `.includes`), and cloning on every merge is not worth paying for that.
+ *
+ * `seen` is the chain of source objects currently being merged, so a source
+ * that points back at one of its own ancestors is treated as a leaf instead of
+ * recursed into. An embedding framework's config slice — the case this type
+ * exists to serve — routinely carries a parent back-pointer, and it typechecks
+ * fine because an optional field of an interface can be that interface. Without
+ * the guard that input spins for seconds, allocates gigabytes and dies with a
+ * stack overflow. It is a DEPTH chain, pushed and popped around the recursion,
+ * not a global set: the same object legitimately appearing under two different
+ * keys must merge both times, and a global set would silently drop the second.
+ */
+declare function mergeObject(target: Record<string, unknown>, source: Record<string, unknown>, seen?: Set<object>): Record<string, unknown>;
 /**
  * The dialect a command should operate on.
  *
@@ -99,4 +147,27 @@ export declare function setConfig(userConfig: QueryBuilderOptions): void;
  */
 export declare function defineConfig(userConfig: QueryBuilderOptions): QueryBuilderOptions;
 export declare const defaultConfig: QueryBuilderConfig;
+// The single, process-wide config object — stored on a `globalThis` symbol so
+// that EVERY copy of this module shares one object, even if Bun's bundler
+// inlines `config.ts` more than once. Previously this was an `export let` that
+// `setConfig` mutated in place: it worked, but relied on the bundler keeping a
+// never-reassigned live binding as a single shared binding, and the build had
+// to regex-patch the emitted `__esm(init_config)` wrapper to keep readers and
+// writers on the same binding. A `globalThis`-keyed `export const` removes both
+// hazards — there is no module-local binding to split or rename, and `const`
+// makes the "never reassign config" rule unenforceable-to-break.
+//
+// Notes:
+//  - `??=` so the first-evaluated copy wins and the rest reuse it.
+//  - `Symbol.for` is a process-global registry key (shared across copies). It
+//    is also shared across package versions in one process — that's the intended
+//    hardening; pin a versioned key if you ever need per-version isolation.
+//  - Synchronous + no top-level await here, so `bun --compile` is unaffected.
+//  - Seeded through `mergeObject`, not `{ ...defaultConfig }`. A shallow spread
+//    left `config.debug === defaultConfig.debug`, so the direct writes this
+//    package makes to the live config — `config.debug.captureText = true` in
+//    `actions/sql.ts` and `computeSqlText()` — were reaching into the exported
+//    DEFAULTS and permanently changing them. `mergeObject` clones every plain
+//    object node, which closes that.
+declare const CONFIG_SINGLETON_KEY: symbol;
 export declare const config: QueryBuilderConfig;