bun-query-builder 0.2.43 → 0.2.45

package/dist/browser.d.ts

@@ -282,13 +282,19 @@ export declare class BrowserQueryError extends Error {
 export declare class BrowserQueryBuilder<T = any> {
   constructor(table: string);
   select(...columns: string[]): this;
-  where(column: string, operatorOrValue: WhereOperator | any, value?: any): this;
-  orWhere(column: string, operatorOrValue: WhereOperator | any, value?: any): this;
-  andWhere(column: string, operatorOrValue: WhereOperator | any, value?: any): this;
+  where(column: string, value: unknown): this;
+  where(column: string, operator: WhereOperator, value: unknown): this;
+  where(column: string, operatorOrValue: unknown, value?: unknown): this;
+  orWhere(column: string, value: unknown): this;
+  orWhere(column: string, operator: WhereOperator, value: unknown): this;
+  orWhere(column: string, operatorOrValue: unknown, value?: unknown): this;
+  andWhere(column: string, value: unknown): this;
+  andWhere(column: string, operator: WhereOperator, value: unknown): this;
+  andWhere(column: string, operatorOrValue: unknown, value?: unknown): this;
   whereNull(column: string): this;
   whereNotNull(column: string): this;
-  whereIn(column: string, values: any[]): this;
-  whereNotIn(column: string, values: any[]): this;
+  whereIn(column: string, values: readonly unknown[]): this;
+  whereNotIn(column: string, values: readonly unknown[]): this;
   orderBy(column: string, direction?: 'asc' | 'desc'): this;
   orderByDesc(column: string): this;
   latest(column?: string): this;

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { config } from './config';
 import { resetConnection } from './db';
-import type { DatabaseSchema } from './schema';
+import type { AnyDatabaseSchema } from './schema';
 import type { DriverConnection } from './db';
 import type { QueryHooks, SupportedDialect } from './types';
 import type { SchemaMeta } from './meta';
@@ -50,7 +50,7 @@ export declare function raw(strings: TemplateStringsArray | string, ...values: u
  */
 export declare function escapeStringLiteral(value: string, dialect?: SupportedDialect): string;
 // eslint-disable-next-line pickier/no-unused-vars
-export declare function createQueryBuilder<DB extends DatabaseSchema<any>>(state?: Partial<InternalState>): QueryBuilder<DB>;
+export declare function createQueryBuilder<DB extends AnyDatabaseSchema>(state?: Partial<InternalState>): QueryBuilder<DB>;
 /**
  * # `clearQueryCache()`
  *
@@ -80,7 +80,7 @@ declare interface RawExpression {
 export declare interface WhereRaw {
   raw: SqlFragment
 }
-export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> {
+export declare interface BaseSelectQueryBuilder<DB extends AnyDatabaseSchema, 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>
@@ -108,7 +108,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   orWhereGroup: (callback: (builder: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereNull: (column: keyof DB[TTable]['columns'] & string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereNotNull: (column: keyof DB[TTable]['columns'] & string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orWhereBetween: (column: keyof DB[TTable]['columns'] & string, start: any, end: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orWhereBetween: <K extends keyof DB[TTable]['columns'] & string>(column: K, start: DB[TTable]['columns'][K], end: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereExists: (subquery: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereRaw: (fragment: SqlFragment) => 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>
@@ -265,7 +265,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   denseRank?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   rank?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
 }
-export declare interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface InsertQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> {
   values: (data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => InsertQueryBuilder<DB, TTable>
   returning: <K extends keyof DB[TTable]['columns'] & string>(...cols: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
   toSQL: () => string
@@ -274,7 +274,7 @@ export declare interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirst: () => Promise<DB[TTable]['columns'] | undefined>
   executeTakeFirstOrThrow: () => Promise<DB[TTable]['columns']>
 }
-export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface UpdateQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> {
   set: (values: Partial<{ [K in keyof DB[TTable]['columns']]: DB[TTable]['columns'][K] | SqlFragment }>) => UpdateQueryBuilder<DB, TTable>
   where: <K extends keyof DB[TTable]['columns'] & string>(
     expr: WhereExpression<DB[TTable]['columns']> | K | SqlFragment,
@@ -290,7 +290,7 @@ export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirst: () => Promise<{ numUpdatedRows?: number }>
   executeTakeFirstOrThrow: () => Promise<{ numUpdatedRows: number }>
 }
-export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface DeleteQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> {
   where: <K extends keyof DB[TTable]['columns'] & string>(
     expr: WhereExpression<DB[TTable]['columns']> | K,
     op?: WhereOperator,
@@ -305,13 +305,13 @@ export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirst: () => Promise<{ numDeletedRows?: number }>
   executeTakeFirstOrThrow: () => Promise<{ numDeletedRows: number }>
 }
-export declare interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface TableQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> {
   insert: (data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => InsertQueryBuilder<DB, TTable>
   update: (values: Partial<DB[TTable]['columns']>) => UpdateQueryBuilder<DB, TTable>
   delete: () => DeleteQueryBuilder<DB, TTable>
   select: <K extends keyof DB[TTable]['columns'] & string>(...columns: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
 }
-export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
+export declare interface QueryBuilder<DB extends AnyDatabaseSchema> {
   select: {
     <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(
       table: TTable,
@@ -434,25 +434,25 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   getRelationshipTarget?: (table: string, relationName: string) => string | null
 }
 declare interface InternalState {
-  sql: any
+  sql: DriverConnection
   meta?: SchemaMeta
-  schema?: any
+  schema?: AnyDatabaseSchema
   txDefaults?: TransactionOptions
   hooks?: QueryHooks
   inTransaction?: boolean
 }
 declare interface TxBackoff { baseMs?: number, maxMs?: number, factor?: number, jitter?: boolean }
-declare interface TxLoggerEvent { type: 'start' | 'retry' | 'commit' | 'rollback' | 'error', attempt: number, error?: any, durationMs?: number }
+declare interface TxLoggerEvent { type: 'start' | 'retry' | 'commit' | 'rollback' | 'error', attempt: number, error?: unknown, durationMs?: number }
 export declare interface TransactionOptions {
   retries?: number
   isolation?: TransactionIsolation
-  onRetry?: (attempt: number, error: any) => void
+  onRetry?: (attempt: number, error: unknown) => void
   afterCommit?: () => void
   sqlStates?: string[]
   backoff?: TxBackoff
   logger?: (event: TxLoggerEvent) => void
   readOnly?: boolean
-  onRollback?: (error: any) => void
+  onRollback?: (error: unknown) => void
   afterRollback?: () => void
 }
 // Where condition helpers
@@ -497,10 +497,10 @@ export type SortDirection = 'asc' | 'desc';
  *
  * Helper type extracting a string union of column names for a given table.
  */
-export type ColumnName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = keyof DB[TTable]['columns'] & string;
+export type ColumnName<DB extends AnyDatabaseSchema, 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']
+export type SelectedRow<DB extends AnyDatabaseSchema, _TTable extends keyof DB & string, TSelected,> = Readonly<TSelected>;
+declare type PrimaryKeyValue<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = DB[TTable]['primaryKey'] extends keyof DB[TTable]['columns']
     ? DB[TTable]['columns'][DB[TTable]['primaryKey']]
     : unknown;
 declare type NumericColumnName<Columns> = {
@@ -508,7 +508,7 @@ declare type NumericColumnName<Columns> = {
     ? 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
+declare type JoinColumn<DB extends AnyDatabaseSchema, TTables extends string> = TTables extends any
   ? `${TTables}.${keyof DB[TTables]['columns'] & string}`
   : never;
 /**
@@ -521,20 +521,20 @@ declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string>
  * untyped schemas keep compiling. A table that declares ZERO relations
  * yields `never` — every relation name is rejected.
  */
-export type TableRelationName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = DB[TTable] extends { relations?: infer R }
+export type TableRelationName<DB extends AnyDatabaseSchema, 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 }
+declare type RelatedTableName<DB extends AnyDatabaseSchema, 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<
+declare type RelationQueryBuilder<DB extends AnyDatabaseSchema, 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> = {
+declare type RelationConstraintRecord<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = {
   [R in TableRelationName<DB, TTable>]: Partial<Record<R, (qb: RelationQueryBuilder<DB, TTable, R>) => unknown>>
 }[TableRelationName<DB, TTable>];
 /**
@@ -546,7 +546,7 @@ declare type RelationConstraintRecord<DB extends DatabaseSchema<any>, TTable ext
  * relations accepts nothing (the bare `Partial<Record<never, ...>>` would be
  * `{}`, which strings are assignable to — hence the explicit never guard).
  */
-export type WithRelationArg<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = [TableRelationName<DB, TTable>] extends [never]
+export type WithRelationArg<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = [TableRelationName<DB, TTable>] extends [never]
     ? never
     :
       | TableRelationName<DB, TTable>
@@ -559,7 +559,7 @@ declare type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}`
 // Typed SQL builder (type-level only). We piggy-back on the runtime builder but
 // thread a phantom TSql string through method signatures so hovers can show the
 // composed SQL at compile-time for common operations.
-declare type _TypedDynamicWhereMethods<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string, TSql extends string,> = {
+declare type _TypedDynamicWhereMethods<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TSelected, TJoined extends string, TSql extends string,> = {
   [K in keyof DB[TTable]['columns'] & string as `where${SnakeToPascal<K>}`]: (
     value: DB[TTable]['columns'][K],
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} = ?`>
@@ -577,7 +577,7 @@ declare type _TypedDynamicWhereMethods<DB extends DatabaseSchema<any>, TTable ex
 // untyped variant (returning a plain SelectQueryBuilder) would win overload
 // resolution, silently downgrading `toSQL()` from the composed literal SQL
 // type back to `string` after any dynamic-where call.
-export type TypedSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable, TSql extends string = `SELECT * FROM ${TTable}`,> = Omit<
+export type TypedSelectQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable, TSql extends string = `SELECT * FROM ${TTable}`,> = Omit<
   BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined>,
   'toSQL' | 'where' | 'andWhere' | 'orWhere' | 'orderBy' | 'limit'
 > & _TypedDynamicWhereMethods<DB, TTable, TSelected, TJoined, TSql>
@@ -616,16 +616,16 @@ export type TypedSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} ORDER BY ${C} ${D}`>
   limit: <N extends number>(n: N) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} LIMIT ${N}`>
 }
-declare type DynamicWhereMethods<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> = {
+declare type DynamicWhereMethods<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> = {
   [K in keyof DB[TTable]['columns'] & string as `where${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
 } & {
   [K in keyof DB[TTable]['columns'] & string as `orWhere${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
 } & {
   [K in keyof DB[TTable]['columns'] & string as `andWhere${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
 }
-export type SelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> = BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>;
+export type SelectQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> = BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>;
 // Typed INSERT builder to expose a structured SQL literal in hovers
-export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSql extends string = `INSERT INTO ${TTable}`,> = Omit<InsertQueryBuilder<DB, TTable>, 'toSQL' | 'values' | 'returning'> & {
+export type TypedInsertQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TSql extends string = `INSERT INTO ${TTable}`,> = Omit<InsertQueryBuilder<DB, TTable>, 'toSQL' | 'values' | 'returning'> & {
   toSQL: () => TSql
   values: (
     data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[],
@@ -642,8 +642,8 @@ export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
 }
 declare type TransactionIsolation = 'read committed' | 'repeatable read' | 'serializable';
 declare class QueryCache {
-  get(key: string): any | null;
-  set(key: string, data: any, ttlMs: number): void;
+  get<T = unknown>(key: string): T | null;
+  set(key: string, data: unknown, ttlMs: number): void;
   clear(): void;
   setMaxSize(size: number): void;
 }

package/dist/column-types.d.ts

@@ -0,0 +1,26 @@
+import type { NormalizedColumnType } from './migrations';
+/**
+ * Whether a canonical type stores a number.
+ *
+ * Used to decide when the `*_id` naming heuristic may coerce a column to
+ * INTEGER. Declared text types must never be coerced by a name heuristic —
+ * external ids are frequently strings (tickers, wallet addresses, hashes).
+ */
+export declare function isNumericPlanType(type: string | undefined): boolean;
+/**
+ * Map a declared attribute type onto the canonical set.
+ *
+ * Accepts the spellings the model layer and the validation-rule reader already
+ * accept, so `type: 'int'`, `'bool'` and `'timestamp'` land where their long
+ * forms do. Returns `undefined` for anything unrecognised, which callers treat
+ * as "no opinion" rather than guessing.
+ */
+export declare function normalizeAttributeType(raw: unknown): NormalizedColumnType | undefined;
+/**
+ * The SQLite storage class for a canonical type.
+ *
+ * `enum` is TEXT here; the migration driver additionally emits a CHECK
+ * constraint, which needs the column name and a quoter and so stays with the
+ * driver.
+ */
+export declare function sqliteAffinityFor(type: NormalizedColumnType | undefined): 'TEXT' | 'INTEGER' | 'REAL';

package/dist/db.d.ts

@@ -1,6 +1,20 @@
 import { Database } from 'bun:sqlite';
 import { SQL } from 'bun';
+import type { SQLQueryBindings } from 'bun:sqlite';
 import type { DatabaseConfig, PoolConfig, SupportedDialect } from './types';
+/**
+ * The one place user values become driver bindings.
+ *
+ * Everything a caller interpolates arrives as `unknown` - that is honest, we
+ * do not know what it is. bun:sqlite accepts a narrower set. The conversion is
+ * unchecked because the driver itself is the validator: it throws a clear
+ * "can't bind" for anything it cannot take, and a check here would only
+ * duplicate that rule and drift from it. Kept as one named function so the
+ * boundary is visible, rather than an `any` at each of the six call sites.
+ */
+export declare function toBindings(params: readonly unknown[]): SQLQueryBindings[];
+/** A template value seen as a possible fragment; null when it is a plain bind param. */
+export declare function asEmbeddedValue(value: unknown): EmbeddedValue | null;
 /**
  * SQLite wrapper that provides a SQL-like tagged template literal interface
  * using bun:sqlite's Database class for better compiled binary support.
@@ -29,7 +43,7 @@ import type { DatabaseConfig, PoolConfig, SupportedDialect } from './types';
  * numbered placeholders is returned untouched, so `?` queries and Bun's own
  * tagged-template output are unaffected.
  */
-export declare function bindNumberedPlaceholders(sql: string, params: any[]): { sql: string, params: any[] };
+export declare function bindNumberedPlaceholders<T>(sql: string, params: T[]): { sql: string, params: T[] };
 export declare function splitSqlStatements(sql: string): string[];
 /**
  * Creates a database connection string based on the configured dialect and database settings.
@@ -108,6 +122,22 @@ export declare const bunSql: SQL;
  * Both Bun's native `SQL` query and our `createSQLiteSQL` wrapper satisfy this.
  * See stacksjs/bun-query-builder#1044.
  */
+/**
+ * What a value interpolated into a tagged template can turn out to be.
+ *
+ * Three things arrive here: a plain bind param, a nested query (carries `sql`
+ * plus a `values` ARRAY), and a raw-SQL marker (carries `__raw`/`raw` and no
+ * `values`). Naming the shape is what lets the branches below read properties
+ * without an `any` - and the order of those branches is load-bearing, see
+ * stacksjs/bun-query-builder#1084.
+ */
+export declare interface EmbeddedValue {
+  sql?: unknown
+  values?: unknown
+  __raw?: unknown
+  raw?: unknown
+  value?: unknown
+}
 export declare interface DriverQuery {
   execute: () => Promise<any>
   values?: () => any
@@ -124,10 +154,10 @@ export declare interface DriverQuery {
  * casts be dropped. See stacksjs/bun-query-builder#1044.
  */
 export declare interface DriverConnection {
-  (strings: TemplateStringsArray, ...values: any[]): DriverQuery
+  (strings: TemplateStringsArray, ...values: unknown[]): DriverQuery
   (value: any): any
-  unsafe: (sql: string, values?: any[]) => AwaitableDriverQuery
-  query?: (sql: string, params?: any[]) => any
+  unsafe: (sql: string, values?: unknown[]) => AwaitableDriverQuery
+  query?: (sql: string, params?: unknown[]) => any
   close?: () => Promise<void> | void
   _prepareStatement?: (sql: string) => any
   [key: string]: any
@@ -136,8 +166,8 @@ export declare interface DriverConnection {
 export type AwaitableDriverQuery = DriverQuery & PromiseLike<any>;
 declare class SQLiteWrapper {
   constructor(filename: string);
-  query(sql: string, params?: any[]): any[];
-  run(sql: string, params?: any[]): any;
+  query(sql: string, params?: SQLQueryBindings[]): any[];
+  run(sql: string, params?: SQLQueryBindings[]): any;
   close(): void;
   get database(): Database;
 }

package/dist/drivers/sqlite.d.ts

@@ -1,11 +1,6 @@
+import { isNumericPlanType } from '../column-types';
 import type { ColumnPlan, IndexPlan, RebuildTableSpec, TablePlan } from '../migrations';
 import type { DateBucketGrain } from './postgres';
-/**
- * Whether a plan type belongs to the numeric family. Used by the `_id`
- * safety net (numeric ids must store as INTEGER on SQLite) — non-numeric
- * declared types must never be coerced by the name heuristic.
- */
-export declare function isNumericPlanType(type: string | undefined): boolean;
 export declare interface DialectDriver {
   createEnumType: (enumTypeName: string, values: string[]) => string
   createTable: (table: TablePlan) => string
@@ -45,3 +40,13 @@ export declare class SQLiteDriver implements DialectDriver {
   dateBucket(column: string, grain: DateBucketGrain, offsetHours?: number): string;
   booleanLiteral(value: boolean): string;
 }
+/**
+ * Whether a plan type belongs to the numeric family. Used by the `_id`
+ * safety net (numeric ids must store as INTEGER on SQLite) — non-numeric
+ * declared types must never be coerced by the name heuristic.
+ *
+ * Defined in column-types.ts now, so the ORM's create-table path applies the
+ * same rule from the same source. Re-exported because this is where callers
+ * already import it from.
+ */
+export { isNumericPlanType };

package/dist/dynamodb-client.d.ts

@@ -11,12 +11,31 @@ export declare function createDynamoDBItemBuilder<T = any>(options: DynamoDBQuer
  * Create a DynamoDB client with fluent query builder methods
  */
 export declare function createDynamoDBClient(options: DynamoDBQueryBuilderOptions): DynamoDBClientMethods;
+/**
+ * The AWS SDK client, described by the one method this package uses.
+ *
+ * `@aws-sdk/client-dynamodb` is not a dependency (callers bring their own),
+ * so the shape is structural: anything with a `send` satisfies it, including
+ * the real `DynamoDBClient` and a test double.
+ */
+export declare interface DynamoDBClientLike {
+  send: (command: unknown) => Promise<unknown>
+  [key: string]: unknown
+}
+/** What DynamoDB reports about the capacity a call consumed. */
+export declare interface DynamoDBConsumedCapacity {
+  TableName?: string
+  CapacityUnits?: number
+  ReadCapacityUnits?: number
+  WriteCapacityUnits?: number
+  [key: string]: unknown
+}
 /**
  * DynamoDB Query Builder Options
  */
 export declare interface DynamoDBQueryBuilderOptions {
   config: DynamoDBConfig
-  client?: any
+  client?: DynamoDBClientLike
 }
 /**
  * Result type for DynamoDB operations
@@ -27,7 +46,7 @@ export declare interface DynamoDBResult<T = any> {
   count?: number
   scannedCount?: number
   lastEvaluatedKey?: Record<string, any>
-  consumedCapacity?: any
+  consumedCapacity?: DynamoDBConsumedCapacity
 }
 /**
  * DynamoDB Client Factory
@@ -41,6 +60,26 @@ export declare interface DynamoDBClientMethods {
   registerEntity: (mapping: SingleTableEntityMapping) => void
   buildKey: (entityType: string, values: Record<string, any>) => { pk: string, sk: string }
 }
+/**
+ * A value DynamoDB can store or compare against.
+ *
+ * DynamoDB's type system is small and closed - scalars, binary, lists and
+ * maps - so the attribute surface below says that rather than `any`. A value
+ * outside this set could never have round-tripped through the wire format.
+ */
+export type DynamoDBValue = | string
+  | number
+  | boolean
+  | null
+  | Uint8Array
+  | DynamoDBValue[]
+  | { [key: string]: DynamoDBValue }
+/** Every operator a DynamoDB filter expression accepts. */
+export type DynamoDBFilterOperator = | DynamoDBComparisonOperator
+  | 'contains'
+  | 'attribute_exists'
+  | 'attribute_not_exists'
+  | 'IN';
 /**
  * DynamoDB Query Builder
  *
@@ -51,23 +90,23 @@ export declare class DynamoDBQueryBuilder<T = any> {
   table(tableName: string): this;
   index(indexName: string): this;
   entity(entityType: string): this;
-  whereKey(attribute: string, operator: DynamoDBComparisonOperator, value: any): this;
-  wherePartitionKey(attribute: string, value: any): this;
-  whereSortKey(attribute: string, value: any): this;
+  whereKey(attribute: string, operator: DynamoDBComparisonOperator, value: DynamoDBValue): this;
+  wherePartitionKey(attribute: string, value: DynamoDBValue): this;
+  whereSortKey(attribute: string, value: DynamoDBValue): this;
   whereSortKeyBeginsWith(attribute: string, prefix: string): this;
-  whereSortKeyBetween(attribute: string, start: any, end: any): this;
-  where(attribute: string, operator: DynamoDBComparisonOperator | 'contains' | 'attribute_exists' | 'attribute_not_exists' | 'IN', value?: any): this;
-  whereEquals(attribute: string, value: any): this;
-  whereLessThan(attribute: string, value: any): this;
-  whereLessThanOrEqual(attribute: string, value: any): this;
-  whereGreaterThan(attribute: string, value: any): this;
-  whereGreaterThanOrEqual(attribute: string, value: any): this;
-  whereBetween(attribute: string, start: any, end: any): this;
+  whereSortKeyBetween(attribute: string, start: DynamoDBValue, end: DynamoDBValue): this;
+  where(attribute: string, operator: DynamoDBFilterOperator, value?: DynamoDBValue): this;
+  whereEquals(attribute: string, value: DynamoDBValue): this;
+  whereLessThan(attribute: string, value: DynamoDBValue): this;
+  whereLessThanOrEqual(attribute: string, value: DynamoDBValue): this;
+  whereGreaterThan(attribute: string, value: DynamoDBValue): this;
+  whereGreaterThanOrEqual(attribute: string, value: DynamoDBValue): this;
+  whereBetween(attribute: string, start: DynamoDBValue, end: DynamoDBValue): this;
   whereBeginsWith(attribute: string, prefix: string): this;
-  whereContains(attribute: string, value: any): this;
+  whereContains(attribute: string, value: DynamoDBValue): this;
   whereExists(attribute: string): this;
   whereNotExists(attribute: string): this;
-  whereIn(attribute: string, values: any[]): this;
+  whereIn(attribute: string, values: DynamoDBValue[]): this;
   select(...attributes: string[]): this;
   limit(count: number): this;
   ascending(): this;
@@ -93,11 +132,11 @@ export declare class DynamoDBItemBuilder<T = any> {
   table(tableName: string): this;
   key(key: Record<string, any>): this;
   item(data: Record<string, any>): this;
-  set(attribute: string, value: any): this;
+  set(attribute: string, value: DynamoDBValue): this;
   setMany(values: Record<string, any>): this;
   remove(attribute: string): this;
-  add(attribute: string, value: any): this;
-  deleteFromSet(attribute: string, values: any): this;
+  add(attribute: string, value: DynamoDBValue): this;
+  deleteFromSet(attribute: string, values: DynamoDBValue): this;
   condition(expression: string): this;
   ifNotExists(attribute?: string): this;
   ifExists(attribute?: string): this;

package/dist/dynamodb-single-table.d.ts

@@ -1,4 +1,4 @@
-import type { DynamoDBQueryBuilderOptions } from './dynamodb-client';
+import type { DynamoDBFilterOperator, DynamoDBQueryBuilderOptions, DynamoDBValue } from './dynamodb-client';
 import type { DynamoDBTableDefinition } from './drivers/dynamodb';
 /**
  * Create a single table manager
@@ -135,7 +135,7 @@ export declare class SingleTableQueryBuilder<T> {
   whereSortKey(skData: Record<string, any>): this;
   whereSortKeyBeginsWith(prefix: string): this;
   useIndex(indexName: string, pkData: Record<string, any>): this;
-  where(attribute: string, operator: any, value?: any): this;
+  where(attribute: string, operator: DynamoDBFilterOperator, value?: DynamoDBValue): this;
   select(...attributes: string[]): this;
   limit(count: number): this;
   descending(): this;

package/dist/dynamodb-tooling-adapter.d.ts

@@ -1,6 +1,7 @@
 import { DynamoDBItemBuilder, DynamoDBQueryBuilder } from './dynamodb-client';
 import { SingleTableManager, SingleTableRepository } from './dynamodb-single-table';
-import type { DynamoDBDriver } from './drivers/dynamodb';
+import type { DynamoDBClientLike } from './dynamodb-client';
+import type { DynamoDBDriver, DynamoDBTableDefinition } from './drivers/dynamodb';
 /**
  * Resolve key pattern placeholders with actual values
  */
@@ -8,7 +9,7 @@ export declare function resolveKeyPattern(keyPatterns: KeyPatterns, data: Record
 /**
  * Parse models from configuration (stub implementation)
  */
-export declare function parseStacksModels(_config: any): Promise<{ models: Map<string, ParsedModel> }>;
+export declare function parseStacksModels(_config: unknown): Promise<{ models: Map<string, ParsedModel> }>;
 /**
  * Convert model instance to DynamoDB item format (stub)
  */
@@ -63,7 +64,7 @@ export declare interface ParsedAttribute {
   nullable: boolean
   unique: boolean
   hidden: boolean
-  defaultValue?: any
+  defaultValue?: unknown
   cast?: string
   dynamoDbType: 'S' | 'N' | 'B' | 'BOOL' | 'NULL' | 'M' | 'L' | 'SS' | 'NS' | 'BS'
 }
@@ -127,7 +128,7 @@ export declare interface StacksModel {
     nullable?: boolean
     unique?: boolean
     hidden?: boolean
-    default?: any
+    default?: unknown
     cast?: string
     validation?: { rule?: string }
   }>
@@ -177,7 +178,7 @@ export declare interface DynamoDBToolingConfig {
  */
 export declare class DynamoDBToolingAdapter {
   constructor(config: DynamoDBToolingConfig);
-  setClient(client: any): this;
+  setClient(client: DynamoDBClientLike): this;
   discoverModels(): Promise<ParsedModel[]>;
   registerModel(model: StacksModel): ParsedModel;
   registerParsedModel(parsed: ParsedModel): ParsedModel;
@@ -192,6 +193,6 @@ export declare class DynamoDBToolingAdapter {
   parseItem<T = any>(item: Record<string, any>): { type: string, data: T } | undefined;
   getDriver(): DynamoDBDriver;
   getSingleTableManager(): SingleTableManager;
-  generateTableDefinition(): any;
+  generateTableDefinition(): DynamoDBTableDefinition;
   generateAccessPatterns(modelName: string): AccessPattern[];
 }

package/dist/meta.d.ts

@@ -17,6 +17,6 @@ export declare interface SchemaMeta {
     morphToMany?: Record<string, string>
     morphedByMany?: Record<string, string>
   }>
-  scopes?: Record<string, Record<string, (qb: any, value?: any) => any>>
+  scopes?: Record<string, Record<string, (qb: any, value?: unknown) => unknown>>
   models?: ModelRecord
 }

package/dist/model.d.ts

@@ -51,6 +51,10 @@ export declare function getModelRegistry(): Record<string, ReturnType<typeof cre
 export declare function hasModel(name: string): boolean;
 /**
  * Clear all registered models. Primarily useful for testing.
+ *
+ * Also drops the models `createModel` registered internally, and the memoized
+ * relation resolutions derived from them. Leaving either behind lets a stale
+ * resolution from one test file decide a relation's table in the next.
  */
 export declare function clearModelRegistry(): void;
 /**

package/dist/orm.d.ts

@@ -14,18 +14,11 @@ export type {
   FillableKeys,
   HiddenKeys,
 };
-/**
- * Extract an affected-row count from a Bun SQL driver result.
- *
- * Verified against live Postgres (Bun 1.3): a non-RETURNING `UPDATE`/`DELETE`
- * returns an empty array carrying `{ count: <affected>, affectedRows: null,
- * command: 'UPDATE' }`. So `count` must be checked BEFORE the `Array.length`
- * fallback (which would be 0) — see stacksjs/bun-query-builder#1032. MySQL
- * surfaces `affectedRows` instead.
- */
-export declare function extractChanges(res: any): number;
+/** Drops the `createModel` models. Paired with `clearModelRegistry()`. */
+export declare function clearLocalModels(): void;
+export declare function extractChanges(res: WriteResultLike | null | undefined): number;
 /** Extract a generated primary key from a Bun SQL driver result. */
-export declare function extractInsertId(res: any): number | bigint | null;
+export declare function extractInsertId(res: WriteResultLike | null | undefined): number | bigint | null;
 export declare function configureOrm(options: { database?: string | Database; verbose?: boolean }): void;
 /**
  * Return the underlying `bun:sqlite` Database backing the model layer.
@@ -138,8 +131,8 @@ export declare interface ModelDefinition {
   readonly attributes: {
     readonly [key: string]: TypedAttribute<unknown>
   }
-  readonly get?: Record<string, (attributes: any) => unknown>
-  readonly set?: Record<string, (attributes: any) => unknown>
+  readonly get?: Record<string, (attributes: Record<string, unknown>) => unknown>
+  readonly set?: Record<string, (attributes: Record<string, unknown>) => unknown>
   readonly scopes?: Record<string, (value: unknown) => unknown>
   readonly indexes?: readonly object[]
   readonly dashboard?: { readonly enabled?: boolean; readonly highlight?: boolean | number }
@@ -160,6 +153,33 @@ declare interface OrmExecutor {
   insert: (sql: string, params: unknown[], primaryKey: string) => Promise<RunResult>
   readonly sqliteDb?: Database
 }
+/**
+ * Extract an affected-row count from a Bun SQL driver result.
+ *
+ * Verified against live Postgres (Bun 1.3): a non-RETURNING `UPDATE`/`DELETE`
+ * returns an empty array carrying `{ count: <affected>, affectedRows: null,
+ * command: 'UPDATE' }`. So `count` must be checked BEFORE the `Array.length`
+ * fallback (which would be 0) — see stacksjs/bun-query-builder#1032. MySQL
+ * surfaces `affectedRows` instead.
+ */
+/**
+ * What a driver hands back after a write.
+ *
+ * Each one reports the affected count under its own name - and Postgres
+ * returns an empty array carrying `count`, so the shape is genuinely a union
+ * rather than one thing. Naming the fields beats `any`: a caller reading this
+ * type learns which drivers report what.
+ */
+export declare interface WriteResultLike {
+  affectedRows?: number
+  count?: number
+  changes?: number
+  lastInsertRowid?: number | bigint
+  insertId?: number | bigint
+  command?: string
+  rows?: unknown[]
+  [key: string]: unknown
+}
 /**
  * Resolve a relation from its name and the parent model's definition.
  * Uses the model registry to find the related model's definition.