bun-query-builder 0.1.12 → 0.1.15

package/dist/drivers/sqlite.d.ts

@@ -3,7 +3,7 @@ export declare interface DialectDriver {
   createEnumType: (enumTypeName: string, values: string[]) => string
   createTable: (table: TablePlan) => string
   createIndex: (tableName: string, index: IndexPlan) => string
-  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string) => string
+  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string) => string
   addColumn: (tableName: string, column: ColumnPlan) => string
   modifyColumn: (tableName: string, column: ColumnPlan) => string
   dropTable: (tableName: string) => string
@@ -15,15 +15,10 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class SQLiteDriver implements DialectDriver {
-  private quoteIdentifier(id: string): string;
-  private getColumnType(column: ColumnPlan): string;
-  private getPrimaryKeyType(column: ColumnPlan): string;
-  private getAutoIncrementClause(column: ColumnPlan): string;
-  private getDefaultValue(column: ColumnPlan): string;
   createEnumType(_enumTypeName: string, _values: string[]): string;
   createTable(table: TablePlan): string;
   createIndex(tableName: string, index: IndexPlan): string;
-  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string): string;
   addColumn(tableName: string, column: ColumnPlan): string;
   modifyColumn(tableName: string, column: ColumnPlan): string;
   dropTable(tableName: string): string;
@@ -33,5 +28,4 @@ export declare class SQLiteDriver implements DialectDriver {
   createMigrationsTable(): string;
   getExecutedMigrationsQuery(): string;
   recordMigrationQuery(): string;
-  private renderColumn(column: ColumnPlan): string;
-}
+}

package/dist/dynamodb/client.d.ts

@@ -154,11 +154,7 @@ export declare interface DynamoDBDeleteItemOutput {
  * Uses AWS Signature V4 and native fetch for zero-dependency DynamoDB access.
  */
 export declare class DynamoDBClient {
-  private config: DynamoDBClientConfig;
-  private endpoint: string;
-  private credentials: DynamoDBCredentials;
   constructor(config: DynamoDBClientConfig);
-  private execute(operation: string, input: any): Promise<any>;
   query(input: DynamoDBQueryInput): Promise<DynamoDBQueryOutput>;
   scan(input: DynamoDBScanInput): Promise<DynamoDBQueryOutput>;
   getItem(input: DynamoDBGetItemInput): Promise<DynamoDBGetItemOutput>;
@@ -175,4 +171,4 @@ export declare class DynamoDBClient {
   updateTable(input: any): Promise<any>;
   updateTimeToLive(input: any): Promise<any>;
   describeTimeToLive(tableName: string): Promise<any>;
-}
+}

package/dist/dynamodb/index.d.ts

@@ -1,4 +1,5 @@
-import type { DynamoDBConfig, DynamoDBDriver, SingleTableEntityMapping,  } from '../drivers/dynamodb';
+import type { DynamoDBConfig, DynamoDBDriver, SingleTableEntityMapping } from '../drivers/dynamodb';
+// Re-export types from driver
 export type {
   DynamoDBConfig,
   DynamoDBDriver,
@@ -82,28 +83,12 @@ export declare interface DynamoDBQueryResult<T = any> {
  * Entity-centric query builder for DynamoDB
  */
 export declare class EntityQueryBuilder<T = any> {
-  private driver: DynamoDBDriver;
-  private client: any;
-  private tableName: string;
-  private pkAttribute: string;
-  private skAttribute: string;
-  private entityTypeAttr: string;
-  private delimiter: string;
-  private _entityType?: string;
-  private _pkValue?: string;
-  private _skCondition?: { type: 'eq' | 'begins_with' | 'between' | 'lt' | 'lte' | 'gt' | 'gte', value: string, value2?: string };
-  private _indexName?: string;
-  private _projectionAttrs: string[];
-  private _filterConditions: Array<{ attribute: string, operator: string, value?: any, values?: any[] }>;
-  private _limitValue?: number;
-  private _scanForward: boolean;
-  private _consistentRead: boolean;
-  private _startKey?: Record<string, any>;
   constructor(driver: DynamoDBDriver, client: any, tableName: string, config: { pkAttribute: string, skAttribute: string, entityTypeAttribute: string, keyDelimiter: string });
   entity(entityType: string): this;
   pk(value: string): this;
+  get sk(): SortKeyBuilder;
   index(indexName: string): this;
-  project(attributes: string[]): this;
+  project(...attributes: string[]): this;
   filter(attribute: string, operator: string, value?: any): this;
   where(attribute: string, value: any): this;
   whereIn(attribute: string, values: any[]): this;
@@ -122,14 +107,6 @@ export declare class EntityQueryBuilder<T = any> {
  * DynamoDB client with entity-centric API
  */
 declare class DynamoClient {
-  private driver?: DynamoDBDriver;
-  private client?: any;
-  private tableName: string;
-  private pkAttribute: string;
-  private skAttribute: string;
-  private entityTypeAttr: string;
-  private delimiter: string;
-  private entityMappings: Map<string, SingleTableEntityMapping>;
   connection(config: DynamoConnectionConfig): this;
   setClient(client: any): this;
   registerEntity(mapping: SingleTableEntityMapping): this;
@@ -138,8 +115,10 @@ declare class DynamoClient {
   transactWrite(operations: TransactWriteOperation[]): Promise<void>;
   getDriver(): DynamoDBDriver | undefined;
 }
+// Re-export Model and client
 export { Model, configureModels } from './model';
 export { DynamoDBClient, createClient } from './client';
+// Re-export migrations
 export {
   DynamoDBMigrationDriver,
   createMigrationDriver,
@@ -153,4 +132,4 @@ export {
   hashTableDefinition,
   isDefinitionEqual,
 } from './migrations';
-export { DynamoDBMigrationTracker, MIGRATIONS_TABLE } from './migration-tracker';
+export { DynamoDBMigrationTracker, MIGRATIONS_TABLE } from './migration-tracker';

package/dist/dynamodb/migration-driver.d.ts

@@ -1,8 +1,5 @@
-import { DynamoDBClient } from './client';
-import { DynamoDBMigrationTracker } from './migration-tracker';
 import type { DynamoDBClientConfig } from './client';
-import type { DynamoDBMigrationPlan, DynamoDBMigrationOperation, DynamoDBMigrationState } from './migrations';
-import type { DynamoDBTableDefinition, DynamoDBGlobalSecondaryIndex } from '../drivers/dynamodb';
+import type { DynamoDBMigrationPlan, DynamoDBMigrationState } from './migrations';
 /**
  * Create a migration driver instance
  */
@@ -29,27 +26,9 @@ export declare interface MigrationResult {
  * Executes DynamoDB schema migrations
  */
 export declare class DynamoDBMigrationDriver {
-  private client: DynamoDBClient;
-  private tracker: DynamoDBMigrationTracker;
-  private config: MigrationDriverConfig;
   constructor(config: MigrationDriverConfig);
   execute(plan: DynamoDBMigrationPlan): Promise<MigrationResult>;
-  private executeOperation(op: DynamoDBMigrationOperation): Promise<void>;
-  private createTable(definition: DynamoDBTableDefinition): Promise<void>;
-  private deleteTable(tableName: string): Promise<void>;
-  private addGSI(tableName: string, gsi: DynamoDBGlobalSecondaryIndex): Promise<void>;
-  private deleteGSI(tableName: string, indexName: string): Promise<void>;
-  private updateTTL(tableName: string, ttlAttribute: string | null, enabled: boolean): Promise<void>;
-  private updateBillingMode(tableName: string, billingMode: 'PAY_PER_REQUEST' | 'PROVISIONED', provisionedThroughput?: { readCapacityUnits: number; writeCapacityUnits: number }): Promise<void>;
-  private enableStream(tableName: string, viewType: string): Promise<void>;
-  private disableStream(tableName: string): Promise<void>;
-  private executeUpdateTable(input: any): Promise<void>;
-  private executeUpdateTimeToLive(input: any): Promise<void>;
-  private waitForTableActive(tableName: string, maxAttempts?: number): Promise<void>;
-  private waitForGSIActive(tableName: string, indexName: string, maxAttempts?: number): Promise<void>;
   migrateModel(ModelClass: any): Promise<MigrationResult>;
   migrateModels(models: any[]): Promise<MigrationResult[]>;
   getStatus(): Promise<Map<string, DynamoDBMigrationState | null>>;
-  private tableInfoToDefinition(tableInfo: any): DynamoDBTableDefinition;
-  private log(args: any[]): void;
-}
+}

package/dist/dynamodb/migration-tracker.d.ts

@@ -5,18 +5,16 @@ import type { DynamoDBTableDefinition } from '../drivers/dynamodb';
  * Tracks and manages DynamoDB migration state
  */
 export declare class DynamoDBMigrationTracker {
-  private client: DynamoDBClient;
-  private initialized: boolean;
   constructor(client: DynamoDBClient);
   ensureMigrationsTable(): Promise<void>;
-  private waitForTableActive(tableName: string, maxAttempts?: number): Promise<void>;
   getLatestState(tableName: string): Promise<DynamoDBMigrationState | null>;
   getHistory(tableName: string): Promise<DynamoDBMigrationState[]>;
   recordMigration(tableName: string, definition: DynamoDBTableDefinition, version?: number): Promise<DynamoDBMigrationState>;
   listTrackedTables(): Promise<string[]>;
   hasMigrations(tableName: string): Promise<boolean>;
   deleteMigrationHistory(tableName: string): Promise<void>;
-  private marshallState(state: DynamoDBMigrationState, pk: string, sk: string): Record<string, any>;
-  private unmarshallState(item: Record<string, any>): DynamoDBMigrationState;
 }
-export { MIGRATIONS_TABLE };
+// ============================================================================
+// Exports
+// ============================================================================
+export { MIGRATIONS_TABLE };

package/dist/dynamodb/migrations.d.ts

@@ -1,4 +1,7 @@
 import type { DynamoDBTableDefinition, DynamoDBGlobalSecondaryIndex, DynamoDBAttributeDefinition } from '../drivers/dynamodb';
+// ============================================================================
+// Exports
+// ============================================================================
 export type {
   DynamoDBTableDefinition,
   DynamoDBGlobalSecondaryIndex,
@@ -110,4 +113,4 @@ export type DynamoDBMigrationOperationType = | 'CREATE_TABLE'
   | 'UPDATE_BILLING_MODE'
   | 'UPDATE_THROUGHPUT'
   | 'ENABLE_STREAM'
-  | 'DISABLE_STREAM'
+  | 'DISABLE_STREAM';

package/dist/dynamodb/model.d.ts

@@ -81,16 +81,6 @@ export declare abstract class Model {
 // Query Builder Implementation
 // ============================================================================
 declare class ModelQueryBuilderImpl<T extends Model> implements ModelQueryBuilder<T> {
-  private ModelClass: typeof Model;
-  private _pkValue?: string;
-  private _skCondition?: { type: string, value: any, value2?: any };
-  private _indexName?: string;
-  private _filterConditions: Array<{ attribute: string, operator: string, value?: any, values?: any[] }>;
-  private _projectionAttrs: string[];
-  private _limitValue?: number;
-  private _scanForward: boolean;
-  private _consistentReadValue: boolean;
-  private _startKey?: Record<string, any>;
   constructor(ModelClass: typeof Model);
   wherePk(value: string): this;
   where(attribute: string, operatorOrValue: any, value?: any): this;
@@ -101,14 +91,16 @@ declare class ModelQueryBuilderImpl<T extends Model> implements ModelQueryBuilde
   whereNotExists(attribute: string): this;
   orderBy(direction: 'asc' | 'desc'): this;
   limit(count: number): this;
-  select(attributes: string[]): this;
+  select(...attributes: string[]): this;
   index(indexName: string): this;
   consistentRead(): this;
   startFrom(key: Record<string, any>): this;
-  private buildRequest(): Record<string, any>;
   get(): Promise<T[]>;
   first(): Promise<T | null>;
   count(): Promise<number>;
   paginate(pageSize: number, lastKey?: Record<string, any>): Promise<{ items: T[], lastKey?: Record<string, any> }>;
 }
-export { DynamoDBClient, createClient } from './client';
+// ============================================================================
+// Re-exports for convenience
+// ============================================================================
+export { DynamoDBClient, createClient } from './client';

package/dist/dynamodb-client.d.ts

@@ -1,4 +1,4 @@
-import type { DynamoDBComparisonOperator, DynamoDBCondition, DynamoDBConfig, DynamoDBDriver, DynamoDBPutItemParams, DynamoDBQueryParams, DynamoDBScanParams, DynamoDBUpdateItemParams, SingleTableEntityMapping,  } from './drivers/dynamodb';
+import type { DynamoDBComparisonOperator, DynamoDBConfig, DynamoDBDriver, DynamoDBQueryParams, DynamoDBScanParams, SingleTableEntityMapping } from './drivers/dynamodb';
 /**
  * Create a DynamoDB query builder
  */
@@ -47,18 +47,6 @@ export declare interface DynamoDBClientMethods {
  * Fluent interface for building DynamoDB queries
  */
 export declare class DynamoDBQueryBuilder<T = any> {
-  private driver: DynamoDBDriver;
-  private client: any;
-  private tableName: string;
-  private indexName?: string;
-  private entityType?: string;
-  private keyConditions: DynamoDBCondition[];
-  private filterConditions: DynamoDBCondition[];
-  private projectionAttrs: string[];
-  private limitValue?: number;
-  private scanForward: boolean;
-  private consistentReadValue: boolean;
-  private startKey?: Record<string, any>;
   constructor(options: DynamoDBQueryBuilderOptions);
   table(tableName: string): this;
   index(indexName: string): this;
@@ -80,7 +68,7 @@ export declare class DynamoDBQueryBuilder<T = any> {
   whereExists(attribute: string): this;
   whereNotExists(attribute: string): this;
   whereIn(attribute: string, values: any[]): this;
-  select(attributes: string[]): this;
+  select(...attributes: string[]): this;
   limit(count: number): this;
   ascending(): this;
   descending(): this;
@@ -101,14 +89,6 @@ export declare class DynamoDBQueryBuilder<T = any> {
  * DynamoDB Item Builder for Put/Update operations
  */
 export declare class DynamoDBItemBuilder<T = any> {
-  private driver: DynamoDBDriver;
-  private client: any;
-  private tableName: string;
-  private itemData: Record<string, any>;
-  private keyData: Record<string, any>;
-  private updateExpressions: DynamoDBUpdateItemParams['updateExpressions'];
-  private conditionExpr?: string;
-  private returnValuesOption: DynamoDBPutItemParams['returnValues'];
   constructor(options: DynamoDBQueryBuilderOptions);
   table(tableName: string): this;
   key(key: Record<string, any>): this;
@@ -131,4 +111,4 @@ export declare class DynamoDBItemBuilder<T = any> {
   update(): Promise<T | undefined>;
   delete(): Promise<T | undefined>;
   get(): Promise<T | undefined>;
-}
+}

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

@@ -1,6 +1,5 @@
-import { DynamoDBQueryBuilder } from './dynamodb-client';
 import type { DynamoDBQueryBuilderOptions } from './dynamodb-client';
-import type { DynamoDBTableDefinition,  } from './drivers/dynamodb';
+import type { DynamoDBTableDefinition } from './drivers/dynamodb';
 /**
  * Create a single table manager
  */
@@ -11,6 +10,21 @@ export declare function createSingleTableManager(config: SingleTableConfig): Sin
 export declare function createRepository<T extends Record<string, any>>(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions): SingleTableRepository<T>;
 /**
  * Common single table design patterns
+ * @defaultValue
+ * ```ts
+ * {
+ *   simpleEntity: (entityName: string, idField?: string) => unknown,
+ *   oneToMany: (parentEntity: string,
+ *     childEntity: string,
+ *     parentIdField?: string,
+ *     childIdField?: string,) => unknown,
+ *   manyToMany: (entityName: string,
+ *     relationName: string,
+ *     idField?: string,
+ *     relatedIdField?: string,) => unknown,
+ *   hierarchical: (entityName: string, rootIdField?: string, pathField?: string) => unknown
+ * }
+ * ```
  */
 export declare const SingleTablePatterns: {
   /**
@@ -18,26 +32,26 @@ export declare const SingleTablePatterns: {
    * PK: USER#<userId>
    * SK: PROFILE for metadata, or related items like ORDER#<orderId>
    */
-  simpleEntity: (entityName: string, idField: string?) => any;
+  simpleEntity: (entityName: string, idField?: string) => unknown;
   /**
    * One-to-many relationship pattern
    * Parent: PK=PARENT#<parentId>, SK=METADATA
    * Child: PK=PARENT#<parentId>, SK=CHILD#<childId>
    */
-  oneToMany: ( parentEntity: string, childEntity: string, parentIdField: string?, childIdField: string?, ) => unknown;
+  oneToMany: (parentEntity: string, childEntity: string, parentIdField?: string, childIdField?: string,) => unknown;
   /**
    * Many-to-many relationship pattern using adjacency list
    * Entity: PK=ENTITY#<entityId>, SK=METADATA
    * Relationship: PK=ENTITY#<entityId>, SK=RELATED#<relatedId>
    * Inverse: PK=ENTITY#<relatedId>, SK=RELATED#<entityId> (via GSI)
    */
-  manyToMany: ( entityName: string, relationName: string, idField: string?, relatedIdField: string?, ) => unknown;
+  manyToMany: (entityName: string, relationName: string, idField?: string, relatedIdField?: string,) => unknown;
   /**
    * Hierarchical data pattern (e.g., org chart, file system)
    * PK: ROOT#<rootId>
    * SK: PATH#<path> (e.g., PATH#/folder1/folder2/file)
    */
-  hierarchical: (entityName: string, rootIdField: string?, pathField: string?) => any
+  hierarchical: (entityName: string, rootIdField?: string, pathField?: string) => unknown
 };
 /**
  * Entity definition for single table design
@@ -48,11 +62,8 @@ export declare interface SingleTableEntity {
   skPattern: string
   keyFields: string[]
   indexes?: {
-    /** GSI name */
     name: string
-    /** Pattern for GSI partition key */
     pkPattern: string
-    /** Pattern for GSI sort key */
     skPattern?: string
   }[]
   schema?: Record<string, {
@@ -82,11 +93,6 @@ export declare interface SingleTableConfig {
  * single table design patterns.
  */
 export declare class SingleTableManager {
-  private config: SingleTableConfig;
-  private entities: Map<string, SingleTableEntity>;
-  private pkAttribute: string;
-  private skAttribute: string;
-  private typeAttribute: string;
   constructor(config: SingleTableConfig);
   getEntity(name: string): SingleTableEntity | undefined;
   registerEntity(entity: SingleTableEntity): void;
@@ -97,7 +103,6 @@ export declare class SingleTableManager {
   parseItem<T = any>(item: Record<string, any>): { type: string, data: T } | undefined;
   getEntityPrefix(entityName: string): string;
   generateTableDefinition(): DynamoDBTableDefinition;
-  private interpolatePattern(pattern: string, values: Record<string, any>): string;
 }
 /**
  * Single Table Entity Repository
@@ -105,9 +110,6 @@ export declare class SingleTableManager {
  * Provides CRUD operations for a specific entity type in a single table design.
  */
 export declare class SingleTableRepository<T extends Record<string, any>> {
-  private manager: SingleTableManager;
-  private entityName: string;
-  private options: DynamoDBQueryBuilderOptions;
   constructor(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions);
   create(data: T): Promise<T>;
   get(keyData: Partial<T>): Promise<T | undefined>;
@@ -120,21 +122,15 @@ export declare class SingleTableRepository<T extends Record<string, any>> {
  * Query builder for single table entity queries
  */
 export declare class SingleTableQueryBuilder<T> {
-  private manager: SingleTableManager;
-  private entityName: string;
-  private options: DynamoDBQueryBuilderOptions;
-  private builder: DynamoDBQueryBuilder<Record<string, any>>;
-  private pkValue?: string;
-  private skConditions: { operator: string, value: any, values?: any[] }[];
   constructor(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions);
   wherePartitionKey(pkData: Record<string, any>): this;
   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;
-  select(attributes: string[]): this;
+  select(...attributes: string[]): this;
   limit(count: number): this;
   descending(): this;
   execute(): Promise<T[]>;
   first(): Promise<T | undefined>;
-}
+}

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

@@ -1,8 +1,6 @@
 import { DynamoDBItemBuilder, DynamoDBQueryBuilder } from './dynamodb-client';
 import { SingleTableManager, SingleTableRepository } from './dynamodb-single-table';
-import type { DynamoDBDriver, SingleTableEntityMapping } from './drivers/dynamodb';
-import type { DynamoDBQueryBuilderOptions } from './dynamodb-client';
-import type { SingleTableConfig, SingleTableEntity } from './dynamodb-single-table';
+import type { DynamoDBDriver } from './drivers/dynamodb';
 /**
  * Resolve key pattern placeholders with actual values
  */
@@ -41,19 +39,6 @@ export declare function generateAccessPatterns(model: ParsedModel): AccessPatter
  * Standalone function for creating entity patterns
  */
 export declare function stacksModelToEntity(model: { name: string; primaryKey?: string }, delimiter?: string): { name: string; pkPattern: string; skPattern: string };
-/**
- * DynamoDB Tooling Adapter
- *
- * This module provides integration between bun-query-builder's DynamoDB driver
- * and the dynamodb-tooling ORM. It bridges the gap between:
- *
- * 1. Stacks model definitions (from dynamodb-tooling)
- * 2. Single table design patterns (from dynamodb-tooling)
- * 3. bun-query-builder's DynamoDB query builder
- *
- * IMPORTANT: This adapter EXTENDS dynamodb-tooling rather than duplicating it.
- * All model parsing, key generation, and entity transformation is delegated to dynamodb-tooling.
- */
 /**
  * Access pattern definition for DynamoDB single-table design
  */
@@ -191,11 +176,6 @@ export declare interface DynamoDBToolingConfig {
  * All model parsing and transformation is delegated to dynamodb-tooling.
  */
 export declare class DynamoDBToolingAdapter {
-  private config: DynamoDBToolingConfig;
-  private driver: DynamoDBDriver;
-  private singleTableManager: SingleTableManager;
-  private models: Map<string, ParsedModel>;
-  private queryBuilderOptions: DynamoDBQueryBuilderOptions;
   constructor(config: DynamoDBToolingConfig);
   setClient(client: any): this;
   discoverModels(): Promise<ParsedModel[]>;
@@ -214,15 +194,4 @@ export declare class DynamoDBToolingAdapter {
   getSingleTableManager(): SingleTableManager;
   generateTableDefinition(): any;
   generateAccessPatterns(modelName: string): AccessPattern[];
-  private parseWithTooling(model: StacksModel): ParsedModel;
-  private parseAttributes(model: StacksModel): ParsedModel['attributes'];
-  private inferDynamoDBType(def: any): 'S' | 'N' | 'B' | 'BOOL' | 'NULL' | 'M' | 'L' | 'SS' | 'NS' | 'BS';
-  private parseRelationships(model: StacksModel, primaryKey: string): ParsedModel['relationships'];
-  private deriveGSIKeyPatterns(entityType: string, primaryKey: string, delimiter: string, relationships: ParsedModel['relationships']): Record<string, string>;
-  private deriveAccessPatterns(modelName: string, entityType: string, primaryKey: string, relationships: ParsedModel['relationships']): AccessPattern[];
-  private toSingleTableEntity(model: ParsedModel): SingleTableEntity;
-  private extractKeyFields(pattern: string): string[];
-  private extractGSIPatterns(keyPatterns: ParsedModel['keyPatterns']): SingleTableEntity['indexes'];
-  private toEntityMapping(model: ParsedModel): SingleTableEntityMapping;
-  private buildGSIConfig(): SingleTableConfig['indexes'];
-}
+}

package/dist/factory.d.ts

@@ -1,7 +1,7 @@
 import type { DatabaseSchema, ModelRecord } from './schema';
 export declare function buildDatabaseSchema<MRecord extends ModelRecord>(models: MRecord): BuildDatabaseSchema<MRecord>;
-export type BuildDatabaseSchema<MRecord extends ModelRecord> = DatabaseSchema<MRecord>
-export type TablesFromSchema<DB> = keyof DB & string
+export type BuildDatabaseSchema<MRecord extends ModelRecord> = DatabaseSchema<MRecord>;
+export type TablesFromSchema<DB> = keyof DB & string;
 export type ColumnsOf<DB, TTable extends keyof DB & string> = DB[TTable] extends { columns: infer C }
   ? C
-  : never
+  : never;

package/dist/index.d.ts

@@ -1,6 +1,26 @@
+// Resolve ambiguous re-exports by explicitly choosing which module's version to use
 export type { WhereOperator } from './browser';
 export type { ModelQueryBuilder } from './dynamodb';
 export type { ColumnName } from './client';
+// Re-export the type-inference version of InferRelationNames (supports wrapped models)
+// to resolve the ambiguity with orm.ts's InferRelationNames (which takes raw definitions)
+export type { InferRelationNames } from './type-inference';
+// Explicit re-exports for type inference utilities
+export type {
+  InferAttributes,
+  InferFillableAttributes,
+  InferPrimaryKey,
+  InferTableName,
+  InferNumericColumns,
+  InferColumnNames,
+  InferHiddenKeys,
+  InferGuardedKeys,
+  ModelRow,
+  ModelRowLoose,
+  ModelCreateData,
+  ModelCreateDataLoose,
+  RelationCardinality,
+} from './type-inference';
 export * from './actions';
 export * from './browser';
 export * from './client';
@@ -18,5 +38,8 @@ export * from './migrations';
 export * from './orm';
 export * from './schema';
 export * from './seeder';
+export * from './type-inference';
 export * from './types';
-export { type ModelDefinition, defineModel } from './model';
+export { type ModelDefinition, defineModel } from './model';
+// Explicit re-exports for model registry functions
+export { getModel, getAllModels, getModelRegistry, hasModel, clearModelRegistry } from './model';

package/dist/loader.d.ts

@@ -3,4 +3,4 @@ export declare function loadModels(options: LoadModelsOptions): Promise<ModelRec
 export declare interface LoadModelsOptions {
   cwd?: string
   modelsDir: string
-}
+}

package/dist/meta.d.ts

@@ -18,4 +18,4 @@ export declare interface SchemaMeta {
     morphedByMany?: Record<string, string>
   }>
   scopes?: Record<string, Record<string, (qb: any, value?: any) => any>>
-}
+}

package/dist/migrations.d.ts

@@ -1,4 +1,4 @@
-import type { ModelRecord } from './schema';
+import type { ModelRecord, OnForeignKeyAction } from './schema';
 import type { SupportedDialect } from './types';
 export declare function buildMigrationPlan(models: ModelRecord, options: InferenceOptions): MigrationPlan;
 export declare function generateSql(plan: MigrationPlan): string[];
@@ -35,7 +35,7 @@ export declare interface ColumnPlan {
   isNullable: boolean
   hasDefault: boolean
   defaultValue?: PrimitiveDefault
-  references?: { table: string, column: string }
+  references?: { table: string, column: string, onDelete?: OnForeignKeyAction, onUpdate?: OnForeignKeyAction }
   enumValues?: string[]
 }
 export declare interface IndexPlan {
@@ -55,7 +55,7 @@ export declare interface MigrationPlan {
 export declare interface InferenceOptions {
   dialect: SupportedDialect
 }
-export type PrimitiveDefault = string | number | boolean | bigint | Date
+export type PrimitiveDefault = string | number | boolean | bigint | Date;
 export type NormalizedColumnType = | 'string'
   | 'text'
   | 'boolean'
@@ -67,4 +67,4 @@ export type NormalizedColumnType = | 'string'
   | 'date'
   | 'datetime'
   | 'json'
-  | 'enum'
+  | 'enum';

package/dist/model.d.ts

@@ -1,10 +1,68 @@
+import { createBrowserModel, type BrowserModelDefinition } from './browser';
+// Re-export the browser model types for convenience
 export type { BrowserModelDefinition as ModelDefinition };
+/**
+ * Look up a registered model by name.
+ *
+ * @param name - The model name (e.g., 'User', 'Trail')
+ * @returns The model instance, or undefined if not registered
+ *
+ * @example
+ * ```ts
+ * const User = getModel('User')
+ * if (User) {
+ *   const users = await User.all()
+ * }
+ * ```
+ */
+export declare function getModel(name: string): ReturnType<typeof createBrowserModel> | undefined;
+/**
+ * Get all registered models as an array.
+ *
+ * @returns Array of all registered model instances
+ *
+ * @example
+ * ```ts
+ * const models = getAllModels()
+ * for (const model of models) {
+ *   console.log(model.getTable())
+ * }
+ * ```
+ */
+export declare function getAllModels(): ReturnType<typeof createBrowserModel>[];
+/**
+ * Get all registered models as a name-to-model map.
+ *
+ * @returns Record mapping model names to model instances
+ *
+ * @example
+ * ```ts
+ * const models = getModelRegistry()
+ * // { User: UserModel, Trail: TrailModel, ... }
+ * ```
+ */
+export declare function getModelRegistry(): Record<string, ReturnType<typeof createBrowserModel>>;
+/**
+ * Check if a model with the given name is registered.
+ *
+ * @param name - The model name to check
+ * @returns true if the model is registered
+ */
+export declare function hasModel(name: string): boolean;
+/**
+ * Clear all registered models. Primarily useful for testing.
+ */
+export declare function clearModelRegistry(): void;
 /**
  * Define an isomorphic model that works in both server and browser.
  *
  * In the browser, this creates a model that uses fetch() to call your API.
- * On the server, this returns the definition for ORM generation AND provides
- * query methods that work directly with the database.
+ * On the server, this uses the dynamic ORM (createModel) to provide fully
+ * typed query methods that work directly with the database — no code
+ * generation needed.
+ *
+ * The model is automatically registered in the global model registry,
+ * making it available via `getModel(name)` and `getAllModels()`.
  *
  * @param definition - The model definition
  * @returns An isomorphic model with query methods
@@ -24,4 +82,4 @@ export declare function defineModel<const TDef extends BrowserModelDefinition>(d
  * registerBrowserModels({ Trail, Activity })
  * ```
  */
-export declare function registerBrowserModels(models: Record<string, unknown>): void;
+export declare function registerBrowserModels(models: Record<string, unknown>): void;