bun-query-builder 0.2.25 → 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,8 @@
 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';
 /**
  * # `raw`
@@ -58,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>
@@ -80,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>
@@ -101,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>,
@@ -121,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>,
@@ -129,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?: {
@@ -141,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][]>
@@ -181,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>[]>
@@ -200,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>
@@ -237,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>>
@@ -248,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>>
@@ -273,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>
@@ -302,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']>,
@@ -331,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,
@@ -349,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,
@@ -375,12 +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>
-  getRelationships?: (table: string) => Record<string, any>
+  advisoryUnlock?: (key: number | string) => Promise<boolean>
+  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
@@ -390,6 +413,7 @@ declare interface InternalState {
   meta?: SchemaMeta
   schema?: any
   txDefaults?: TransactionOptions
+  hooks?: QueryHooks
   inTransaction?: boolean
 }
 declare interface TxBackoff { baseMs?: number, maxMs?: number, factor?: number, jitter?: boolean }
@@ -432,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`
  *
@@ -450,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;
@@ -466,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>`
  *
@@ -480,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>}`
@@ -515,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,