bigal 16.0.0-beta.3 → 16.0.1

package/dist/index.d.cts

@@ -1,1527 +1,1613 @@
-interface ColumnBaseMetadataOptions {
-    /**
-     * Name of class with @table decorator
-     */
-    target: string;
-    /**
-     * Column name in the database
-     */
-    name: string;
-    /**
-     * Class property to which the column is applied
-     */
-    propertyName: string;
-    /**
-     * Indicates if a value is required for creates.
-     */
-    required?: boolean;
-    /**
-     * Indicates if column is inserted by default. Default is true
-     */
-    insert?: boolean;
-    /**
-     * Indicates if column value is updated by "save" operation. Default is true
-     */
-    update?: boolean;
-    /**
-     * Indicates if this column is a primary key.
-     * Same can be achieved when @primaryColumn decorator is used
-     */
-    primary?: boolean;
-    /**
-     * Value will be equal to `new Date()` when the row is inserted into the table
-     * Same can be achieved when @createDateColumn decorator is used
-     */
-    createDate?: boolean;
-    /**
-     * Value will be equal to `new Date()` when the row is updated
-     * Same can be achieved when @updateDateColumn decorator is used
-     */
-    updateDate?: boolean;
-    /**
-     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
-     * Same can be achieved when @versionColumn decorator is used
-     */
-    version?: boolean;
-}
-declare abstract class ColumnBaseMetadata {
-    /**
-     * Name of class with @table decorator
-     */
-    target: string;
-    /**
-     * Column name in the database
-     */
-    name: string;
-    /**
-     * Class property to which the column is applied
-     */
-    propertyName: string;
-    /**
-     * Indicates if a value is required for creates.
-     */
-    required: boolean;
-    /**
-     * Indicates if column is inserted by default. Default is true
-     */
-    insert: boolean;
-    /**
-     * Indicates if column value is updated by "save" operation. Default is true
-     */
-    update: boolean;
-    /**
-     * Indicates if this column is a primary key.
-     * Same can be achieved when @primaryColumn decorator is used
-     */
-    primary: boolean;
-    /**
-     * Value will be equal to `new Date()` when the row is inserted into the table
-     * Same can be achieved when @createDateColumn decorator is used
-     */
-    createDate: boolean;
-    /**
-     * Value will be equal to `new Date()` when the row is updated
-     * Same can be achieved when @updateDateColumn decorator is used
-     */
-    updateDate: boolean;
-    /**
-     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
-     * Same can be achieved when @versionColumn decorator is used
-     */
-    version: boolean;
-    protected constructor({ target, name, propertyName, required, insert, update, primary, createDate, updateDate, version, }: ColumnBaseMetadataOptions);
-}
-
-interface ColumnCollectionMetadataOptions extends ColumnBaseMetadataOptions {
-    /**
-     * Type of the items in the collection
-     */
-    collection: string | (() => string);
-    /**
-     * Property name of the on the collection item type
-     */
-    via: string;
-    /**
-     * Name of the junction table for multi-multi associations
-     */
-    through?: string | (() => string);
-}
-declare class ColumnCollectionMetadata extends ColumnBaseMetadata {
-    private _collectionString?;
-    private _collectionFn?;
-    private _throughString?;
-    private _throughFn?;
-    /**
-     * Type of the items in the collection
-     * @returns Name of collection
-     */
-    get collection(): string;
-    /**
-     * Property name of the on the collection item type
-     */
-    via: string;
-    /**
-     * Name of the junction table for multi-multi associations
-     * @returns Name of junction table
-     */
-    get through(): string | undefined;
-    constructor({ target, //
-    name, propertyName, required, insert, update, primary, createDate, updateDate, version, collection, via, through, }: ColumnCollectionMetadataOptions);
-}
-
-interface ColumnModelMetadataOptions extends ColumnBaseMetadataOptions {
-    /**
-     * Name of the model represented by this column id
-     */
-    model: string | (() => string);
-}
-declare class ColumnModelMetadata extends ColumnBaseMetadata {
-    private _modelString?;
-    private _modelFn?;
-    /**
-     * Name of the model represented by this column id
-     * @returns Name of model
-     */
-    get model(): string;
-    constructor({ target, //
-    name, propertyName, required, insert, update, primary, createDate, updateDate, version, model, }: ColumnModelMetadataOptions);
-}
-
-interface ColumnTypeMetadataOptions extends ColumnBaseMetadataOptions {
-    /**
-     * Type of sql column
-     */
-    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]' | 'uuid' | 'uuid[]';
-    /**
-     * Default database value
-     */
-    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
-    /**
-     * Array of possible enumerated values
-     */
-    enum?: readonly string[];
-    /**
-     * If set, enforces a maximum length check on the column
-     *
-     * Applies to types: string | string[]
-     */
-    maxLength?: number;
-}
-declare class ColumnTypeMetadata extends ColumnBaseMetadata {
-    /**
-     * Type of the column
-     */
-    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]' | 'uuid' | 'uuid[]';
-    /**
-     * Default database value
-     */
-    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
-    /**
-     * Array of possible enumerated values
-     */
-    enum?: readonly string[];
-    /**
-     * If set, enforces a maximum length check on the column
-     *
-     * Applies to types: string | string[]
-     */
-    maxLength?: number;
-    constructor(options: ColumnTypeMetadataOptions);
-}
-
-type ColumnMetadata$1 = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
-
-interface ColumnModifierMetadata {
-    /**
-     * Name of class with @table decorator
-     */
-    target: string;
-    /**
-     * Column name in the database
-     */
-    name?: string;
-    /**
-     * Class property to which the column is applied
-     */
-    propertyName: string;
-    /**
-     * Indicates if a value is required for creates.
-     */
-    required?: boolean;
-    /**
-     * Indicates if this column is a primary key.
-     * Same can be achieved when @primaryColumn decorator is used
-     */
-    primary?: boolean;
-    /**
-     * Value will be equal to `new Date()` when the row is inserted into the table
-     * Same can be achieved when @createDateColumn decorator is used
-     */
-    createDate?: boolean;
-    /**
-     * Value will be equal to `new Date()` when the row is updated
-     * Same can be achieved when @updateDateColumn decorator is used
-     */
-    updateDate?: boolean;
-    /**
-     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
-     * Same can be achieved when @versionColumn decorator is used
-     */
-    version?: boolean;
-    /**
-     * Type of sql column
-     */
-    type?: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
-    /**
-     * Name of the model represented by this column id
-     */
-    model?: string | (() => string);
-}
-
-type Column = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
-type ColumnByStringId$1 = Record<string, Column>;
-interface ModelMetadataOptions<_T extends Record<string, unknown>> {
-    name: string;
-    type?: {
-        new (): unknown;
-    };
-    connection?: string;
-    schema?: string;
-    tableName?: string;
-    readonly?: boolean;
-}
-declare class ModelMetadata<_T extends Record<string, unknown>> {
-    private _columns;
-    private _primaryKeyColumn;
-    private _createDateColumns;
-    private _updateDateColumns;
-    private _versionDateColumns;
-    set columns(columns: readonly Column[]);
-    get columns(): readonly Column[];
-    get primaryKeyColumn(): Column | undefined;
-    get createDateColumns(): readonly Column[];
-    get updateDateColumns(): readonly Column[];
-    get versionColumns(): readonly Column[];
-    get qualifiedTableName(): string;
-    name: string;
-    type?: {
-        new (): unknown;
-    };
-    connection?: string;
-    schema?: string;
-    tableName: string;
-    readonly: boolean;
-    columnsByColumnName: ColumnByStringId$1;
-    columnsByPropertyName: ColumnByStringId$1;
-    constructor({ name, //
-    type, connection, schema, tableName, readonly, }: ModelMetadataOptions<_T>);
-}
-
+//#region src/types/ClassLike.d.ts
+interface ClassLike {
+  /**
+  * Returns the name of the function. Function names are read-only and can not be changed.
+  */
+  readonly constructor: {
+    readonly name: string;
+  };
+}
+//#endregion
+//#region src/types/PoolLike.d.ts
 /**
- * Represents a row returned from a PostgreSQL query.
- * Compatible with pg's QueryResultRow type.
- */
+* Represents a row returned from a PostgreSQL query.
+* Compatible with pg's QueryResultRow type.
+*/
 interface QueryResultRow {
-    [column: string]: any;
+  [column: string]: any;
 }
 interface PoolQueryResult<TRow extends QueryResultRow> {
-    rows: TRow[];
-    rowCount: number | null;
+  rows: TRow[];
+  rowCount: number | null;
 }
 /**
- * Minimal interface for a PostgreSQL connection pool.
- * This interface is compatible with postgres-pool, node-postgres (pg),
- * `@neondatabase/serverless`, and other pg-compatible drivers.
- */
+* Minimal interface for a PostgreSQL connection pool.
+* This interface is compatible with postgres-pool, node-postgres (pg),
+* `@neondatabase/serverless`, and other pg-compatible drivers.
+*/
 interface PoolLike {
-    query<TRow extends QueryResultRow = QueryResultRow>(text: string, values?: readonly unknown[]): Promise<PoolQueryResult<TRow>>;
-}
-
-/**
- * Makes all properties optional for create/update operations.
- * BelongsTo fields already accept both FK values and entity objects via `EntityOrId` in InferSelect.
- */
-type CreateUpdateParams<T extends Record<string, unknown>> = {
-    [K in keyof T]?: T[K];
-};
-
-/**
- * Accepts either a FK value or an entity object with a matching `id` property.
- * BigAl extracts the primary key at runtime when an object is provided.
- *
- * @example
- * ```ts
- * // Both are valid for a belongsTo field:
- * product.store = 5;                          // FK value
- * product.store = { id: 5, name: 'Acme' };   // Entity object
- * ```
- */
-type EntityOrId<TFk> = TFk | (Record<string, unknown> & {
-    id: TFk;
-});
-
-interface BelongsToConfig<TFkType = number, TModelName extends string = string> {
-    brand: 'belongsTo';
-    fkType: TFkType;
-    modelName: TModelName;
-}
-declare class BelongsToBuilder<TFkType = number, TModelName extends string = string> {
-    readonly _: BelongsToConfig<TFkType, TModelName>;
-    /** Explicit FK column name, or empty string to auto-derive from property key */
-    dbColumnName: string;
-    readonly modelRef: string;
-    constructor(modelRef: string, dbColumnName?: string);
-}
-/**
- * Defines a many-to-one (belongsTo) relationship.
- *
- * The FK column name is auto-derived as `snakeCase(propertyKey) + '_id'` by `table()`.
- * Pass an explicit name to override: `belongsTo('Store', { name: 'shop_id' })`.
- *
- * @param {string} modelRef - Model name string (resolved at initialize() time)
- * @param {string | object} [options] - FK column name string or options object with `name`
- */
-declare function belongsTo<TFkType = number, TModelName extends string = string>(modelRef: TModelName, options?: string | {
-    name: string;
-}): BelongsToBuilder<TFkType, TModelName>;
-
-interface ColumnBuilderConfig<TData = unknown, TNotNull extends boolean = boolean, THasDefault extends boolean = boolean, TIsPrimaryKey extends boolean = boolean, TIsAutoSet extends boolean = boolean> {
-    brand: 'column';
-    data: TData;
-    notNull: TNotNull;
-    hasDefault: THasDefault;
-    isPrimaryKey: TIsPrimaryKey;
-    isAutoSet: TIsAutoSet;
-}
-interface ColumnBuilderRuntimeConfig {
-    dbColumnName: string;
-    columnType: string;
-    isNotNull: boolean;
-    hasDefaultValue: boolean;
-    isPrimaryKey: boolean;
-    isAutoSet: boolean;
-    isUnique: boolean;
-    isCreateDate: boolean;
-    isUpdateDate: boolean;
-    isVersion: boolean;
-    defaultValue: unknown;
-    maxLength: number | undefined;
-}
-declare class ColumnBuilder<TConfig extends ColumnBuilderConfig = ColumnBuilderConfig> {
-    readonly _: TConfig;
-    readonly config: ColumnBuilderRuntimeConfig;
-    constructor(columnType: string, dbColumnName?: string);
-    notNull(): ColumnBuilder<TConfig & {
-        notNull: true;
-    }>;
-    default(value: TConfig['data']): ColumnBuilder<TConfig & {
-        hasDefault: true;
-    }>;
-    primaryKey(): ColumnBuilder<TConfig & {
-        notNull: true;
-        hasDefault: true;
-        isPrimaryKey: true;
-    }>;
-    unique(): ColumnBuilder<TConfig>;
-    version(): ColumnBuilder<TConfig & {
-        notNull: true;
-    }>;
-    toColumnTypeMetadataOptions(propertyName: string, tableName: string): ColumnTypeMetadataOptions;
-}
-
-interface HasManyConfig<TModelName extends string = string> {
-    brand: 'hasMany';
-    modelName: TModelName;
-}
-interface HasManyThroughIntermediate<TModelName extends string = string> {
-    via(propertyName: string): HasManyBuilder<TModelName>;
-}
-declare class HasManyBuilder<TModelName extends string = string> {
-    readonly _: HasManyConfig<TModelName>;
-    readonly modelRef: string;
-    viaPropertyName: string | undefined;
-    throughRef: string | undefined;
-    constructor(modelRef: string);
-    via(propertyName: string): HasManyBuilder<TModelName>;
-    through(throughRef: string): HasManyThroughIntermediate<TModelName>;
+  query<TRow extends QueryResultRow = QueryResultRow>(text: string, values?: readonly unknown[]): Promise<PoolQueryResult<TRow>>;
 }
+//#endregion
+//#region src/types/ExcludeEntityCollections.d.ts
 /**
- * Defines a one-to-many or many-to-many (hasMany) relationship.
- *
- * @param {string} modelRef - Model name string (resolved at initialize() time)
- */
-declare function hasMany<TModelName extends string = string>(modelRef: TModelName): HasManyBuilder<TModelName>;
-
-/**
- * Any value that can appear in a schema definition object passed to `table()`.
- */
-type SchemaEntry = BelongsToBuilder<unknown> | ColumnBuilder<ColumnBuilderConfig> | HasManyBuilder;
-/**
- * A schema definition is a record of property names to schema entries.
- */
-type SchemaDefinition = Record<string, SchemaEntry>;
-/** Keys for columns and belongsTo (actual database columns) */
-type ColumnKeys<TSchema extends SchemaDefinition> = {
-    [K in keyof TSchema]: TSchema[K] extends HasManyBuilder ? never : K;
-}[keyof TSchema];
-/** Keys for hasMany relationships (collections, available for populate) */
-type CollectionKeys<TSchema extends SchemaDefinition> = {
-    [K in keyof TSchema]: TSchema[K] extends HasManyBuilder ? K : never;
-}[keyof TSchema];
-/** All keys from the schema (columns + collections). Used for external consumers. */
-type SelectKeys<TSchema extends SchemaDefinition> = keyof TSchema & string;
-/**
- * Keys that are required on insert: notNull columns that have no default, are not primary keys, and are not auto-set.
- * BelongsTo FK columns are always required on insert (they represent a foreign key value).
- */
-type RequiredInsertKeys<TSchema extends SchemaDefinition> = {
-    [K in keyof TSchema]: TSchema[K] extends HasManyBuilder ? never : TSchema[K] extends BelongsToBuilder<unknown> ? K : TSchema[K] extends ColumnBuilder<infer TConf> ? TConf extends {
-        notNull: true;
-    } ? TConf extends {
-        hasDefault: true;
-    } ? never : TConf extends {
-        isPrimaryKey: true;
-    } ? never : TConf extends {
-        isAutoSet: true;
-    } ? never : K : never : never;
-}[keyof TSchema];
-/**
- * Keys that are optional on insert: nullable columns, columns with defaults, primary keys, and auto-set columns.
- * HasMany keys are excluded entirely.
- */
-type OptionalInsertKeys<TSchema extends SchemaDefinition> = Exclude<ColumnKeys<TSchema>, RequiredInsertKeys<TSchema>>;
-/**
- * Extracts the TypeScript select type for a single schema entry.
- * - ColumnBuilder: `TData` if notNull, otherwise `TData | null`
- * - BelongsToBuilder: `EntityOrId<TFk>` - accepts FK value or entity object with matching id.
- *   Use `QueryResult` to narrow back to just the FK type for query results.
- * - HasManyBuilder: never (excluded at the key level)
- */
-type InferSelectColumn<TEntry extends SchemaEntry> = TEntry extends ColumnBuilder<infer TConf> ? (TConf extends {
-    notNull: true;
-} ? TConf['data'] : TConf['data'] | null) : TEntry extends BelongsToBuilder<infer TFk> ? EntityOrId<TFk> : never;
-/**
- * Extracts the TypeScript insert type for a single schema entry.
- * Same widening as select: belongsTo accepts FK value or entity object.
- */
-type InferInsertColumn<TEntry extends SchemaEntry> = TEntry extends ColumnBuilder<infer TConf> ? (TConf extends {
-    notNull: true;
-} ? TConf['data'] : TConf['data'] | null) : TEntry extends BelongsToBuilder<infer TFk> ? EntityOrId<TFk> : never;
+* Removes all entity collection properties. To be used as a re-map key function
+*/
+type ExcludeEntityCollections<T, K extends PropertyKey> = T extends NotEntityBrand[] | undefined ? K : T extends Entity[] | undefined ? never : K;
+//#endregion
+//#region src/types/ExcludeFunctions.d.ts
 /**
- * Infers the full model type from a schema definition.
- * Includes hasMany as optional `Record<string, unknown>[]` for populate support.
- * Use `QueryResult` to narrow for query results (strips hasMany, narrows belongsTo to FK).
- */
-type InferSelect<TSchema extends SchemaDefinition> = {
-    [K in ColumnKeys<TSchema>]: InferSelectColumn<TSchema[K]>;
-} & {
-    [K in CollectionKeys<TSchema>]?: Record<string, unknown>[];
-};
-/**
- * Infers the insert (write) type from a schema definition.
- * Required keys are non-nullable columns without defaults.
- * Optional keys include nullable columns, columns with defaults, primary keys, and auto-set columns.
- * HasMany relationships are excluded entirely.
- */
-type InferInsert<TSchema extends SchemaDefinition> = {
-    [K in RequiredInsertKeys<TSchema>]: InferInsertColumn<TSchema[K]>;
-} & {
-    [K in OptionalInsertKeys<TSchema>]?: InferInsertColumn<TSchema[K]>;
-};
-/** Keys in the schema that are BelongsToBuilder (many-to-one FK columns) */
-type BelongsToKeys<TSchema extends SchemaDefinition> = {
-    [K in keyof TSchema]: TSchema[K] extends BelongsToBuilder<unknown> ? K : never;
-}[keyof TSchema];
-/** Keys in the schema that are HasManyBuilder (collection relationships) */
-type HasManyKeys<TSchema extends SchemaDefinition> = {
-    [K in keyof TSchema]: TSchema[K] extends HasManyBuilder ? K : never;
-}[keyof TSchema];
-/** Keys in the schema that are any relationship (belongsTo or hasMany) */
-type RelationshipKeys<TSchema extends SchemaDefinition> = BelongsToKeys<TSchema> | HasManyKeys<TSchema>;
-/** Keys that are populate-able (both belongsTo and hasMany). Falls back to all string keys when schema is default. */
-type PopulatableKeys<TSchema extends SchemaDefinition> = SchemaDefinition extends TSchema ? string : RelationshipKeys<TSchema>;
-/** Extracts the branded model name string from a schema entry */
-type ModelNameOf<TEntry extends SchemaEntry> = TEntry extends BelongsToBuilder<unknown, infer TName> ? TName : TEntry extends HasManyBuilder<infer TName> ? TName : never;
-
-/**
- * Excludes hasMany collection keys from K when a concrete TSchema is provided.
- * Falls back to passing through all keys when TSchema is the default.
- */
-type ExcludeEntityCollections<K extends PropertyKey, TSchema extends SchemaDefinition = SchemaDefinition> = SchemaDefinition extends TSchema ? K : K extends HasManyKeys<TSchema> ? never : K;
-
-/**
- * Removes all functions and entity collection properties. To be used as a re-map key function
- */
+* Removes all functions and entity collection properties. To be used as a re-map key function
+*/
 type ExcludeFunctions<T, K extends PropertyKey> = T extends Function ? never : K;
-
+//#endregion
+//#region src/types/CreateUpdateParams.d.ts
+/**
+* Changes all Entity value properties to Primitive (string|number) | Pick<Entity, 'id'>
+*/
+type CreateUpdateParams<T extends Entity> = { [K in keyof T as ExcludeEntityCollections<NonNullable<T[K]>, ExcludeFunctions<T[K], K>>]?: T[K] extends NotEntityBrand | undefined ? T[K] : Extract<T[K], Entity> extends undefined ? T[K] : Exclude<T[K], Entity> | Pick<Extract<T[K], Entity>, "id"> };
+//#endregion
+//#region src/types/EntityPrimitiveOrId.d.ts
+type EntityPrimitiveOrId<T> = T extends [] ? T extends (infer U)[] ? EntityPrimitiveOrId<U>[] : T : Extract<NonNullable<T>, Entity> extends undefined ? T : Exclude<NonNullable<T>, Entity> | Pick<Extract<NonNullable<T>, Entity>, "id">;
+//#endregion
+//#region src/types/GetValueType.d.ts
 type GetValueType<T, TValueType> = T extends TValueType[] ? T extends (infer U)[] ? Extract<U, TValueType> : never : T extends TValueType ? T : never;
-
+//#endregion
+//#region src/types/IncludeFunctions.d.ts
 /**
- * Returns the key name if the property type is a function
- */
+* Returns the key name if the property type is a function
+*/
 type IncludeFunctions<T, K extends PropertyKey> = T extends Function ? K : never;
-
+//#endregion
+//#region src/types/IsValueOfType.d.ts
 type IsValueOfType<T, K extends PropertyKey, TValueType> = T extends TValueType | TValueType[] | undefined ? K : never;
-
-/**
- * Identifies keys that are relationships (belongsTo or hasMany).
- * Used to constrain `.join()` and `.leftJoin()` to relationship properties only.
- * When a concrete TSchema is provided, only actual relationship keys are returned.
- * When TSchema is the default (SchemaDefinition), falls back to all string keys.
- */
-type ModelRelationshipKeys<T extends Record<string, unknown>, TSchema extends SchemaDefinition = SchemaDefinition> = SchemaDefinition extends TSchema ? string & keyof T : string & RelationshipKeys<TSchema> & keyof T;
-
+//#endregion
+//#region src/types/ModelRelationshipKeys.d.ts
+type ModelRelationshipKeys<T extends Entity> = { [K in keyof T]: Extract<T[K], Entity> extends never ? never : K }[keyof T] & string;
+//#endregion
+//#region src/types/OmitEntityCollections.d.ts
 /**
- * Removes hasMany collection keys from a row type.
- * When a concrete TSchema is provided, only hasMany keys are excluded.
- * When TSchema is the default, all keys are preserved.
- */
-type OmitEntityCollections<T, TSchema extends SchemaDefinition = SchemaDefinition> = SchemaDefinition extends TSchema ? T : Omit<T, HasManyKeys<TSchema> & keyof T>;
-
+* Removes all entity collection properties
+*/
+type OmitEntityCollections<T> = { [K in keyof T as ExcludeEntityCollections<T[K], K>]: T[K] };
+//#endregion
+//#region src/types/OmitFunctions.d.ts
 /**
- * Removes all functions
- */
-type OmitFunctions<T> = {
-    [K in keyof T as ExcludeFunctions<T[K], K>]: T[K];
-};
-
-type PickAsType<T, K extends keyof T, TValue> = {
-    [P in K]: Extract<T[P], TValue>;
-};
-
-type PickByValueType<T, TValueType> = {
-    [K in keyof T as IsValueOfType<T[K], K, TValueType>]: GetValueType<T[K], TValueType>;
-};
-
-type PickFunctions<T> = {
-    [K in keyof T as IncludeFunctions<T[K], K>]: T[K];
-};
-
-type ColumnMetadata = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
-type ColumnByStringId = Record<string, ColumnMetadata>;
-interface ModelHooks<TInsert, TSelect = TInsert> {
-    beforeCreate?: (values: TInsert) => Promise<TInsert> | TInsert;
-    afterCreate?: (result: TSelect) => Promise<void> | void;
-    beforeUpdate?: (values: Partial<TInsert>) => Partial<TInsert> | Promise<Partial<TInsert>>;
-    afterUpdate?: (result: TSelect) => Promise<void> | void;
-    beforeDestroy?: (where: Record<string, unknown>) => Promise<Record<string, unknown>> | Record<string, unknown>;
-    afterDestroy?: (result: {
-        rowCount: number;
-    }) => Promise<void> | void;
-    afterFind?: (results: TSelect[]) => Promise<TSelect[]> | TSelect[];
-}
-/** A filter definition: a static where clause or a function that returns one dynamically */
-type FilterDefinition = (() => Record<string, unknown>) | Record<string, unknown>;
-interface TableOptions<TInsert, TSelect = TInsert> {
-    /** Unique model name for relationship lookups. Defaults to the table name. */
-    modelName?: string;
-    schema?: string;
-    readonly?: boolean;
-    connection?: string;
-    hooks?: ModelHooks<TInsert, TSelect>;
-    /** Named filters applied automatically to every query. Override per-query via `filters` option. */
-    filters?: Record<string, FilterDefinition>;
-}
-interface TableDefinition<TName extends string = string, TSchema extends SchemaDefinition = SchemaDefinition> {
-    /** Unique model name used for relationship lookups. Defaults to tableName. */
-    readonly modelName: string;
-    readonly tableName: TName;
-    readonly dbSchema: string | undefined;
-    readonly isReadonly: boolean;
-    readonly connection: string | undefined;
-    readonly schema: TSchema;
-    readonly hooks: ModelHooks<InferInsert<TSchema>, InferSelect<TSchema>> | undefined;
-    readonly filters: Record<string, FilterDefinition> | undefined;
-    readonly columnsByPropertyName: Readonly<ColumnByStringId>;
-    readonly columnsByColumnName: Readonly<ColumnByStringId>;
-    readonly columns: readonly ColumnMetadata[];
-    readonly primaryKeyColumn: ColumnMetadata | undefined;
-    readonly createDateColumns: readonly ColumnMetadata[];
-    readonly updateDateColumns: readonly ColumnMetadata[];
-    readonly versionColumns: readonly ColumnMetadata[];
-    readonly belongsToEntries: readonly BelongsToEntry[];
-    readonly hasManyEntries: readonly HasManyEntry[];
-}
-interface BelongsToEntry {
-    readonly propertyName: string;
-    readonly builder: BelongsToBuilder<unknown>;
-}
-interface HasManyEntry {
-    readonly propertyName: string;
-    readonly builder: HasManyBuilder;
-}
-declare function table<TName extends string, TSchema extends SchemaDefinition>(tableName: TName, schemaDefinition: TSchema, options?: TableOptions<InferInsert<TSchema>, InferSelect<TSchema>>): TableDefinition<TName, TSchema>;
+* Removes all functions
+*/
+type OmitFunctions<T> = { [K in keyof T as ExcludeFunctions<T[K], K>]: T[K] };
+//#endregion
+//#region src/types/PickAsType.d.ts
+type PickAsType<T, K extends keyof T, TValue> = { [P in K]: Extract<T[P], TValue> };
+//#endregion
+//#region src/types/PickByValueType.d.ts
+type PickByValueType<T, TValueType> = { [K in keyof T as IsValueOfType<T[K], K, TValueType>]: GetValueType<T[K], TValueType> };
+//#endregion
+//#region src/types/PickFunctions.d.ts
+type PickFunctions<T> = { [K in keyof T as IncludeFunctions<T[K], K>]: T[K] };
+//#endregion
+//#region src/types/PlainObject.d.ts
 /**
- * Defines a read-only table definition backed by a PostgreSQL view.
- * Equivalent to `table(name, schema, { readonly: true, ...options })`.
- * Returns a `ReadonlyRepository` when registered with `initialize`.
- * @param {string} viewName - The PostgreSQL view name
- * @param {TSchema} schemaDefinition - Column definitions
- * @param {object} [options] - Additional options (schema, connection, modelName)
- */
-declare function view<TName extends string, TSchema extends SchemaDefinition>(viewName: TName, schemaDefinition: TSchema, options?: Omit<TableOptions<InferInsert<TSchema>, InferSelect<TSchema>>, 'readonly'>): TableDefinition<TName, TSchema>;
-
+* Recursively converts entity types to plain object types.
+* This is primarily for documentation/intent - at runtime, this strips the prototype chain.
+* Preserves Date objects as-is since they're serializable by most frameworks.
+*/
+type PlainObject<T> = T extends Date ? Date : T extends (infer U)[] ? PlainObject<U>[] : T extends object ? { [K in keyof T]: PlainObject<T[K]> } : T;
+//#endregion
+//#region src/types/QueryResult.d.ts
 /**
- * Produces the row type for query results.
- *
- * Narrows belongsTo fields from `EntityOrId<TFk>` back to just `TFk`, and excludes
- * hasMany collection keys. Query results always contain the FK value, not entity objects.
- *
- * Accepts a TableDefinition, a repository, or a plain row type:
- * - `QueryResult<typeof Product>` - from a model definition or repository
- * - `QueryResult<ProductRow>` - from a plain row type (backward compat)
- */
-type AnyTableDef$2 = TableDefinition<string, any>;
-/** Narrows belongsTo fields to FK type and excludes hasMany */
-type NarrowForQuery<TSchema extends SchemaDefinition> = {
-    [K in Exclude<keyof InferSelect<TSchema>, HasManyKeys<TSchema>>]: K extends BelongsToKeys<TSchema> ? TSchema[K & keyof TSchema] extends BelongsToBuilder<infer TFk> ? TFk : InferSelect<TSchema>[K] : InferSelect<TSchema>[K];
-};
-/** Structural match for repositories - carries schema via phantom `_schema` property */
-interface HasSchema$1<TSchema extends SchemaDefinition = SchemaDefinition> {
-    readonly _schema?: TSchema;
-}
-type ResolveFromSchema<TSchema extends SchemaDefinition> = SchemaDefinition extends TSchema ? never : NarrowForQuery<TSchema>;
-type QueryResult<T extends AnyTableDef$2 | HasSchema$1 | Record<string, unknown>, TSchema extends SchemaDefinition = SchemaDefinition> = T extends TableDefinition<string, infer TInferredSchema> ? NarrowForQuery<TInferredSchema> : T extends {
-    _schema?: infer TRepoSchema extends SchemaDefinition;
-} ? ResolveFromSchema<TRepoSchema> extends never ? SchemaDefinition extends TSchema ? T : Omit<T, HasManyKeys<TSchema> & keyof T> : ResolveFromSchema<TRepoSchema> : SchemaDefinition extends TSchema ? T : Omit<T, HasManyKeys<TSchema> & keyof T>;
-
+* Changes all properties with Entity values to Primitive (string|number). Removes any properties that with values
+* of Entity arrays
+*/
+type QueryResult<T extends Entity> = Extract<{ [K in keyof T as ExcludeEntityCollections<NonNullable<T[K]>, K>]: T[K] extends NotEntityBrand | undefined ? T[K] : Exclude<T[K], Entity> }, T>;
+//#endregion
+//#region src/types/Populated.d.ts
 /**
- * Removes primitives from specified properties and makes them non-optional.
- * Allows singular entity properties to be null.
- */
-type Populated<T extends Record<string, unknown>, K extends keyof T, TPropertyType extends Record<string, unknown>, TPropertyKeys extends keyof TPropertyType> = {
-    [P in K]-?: T[P] extends unknown[] | undefined ? QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType>>>[] : undefined extends T[P] ? QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType>>> | null : QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType>>>;
-};
-
+* Removes primitives from specified properties and make non-optional. Allow singular Entity properties to be null.
+*/
+type Populated<T extends Entity, K extends keyof T, TPropertyType extends Entity, TPropertyKeys extends keyof TPropertyType> = { [P in K]-?: Extract<T[P], Entity | Entity[]> extends Entity ? undefined extends T[P] ? QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType> | "id">> | null : QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType> | "id">> : QueryResult<Pick<TPropertyType, TPropertyKeys | keyof PickFunctions<TPropertyType> | "id">>[] };
+//#endregion
+//#region src/types/QueryResultPopulated.d.ts
 /**
- * Allows a QueryResult type with specific populated properties.
- * In the new schema API, populated properties resolve to the related entity's select type.
- */
-type QueryResultPopulated<T extends Record<string, unknown>, K extends keyof T> = Omit<QueryResult<T>, K> & {
-    [P in K]-?: T[P] extends unknown[] ? QueryResult<GetValueType<T[P], Record<string, unknown>>>[] : undefined extends T[P] ? QueryResult<GetValueType<T[P], Record<string, unknown>>> | null : QueryResult<GetValueType<T[P], Record<string, unknown>>>;
-};
-
-type AnyModel$5 = TableDefinition<string, any>;
+* Allows a QueryResult type with specific populated properties
+*/
+type QueryResultPopulated<T extends Entity, K extends keyof T> = Omit<QueryResult<T>, K> & { [P in K]-?: Extract<T[P], Entity | Entity[]> extends Entity ? undefined extends T[P] ? QueryResult<GetValueType<T[P], Entity>> | null : QueryResult<GetValueType<T[P], Entity>> : QueryResult<GetValueType<T[P], Entity>>[] };
+//#endregion
+//#region src/types/QueryResultOptionalPopulated.d.ts
 /**
- * Resolves a model name string to the query result row type using the models map.
- * Used by populate() to produce fully typed results for related entities.
- *
- * Falls back to `Record<string, unknown>` when the model name isn't in the map.
- */
-type ResolveModel<TModels extends Record<string, AnyModel$5>, TModelName extends string> = TModelName extends keyof TModels ? TModels[TModelName] extends TableDefinition<string, infer TSchema> ? InferSelect<TSchema> : Record<string, unknown> : Record<string, unknown>;
+* Allows a QueryResult type with specific properties optionally populated. If the property is populated, only the id property is needed
+*/
+type QueryResultOptionalPopulated<T extends Entity, K extends keyof T> = Omit<QueryResult<T>, K> & { [P in K]-?: T[P] extends [] ? undefined extends T[P] ? EntityPrimitiveOrId<T[P]> | null : EntityPrimitiveOrId<T[P]> : EntityPrimitiveOrId<T[P]> };
+//#endregion
+//#region src/Entity.d.ts
+type EntityFieldValue = boolean[] | Date | number[] | Record<string, unknown> | string[] | boolean | number | string | unknown | null;
+declare abstract class Entity {
+  abstract id: unknown;
+  static beforeCreate(values: CreateUpdateParams<Entity>): CreateUpdateParams<Entity> | Promise<CreateUpdateParams<Entity>>;
+  static beforeUpdate(values: CreateUpdateParams<Entity>): CreateUpdateParams<Entity> | Promise<CreateUpdateParams<Entity>>;
+}
+interface NotEntityBrand {
+  _notEntityBrand: void;
+}
+type NotEntity<T> = NotEntityBrand & T;
+interface EntityStatic<T extends Entity> {
+  beforeCreate?: (values: CreateUpdateParams<any>) => CreateUpdateParams<any> | Promise<CreateUpdateParams<any>>;
+  beforeUpdate?: (values: CreateUpdateParams<any>) => CreateUpdateParams<any> | Promise<CreateUpdateParams<any>>;
+  new (): T;
+}
+//#endregion
+//#region src/metadata/ColumnBaseMetadata.d.ts
+interface ColumnBaseMetadataOptions {
+  /**
+  * Name of class with @table decorator
+  */
+  target: string;
+  /**
+  * Column name in the database
+  */
+  name: string;
+  /**
+  * Class property to which the column is applied
+  */
+  propertyName: string;
+  /**
+  * Indicates if a value is required for creates.
+  */
+  required?: boolean;
+  /**
+  * Indicates if column is inserted by default. Default is true
+  */
+  insert?: boolean;
+  /**
+  * Indicates if column value is updated by "save" operation. Default is true
+  */
+  update?: boolean;
+  /**
+  * Indicates if this column is a primary key.
+  * Same can be achieved when @primaryColumn decorator is used
+  */
+  primary?: boolean;
+  /**
+  * Value will be equal to `new Date()` when the row is inserted into the table
+  * Same can be achieved when @createDateColumn decorator is used
+  */
+  createDate?: boolean;
+  /**
+  * Value will be equal to `new Date()` when the row is updated
+  * Same can be achieved when @updateDateColumn decorator is used
+  */
+  updateDate?: boolean;
+  /**
+  * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+  * Same can be achieved when @versionColumn decorator is used
+  */
+  version?: boolean;
+}
+declare abstract class ColumnBaseMetadata {
+  /**
+  * Name of class with @table decorator
+  */
+  target: string;
+  /**
+  * Column name in the database
+  */
+  name: string;
+  /**
+  * Class property to which the column is applied
+  */
+  propertyName: string;
+  /**
+  * Indicates if a value is required for creates.
+  */
+  required: boolean;
+  /**
+  * Indicates if column is inserted by default. Default is true
+  */
+  insert: boolean;
+  /**
+  * Indicates if column value is updated by "save" operation. Default is true
+  */
+  update: boolean;
+  /**
+  * Indicates if this column is a primary key.
+  * Same can be achieved when @primaryColumn decorator is used
+  */
+  primary: boolean;
+  /**
+  * Value will be equal to `new Date()` when the row is inserted into the table
+  * Same can be achieved when @createDateColumn decorator is used
+  */
+  createDate: boolean;
+  /**
+  * Value will be equal to `new Date()` when the row is updated
+  * Same can be achieved when @updateDateColumn decorator is used
+  */
+  updateDate: boolean;
+  /**
+  * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+  * Same can be achieved when @versionColumn decorator is used
+  */
+  version: boolean;
+  protected constructor({
+    target,
+    name,
+    propertyName,
+    required,
+    insert,
+    update,
+    primary,
+    createDate,
+    updateDate,
+    version
+  }: ColumnBaseMetadataOptions);
+}
+//#endregion
+//#region src/metadata/ColumnCollectionMetadata.d.ts
+interface ColumnCollectionMetadataOptions extends ColumnBaseMetadataOptions {
+  /**
+  * Type of the items in the collection
+  */
+  collection: string | (() => string);
+  /**
+  * Property name of the on the collection item type
+  */
+  via: string;
+  /**
+  * Name of the junction table for multi-multi associations
+  */
+  through?: string | (() => string);
+}
+declare class ColumnCollectionMetadata extends ColumnBaseMetadata {
+  private _collectionString?;
+  private _collectionFn?;
+  private _throughString?;
+  private _throughFn?;
+  /**
+  * Type of the items in the collection
+  * @returns Name of collection
+  */
+  get collection(): string;
+  /**
+  * Property name of the on the collection item type
+  */
+  via: string;
+  /**
+  * Name of the junction table for multi-multi associations
+  * @returns Name of junction table
+  */
+  get through(): string | undefined;
+  constructor({
+    target,
+    name,
+    propertyName,
+    required,
+    insert,
+    update,
+    primary,
+    createDate,
+    updateDate,
+    version,
+    collection,
+    via,
+    through
+  }: ColumnCollectionMetadataOptions);
+}
+//#endregion
+//#region src/metadata/ColumnModelMetadata.d.ts
+interface ColumnModelMetadataOptions extends ColumnBaseMetadataOptions {
+  /**
+  * Name of the model represented by this column id
+  */
+  model: string | (() => string);
+}
+declare class ColumnModelMetadata extends ColumnBaseMetadata {
+  private _modelString?;
+  private _modelFn?;
+  /**
+  * Name of the model represented by this column id
+  * @returns Name of model
+  */
+  get model(): string;
+  constructor({
+    target,
+    name,
+    propertyName,
+    required,
+    insert,
+    update,
+    primary,
+    createDate,
+    updateDate,
+    version,
+    model
+  }: ColumnModelMetadataOptions);
+}
+//#endregion
+//#region src/metadata/ColumnTypeMetadata.d.ts
+interface ColumnTypeMetadataOptions extends ColumnBaseMetadataOptions {
+  /**
+  * Type of sql column
+  */
+  type: "array" | "binary" | "boolean" | "boolean[]" | "date" | "datetime" | "float" | "float[]" | "integer" | "integer[]" | "json" | "string" | "string[]" | "uuid" | "uuid[]" | "vector";
+  /**
+  * Default database value
+  */
+  defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+  /**
+  * Number of dimensions for the column. Informational only - BigAl does not issue DDL
+  *
+  * Applies to types: vector
+  */
+  dimensions?: number;
+  /**
+  * Array of possible enumerated values
+  */
+  enum?: readonly string[];
+  /**
+  * If set, enforces a maximum length check on the column
+  *
+  * Applies to types: string | string[]
+  */
+  maxLength?: number;
+}
+declare class ColumnTypeMetadata extends ColumnBaseMetadata {
+  /**
+  * Type of the column
+  */
+  type: "array" | "binary" | "boolean" | "boolean[]" | "date" | "datetime" | "float" | "float[]" | "integer" | "integer[]" | "json" | "string" | "string[]" | "uuid" | "uuid[]" | "vector";
+  /**
+  * Default database value
+  */
+  defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+  /**
+  * Number of dimensions for the column. Informational only - BigAl does not issue DDL
+  *
+  * Applies to types: vector
+  */
+  dimensions?: number;
+  /**
+  * Array of possible enumerated values
+  */
+  enum?: readonly string[];
+  /**
+  * If set, enforces a maximum length check on the column
+  *
+  * Applies to types: string | string[]
+  */
+  maxLength?: number;
+  constructor(options: ColumnTypeMetadataOptions);
+}
+//#endregion
+//#region src/metadata/ColumnMetadata.d.ts
+type ColumnMetadata = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
+//#endregion
+//#region src/metadata/ColumnModifierMetadata.d.ts
+interface ColumnModifierMetadata {
+  /**
+  * Name of class with @table decorator
+  */
+  target: string;
+  /**
+  * Column name in the database
+  */
+  name?: string;
+  /**
+  * Class property to which the column is applied
+  */
+  propertyName: string;
+  /**
+  * Indicates if a value is required for creates.
+  */
+  required?: boolean;
+  /**
+  * Indicates if this column is a primary key.
+  * Same can be achieved when @primaryColumn decorator is used
+  */
+  primary?: boolean;
+  /**
+  * Value will be equal to `new Date()` when the row is inserted into the table
+  * Same can be achieved when @createDateColumn decorator is used
+  */
+  createDate?: boolean;
+  /**
+  * Value will be equal to `new Date()` when the row is updated
+  * Same can be achieved when @updateDateColumn decorator is used
+  */
+  updateDate?: boolean;
+  /**
+  * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+  * Same can be achieved when @versionColumn decorator is used
+  */
+  version?: boolean;
+  /**
+  * Type of sql column
+  */
+  type?: "array" | "binary" | "boolean" | "boolean[]" | "date" | "datetime" | "float" | "float[]" | "integer" | "integer[]" | "json" | "string" | "string[]" | "vector";
+  /**
+  * Name of the model represented by this column id
+  */
+  model?: string | (() => string);
+}
+//#endregion
+//#region src/metadata/ModelMetadata.d.ts
+type Column = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
+type ColumnByStringId = Record<string, Column>;
+interface ModelMetadataOptions<T extends Entity> {
+  name: string;
+  type: EntityStatic<T>;
+  connection?: string;
+  schema?: string;
+  tableName?: string;
+  readonly?: boolean;
+}
+declare class ModelMetadata<T extends Entity> {
+  private _columns;
+  private _primaryKeyColumn;
+  private _createDateColumns;
+  private _updateDateColumns;
+  private _versionDateColumns;
+  set columns(columns: readonly Column[]);
+  get columns(): readonly Column[];
+  get primaryKeyColumn(): Column | undefined;
+  get createDateColumns(): readonly Column[];
+  get updateDateColumns(): readonly Column[];
+  get versionColumns(): readonly Column[];
+  get qualifiedTableName(): string;
+  name: string;
+  type: EntityStatic<T>;
+  connection?: string;
+  schema?: string;
+  tableName: string;
+  readonly: boolean;
+  columnsByColumnName: ColumnByStringId;
+  columnsByPropertyName: ColumnByStringId;
+  constructor({
+    name,
+    type,
+    connection,
+    schema,
+    tableName,
+    readonly
+  }: ModelMetadataOptions<T>);
+}
+//#endregion
+//#region src/metadata/MetadataStorage.d.ts
 /**
- * Default models map type. When TModels is this default, populate falls back
- * to `Record<string, unknown>` for populated entity types.
- */
-type DefaultModelsMap = Record<string, AnyModel$5>;
-
+* This represents an object to store all of the decorator data. Since there can be multiple decorators per
+* class/property, things will be reconciled when entities are initialized
+*/
+declare class MetadataStorage<T extends Entity> {
+  readonly models: ModelMetadata<T>[];
+  readonly columns: ColumnMetadata[];
+  readonly columnModifiers: ColumnModifierMetadata[];
+}
+//#endregion
+//#region src/metadata/index.d.ts
+declare function getMetadataStorage<T extends Entity>(): MetadataStorage<T>;
+//#endregion
+//#region src/query/Sort.d.ts
+type SortString<T extends Entity> = `${string & keyof OmitFunctions<OmitEntityCollections<T>>} ASC` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>} asc` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>} DESC` | `${string & keyof OmitFunctions<OmitEntityCollections<T>>} desc` | (string & keyof OmitFunctions<OmitEntityCollections<T>>);
+type ValidateMultipleSorts<T extends Entity, TNextSortPart extends string, TPreviouslyValidatedSortString extends string, TSortString extends string> = TNextSortPart extends `, ${SortString<T>}${infer TRestSortPart}` ? TRestSortPart extends "" ? TSortString : ValidateMultipleSorts<T, TRestSortPart, TNextSortPart extends `${infer TValidatedSortPart}${TRestSortPart}` ? `${TPreviouslyValidatedSortString}${TValidatedSortPart}` : never, TSortString> : `${TPreviouslyValidatedSortString}, ${SortString<T>}`;
+type MultipleSortString<T extends Entity, TSortString extends string = string> = TSortString extends `${SortString<T>}${infer TRestSortPart}` ? TRestSortPart extends "" ? TSortString : ValidateMultipleSorts<T, TRestSortPart, TSortString extends `${infer TPreviouslyValidatedSortString}${TRestSortPart}` ? TPreviouslyValidatedSortString : never, TSortString> : SortString<T>;
+type SortObjectValue = -1 | "asc" | "desc" | 1;
+type VectorDistanceMetric = "cosine" | "innerProduct" | "l1" | "l2";
+interface VectorDistanceSort {
+  nearestTo: number[];
+  metric?: VectorDistanceMetric;
+}
+type SortObject<T extends Entity> = { [K in keyof T as ExcludeFunctions<OmitEntityCollections<T>, K>]?: SortObjectValue | VectorDistanceSort };
+type Sort<T extends Entity> = MultipleSortString<T> | SortObject<T>;
+interface OrderBy<T extends Entity> {
+  propertyName: string & keyof OmitFunctions<OmitEntityCollections<T>>;
+  descending?: boolean;
+  vectorDistance?: {
+    vector: number[];
+    metric: VectorDistanceMetric;
+  };
+}
+//#endregion
+//#region src/query/DoNotReturnRecords.d.ts
 interface DoNotReturnRecords {
-    returnRecords: false;
+  returnRecords: false;
 }
-
-type OnConflictTargets<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> = K[] | {
-    columns: K[];
-    where: WhereQuery<T>;
+//#endregion
+//#region src/query/OnConflictOptions.d.ts
+type OnConflictTargets<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = K[] | {
+  columns: K[];
+  where: WhereQuery<T>;
 };
-interface OnConflictIgnoreOptions<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> {
-    onConflict: {
-        action: 'ignore';
-        targets: OnConflictTargets<T, K>;
-    };
-}
-interface OnConflictMergeOptions<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> {
-    onConflict: {
-        action: 'merge';
-        targets: OnConflictTargets<T, K>;
-        merge?: K[] | {
-            columns?: K[];
-            where: WhereQuery<T>;
-        };
+interface OnConflictIgnoreOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> {
+  onConflict: {
+    action: "ignore";
+    targets: OnConflictTargets<T, K>;
+  };
+}
+interface OnConflictMergeOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> {
+  onConflict: {
+    action: "merge";
+    targets: OnConflictTargets<T, K>;
+    merge?: K[] | {
+      columns?: K[];
+      where: WhereQuery<T>;
     };
+  };
+}
+type OnConflictOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = OnConflictIgnoreOptions<T, K> | OnConflictMergeOptions<T, K>;
+//#endregion
+//#region src/query/ReturnSelect.d.ts
+interface ReturnSelect<T extends Entity, K extends keyof OmitFunctions<OmitEntityCollections<T>> = keyof OmitFunctions<OmitEntityCollections<T>>> {
+  returnSelect: (K & string)[];
+}
+//#endregion
+//#region src/query/CreateOptions.d.ts
+type CreateOnConflictOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = OnConflictOptions<T, K> & Partial<DoNotReturnRecords | ReturnSelect<T>>;
+type CreateOptionalOnConflictOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = Partial<OnConflictOptions<T, K>> & (DoNotReturnRecords | ReturnSelect<T>);
+type CreateOptions<T extends Entity, K extends string & keyof OmitFunctions<OmitEntityCollections<T>> = string & keyof OmitFunctions<OmitEntityCollections<T>>> = CreateOnConflictOptions<T, K> | CreateOptionalOnConflictOptions<T, K>;
+//#endregion
+//#region src/query/Comparer.d.ts
+type Comparer = "!" | "<" | "<=" | ">" | ">=" | "and" | "contains" | "endsWith" | "like" | "or" | "startsWith";
+//#endregion
+//#region src/query/CountResult.d.ts
+interface CountResult<TEntity extends Entity> extends PromiseLike<number> {
+  where(args: WhereQuery<TEntity>): CountResult<TEntity> | number;
+}
+//#endregion
+//#region src/query/CreateResult.d.ts
+/**
+* Result of a create operation that returns a plain object (after calling toJSON())
+*/
+interface CreateResultJSON<T extends Entity> extends PromiseLike<PlainObject<QueryResult<T>>> {
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): CreateResultJSON<T>;
 }
-type OnConflictOptions<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> = OnConflictIgnoreOptions<T, K> | OnConflictMergeOptions<T, K>;
-
-interface ReturnSelect$1<T extends Record<string, unknown>, K extends keyof OmitFunctions<T> = keyof OmitFunctions<T>> {
-    returnSelect: (K & string)[];
-}
-
-type CreateOnConflictOptions<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> = OnConflictOptions<T, K> & Partial<DoNotReturnRecords | ReturnSelect$1<T>>;
-type CreateOptionalOnConflictOptions<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> = Partial<OnConflictOptions<T, K>> & (DoNotReturnRecords | ReturnSelect$1<T>);
-type CreateOptions<T extends Record<string, unknown>, K extends string & keyof OmitFunctions<T> = string & keyof OmitFunctions<T>> = CreateOnConflictOptions<T, K> | CreateOptionalOnConflictOptions<T, K>;
-
-type Comparer = '!' | '<' | '<=' | '>' | '>=' | 'and' | 'contains' | 'endsWith' | 'like' | 'or' | 'startsWith';
-
-interface CountResult<TEntity extends Record<string, unknown>> extends PromiseLike<number> {
-    where(args: WhereQuery<TEntity>): CountResult<TEntity> | number;
-}
-
 /**
- * Result of a create operation that returns a single record
- */
-interface CreateResult<T extends Record<string, unknown>> extends PromiseLike<QueryResult<T>> {
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
+* Result of a create operation that returns multiple plain objects (after calling toJSON())
+*/
+interface CreateResultArrayJSON<T extends Entity> extends PromiseLike<PlainObject<QueryResult<T>>[]> {
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): CreateResultArrayJSON<T>;
 }
 /**
- * Result of a create operation that returns multiple records
- */
-interface CreateResultArray<T extends Record<string, unknown>> extends PromiseLike<QueryResult<T>[]> {
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
+* Result of a create operation that returns a single record
+*/
+interface CreateResult<T extends Entity> extends PromiseLike<QueryResult<T>> {
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): CreateResultJSON<T>;
 }
-
+/**
+* Result of a create operation that returns multiple records
+*/
+interface CreateResultArray<T extends Entity> extends PromiseLike<QueryResult<T>[]> {
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): CreateResultArrayJSON<T>;
+}
+//#endregion
+//#region src/query/ScalarSubquery.d.ts
 declare class ScalarSubquery<TValue> {
-    private readonly _resultType;
-    readonly _aggregate: 'avg' | 'count' | 'max' | 'min' | 'sum';
-    readonly _aggregateColumn?: string;
-    readonly _subquery: SubqueryBuilder<Record<string, unknown>>;
-    constructor(parentSubquery: SubqueryBuilder<Record<string, unknown>>, aggregate: 'avg' | 'count' | 'max' | 'min' | 'sum', column?: string);
-}
-
+  private readonly _resultType;
+  readonly _aggregate: "avg" | "count" | "max" | "min" | "sum";
+  readonly _aggregateColumn?: string;
+  readonly _subquery: SubqueryBuilder<Entity>;
+  constructor(parentSubquery: SubqueryBuilder<Entity>, aggregate: "avg" | "count" | "max" | "min" | "sum", column?: string);
+}
+//#endregion
+//#region src/query/SelectBuilder.d.ts
 interface SelectAggregateExpression {
-    _type: 'aggregate';
-    fn: 'avg' | 'count' | 'max' | 'min' | 'sum';
-    column?: string;
-    distinct: boolean;
-    alias: string;
+  _type: "aggregate";
+  fn: "avg" | "count" | "max" | "min" | "sum";
+  column?: string;
+  distinct: boolean;
+  alias: string;
 }
 interface AggregateBuilder {
-    distinct(): AggregateBuilder;
-    as<TAlias extends string>(alias: TAlias): SelectAggregateExpression & {
-        readonly alias: TAlias;
-    };
-    readonly _expression: SelectAggregateExpression;
-}
-declare class SelectBuilder<T extends Record<string, unknown>> {
-    count(column?: string & keyof T): AggregateBuilder;
-    sum(column: string & keyof T): AggregateBuilder;
-    avg(column: string & keyof T): AggregateBuilder;
-    max(column: string & keyof T): AggregateBuilder;
-    min(column: string & keyof T): AggregateBuilder;
-    protected _createAggregateBuilder(fn: SelectAggregateExpression['fn'], column?: string): AggregateBuilder;
-}
-
+  distinct(): AggregateBuilder;
+  as<TAlias extends string>(alias: TAlias): SelectAggregateExpression & {
+    readonly alias: TAlias;
+  };
+  readonly _expression: SelectAggregateExpression;
+}
+declare class SelectBuilder<T extends Entity> {
+  count(column?: string & keyof T): AggregateBuilder;
+  sum(column: string & keyof T): AggregateBuilder;
+  avg(column: string & keyof T): AggregateBuilder;
+  max(column: string & keyof T): AggregateBuilder;
+  min(column: string & keyof T): AggregateBuilder;
+  protected _createAggregateBuilder(fn: SelectAggregateExpression["fn"], column?: string): AggregateBuilder;
+}
+//#endregion
+//#region src/query/SubqueryBuilder.d.ts
 /**
- * An aggregate expression with a typed alias from `.as()`.
- */
+* An aggregate expression with a typed alias from `.as()`.
+*/
 type TypedAggregateExpression<TAlias extends string> = SelectAggregateExpression & {
-    readonly alias: TAlias;
+  readonly alias: TAlias;
 };
 /**
- * A callback that creates an aggregate with a typed alias.
- */
-type AggregateCallback<T extends Record<string, unknown>, TAlias extends string> = (builder: SelectBuilder<T>) => TypedAggregateExpression<TAlias>;
+* A callback that creates an aggregate with a typed alias.
+*/
+type AggregateCallback<T extends Entity, TAlias extends string> = (builder: SelectBuilder<T>) => TypedAggregateExpression<TAlias>;
 /**
- * Extracts the alias type from a select item.
- */
-type ExtractItemAlias<T extends Record<string, unknown>, TItem> = TItem extends string & keyof T ? TItem : TItem extends AggregateCallback<T, infer A> ? A : TItem extends TypedAggregateExpression<infer A> ? A : never;
+* Extracts the alias type from a select item.
+*/
+type ExtractItemAlias<T extends Entity, TItem> = TItem extends string & keyof T ? TItem : TItem extends AggregateCallback<T, infer A> ? A : TItem extends TypedAggregateExpression<infer A> ? A : never;
 /**
- * Extracts all alias types from an array of select items using mapped type.
- */
-type ExtractAllAliases<T extends Record<string, unknown>, TItems extends readonly unknown[]> = {
-    [K in keyof TItems]: ExtractItemAlias<T, TItems[K]>;
-}[number];
+* Extracts all alias types from an array of select items using mapped type.
+*/
+type ExtractAllAliases<T extends Entity, TItems extends readonly unknown[]> = { [K in keyof TItems]: ExtractItemAlias<T, TItems[K]> }[number];
 /**
- * Valid select items for type-safe column tracking.
- */
-type TypedSelectItem<T extends Record<string, unknown>> = AggregateCallback<T, string> | TypedAggregateExpression<string> | (string & keyof T);
-type SelectItem<T extends Record<string, unknown>> = ((builder: SelectBuilder<T>) => AggregateBuilder | SelectAggregateExpression) | (string & keyof T);
+* Valid select items for type-safe column tracking.
+*/
+type TypedSelectItem<T extends Entity> = AggregateCallback<T, string> | TypedAggregateExpression<string> | (string & keyof T);
+type SelectItem<T extends Entity> = ((builder: SelectBuilder<T>) => AggregateBuilder | SelectAggregateExpression) | (string & keyof T);
 interface HavingComparer {
-    '<'?: number;
-    '<='?: number;
-    '>'?: number;
-    '>='?: number;
-    '!='?: number;
+  "<"?: number;
+  "<="?: number;
+  ">"?: number;
+  ">="?: number;
+  "!="?: number;
 }
 type HavingCondition = Record<string, HavingComparer | number>;
 /**
- * Structural type that accepts any SubqueryBuilder<T, TColumns> regardless of T or TColumns.
- * Uses `unknown` for generic-dependent properties to allow variance.
- * Only includes data properties, not methods, to avoid method return type variance issues.
- */
+* Structural type that accepts any SubqueryBuilder<T, TColumns> regardless of T or TColumns.
+* Uses `unknown` for generic-dependent properties to allow variance.
+* Only includes data properties, not methods, to avoid method return type variance issues.
+*/
 interface SubqueryBuilderLike {
-    _repository: unknown;
-    _select?: string[];
-    _selectExpressions?: SelectAggregateExpression[];
-    _where?: unknown;
-    _sort?: unknown;
-    _limit?: number;
-    _groupBy?: string[];
-    _having?: HavingCondition;
-    _distinctOn?: string[];
+  _repository: unknown;
+  _select?: string[];
+  _selectExpressions?: SelectAggregateExpression[];
+  _where?: unknown;
+  _sort?: unknown;
+  _limit?: number;
+  _groupBy?: string[];
+  _having?: HavingCondition;
+  _distinctOn?: string[];
 }
 /**
- * Structural type for typed subquery builders that tracks selected columns.
- * Used by join operations to enable type-safe sorting on subquery columns.
- */
+* Structural type for typed subquery builders that tracks selected columns.
+* Used by join operations to enable type-safe sorting on subquery columns.
+*/
 interface TypedSubqueryBuilder<TColumns extends string = never> extends SubqueryBuilderLike {
-    readonly _columns?: TColumns;
-}
-declare class SubqueryBuilder<T extends Record<string, unknown>, TColumns extends string = never> implements TypedSubqueryBuilder<TColumns> {
-    readonly _repository: IReadonlyRepository<T> | IRepository<T>;
-    _select?: string[];
-    _selectExpressions?: SelectAggregateExpression[];
-    _where?: WhereQuery<T>;
-    _sort?: SortObject<T> | string;
-    _limit?: number;
-    _groupBy?: (string & keyof T)[];
-    _having?: HavingCondition;
-    _distinctOn?: (string & keyof T)[];
-    readonly _columns?: TColumns;
-    constructor(repository: IReadonlyRepository<T> | IRepository<T>);
-    /**
-     * Select columns and/or aggregate expressions for the subquery with type-safe column tracking.
-     * @returns New SubqueryBuilder with the select applied and column types tracked
-     * @example
-     * // Type-safe select with callback aggregates
-     * subquery(ProductRepository)
-     *   .select(['store', (sb) => sb.count().as('productCount')])
-     *   .groupBy(['store']);
-     *
-     * // Can then sort type-safely after joining:
-     * StoreRepository.find()
-     *   .join(productCounts, 'stats', { on: { id: 'store' } })
-     *   .sort('stats.productCount desc')  // No type cast needed!
-     */
-    select<const TItems extends readonly TypedSelectItem<T>[]>(columns: TItems): SubqueryBuilder<T, ExtractAllAliases<T, TItems>>;
-    /**
-     * Select columns and/or aggregate expressions for the subquery (untyped signature).
-     * Note: Using aggregate callbacks that return `AggregateBuilder` instead of calling `.as()`
-     * does not enable type-safe sorting.
-     * @returns New SubqueryBuilder with the select applied
-     */
-    select(columns: SelectItem<T>[]): SubqueryBuilder<T>;
-    /**
-     * Group the subquery results by one or more columns.
-     * @param {(string & keyof T)[]} columns - Columns to group by
-     * @returns New SubqueryBuilder with the groupBy applied
-     * @example
-     * subquery(ProductRepository)
-     *   .select(['storeId', (sb) => sb.count().as('productCount')])
-     *   .groupBy(['storeId'])
-     */
-    groupBy(columns: (string & keyof T)[]): SubqueryBuilder<T, TColumns>;
-    /**
-     * Filter groups based on aggregate values (used with groupBy).
-     * @param {HavingCondition} condition - Having condition to apply
-     * @returns New SubqueryBuilder with the having condition applied
-     * @example
-     * subquery(ProductRepository)
-     *   .select(['storeId', (sb) => sb.count().as('productCount')])
-     *   .groupBy(['storeId'])
-     *   .having({ productCount: { '>': 5 } })
-     */
-    having(condition: HavingCondition): SubqueryBuilder<T, TColumns>;
-    where(query: WhereQuery<T>): SubqueryBuilder<T, TColumns>;
-    sort(value: Sort<T>): SubqueryBuilder<T, TColumns>;
-    limit(maxRows: number): SubqueryBuilder<T, TColumns>;
-    /**
-     * Selects distinct rows based on the specified columns (PostgreSQL DISTINCT ON).
-     * The sort() clause must start with the same columns in the same order.
-     * @param {string[]} columns - Column names for DISTINCT ON clause
-     * @returns New SubqueryBuilder with the distinctOn applied
-     * @example
-     * subquery(ProductRepository)
-     *   .distinctOn(['store'])
-     *   .select(['store', 'name', 'createdAt'])
-     *   .sort('store')
-     *   .sort('createdAt desc');
-     */
-    distinctOn(columns: (string & keyof T)[]): SubqueryBuilder<T, TColumns>;
-    count(): ScalarSubquery<number>;
-    sum(column: string & keyof T): ScalarSubquery<number>;
-    avg(column: string & keyof T): ScalarSubquery<number>;
-    max<K extends string & keyof T>(column: K): ScalarSubquery<T[K]>;
-    min<K extends string & keyof T>(column: K): ScalarSubquery<T[K]>;
-    private cloneBuilder;
-}
-
-type JoinType = 'inner' | 'left';
-interface ModelJoinDefinition<T extends Record<string, unknown> = Record<string, unknown>> {
-    propertyName: string;
-    alias: string;
-    type: JoinType;
-    on?: WhereQuery<T>;
-    relatedModel?: ModelMetadata<T>;
-    foreignKeyColumn?: string;
-    relatedPrimaryKey?: string;
+  readonly _columns?: TColumns;
+}
+declare class SubqueryBuilder<T extends Entity, TColumns extends string = never> implements TypedSubqueryBuilder<TColumns> {
+  readonly _repository: IReadonlyRepository<T> | IRepository<T>;
+  _select?: string[];
+  _selectExpressions?: SelectAggregateExpression[];
+  _where?: WhereQuery<T>;
+  _sort?: SortObject<T> | string;
+  _limit?: number;
+  _groupBy?: (string & keyof T)[];
+  _having?: HavingCondition;
+  _distinctOn?: (string & keyof T)[];
+  readonly _columns?: TColumns;
+  constructor(repository: IReadonlyRepository<T> | IRepository<T>);
+  /**
+  * Select columns and/or aggregate expressions for the subquery with type-safe column tracking.
+  * @returns New SubqueryBuilder with the select applied and column types tracked
+  * @example
+  * // Type-safe select with callback aggregates
+  * subquery(ProductRepository)
+  *   .select(['store', (sb) => sb.count().as('productCount')])
+  *   .groupBy(['store']);
+  *
+  * // Can then sort type-safely after joining:
+  * StoreRepository.find()
+  *   .join(productCounts, 'stats', { on: { id: 'store' } })
+  *   .sort('stats.productCount desc')  // No type cast needed!
+  */
+  select<const TItems extends readonly TypedSelectItem<T>[]>(columns: TItems): SubqueryBuilder<T, ExtractAllAliases<T, TItems>>;
+  /**
+  * Select columns and/or aggregate expressions for the subquery (untyped signature).
+  * Note: Using aggregate callbacks that return `AggregateBuilder` instead of calling `.as()`
+  * does not enable type-safe sorting.
+  * @returns New SubqueryBuilder with the select applied
+  */
+  select(columns: SelectItem<T>[]): SubqueryBuilder<T>;
+  /**
+  * Group the subquery results by one or more columns.
+  * @param {(string & keyof T)[]} columns - Columns to group by
+  * @returns New SubqueryBuilder with the groupBy applied
+  * @example
+  * subquery(ProductRepository)
+  *   .select(['storeId', (sb) => sb.count().as('productCount')])
+  *   .groupBy(['storeId'])
+  */
+  groupBy(columns: (string & keyof T)[]): SubqueryBuilder<T, TColumns>;
+  /**
+  * Filter groups based on aggregate values (used with groupBy).
+  * @param {HavingCondition} condition - Having condition to apply
+  * @returns New SubqueryBuilder with the having condition applied
+  * @example
+  * subquery(ProductRepository)
+  *   .select(['storeId', (sb) => sb.count().as('productCount')])
+  *   .groupBy(['storeId'])
+  *   .having({ productCount: { '>': 5 } })
+  */
+  having(condition: HavingCondition): SubqueryBuilder<T, TColumns>;
+  where(query: WhereQuery<T>): SubqueryBuilder<T, TColumns>;
+  sort(value: Sort<T>): SubqueryBuilder<T, TColumns>;
+  limit(maxRows: number): SubqueryBuilder<T, TColumns>;
+  /**
+  * Selects distinct rows based on the specified columns (PostgreSQL DISTINCT ON).
+  * The sort() clause must start with the same columns in the same order.
+  * @param {string[]} columns - Column names for DISTINCT ON clause
+  * @returns New SubqueryBuilder with the distinctOn applied
+  * @example
+  * subquery(ProductRepository)
+  *   .distinctOn(['store'])
+  *   .select(['store', 'name', 'createdAt'])
+  *   .sort('store')
+  *   .sort('createdAt desc');
+  */
+  distinctOn(columns: (string & keyof T)[]): SubqueryBuilder<T, TColumns>;
+  count(): ScalarSubquery<number>;
+  sum(column: string & keyof T): ScalarSubquery<number>;
+  avg(column: string & keyof T): ScalarSubquery<number>;
+  max<K extends string & keyof T>(column: K): ScalarSubquery<T[K]>;
+  min<K extends string & keyof T>(column: K): ScalarSubquery<T[K]>;
+  private cloneBuilder;
+}
+//#endregion
+//#region src/query/JoinDefinition.d.ts
+type JoinType = "inner" | "left";
+interface ModelJoinDefinition<T extends Entity = Entity> {
+  propertyName: string;
+  alias: string;
+  type: JoinType;
+  on?: WhereQuery<T>;
+  relatedModel?: ModelMetadata<T>;
+  foreignKeyColumn?: string;
+  relatedPrimaryKey?: string;
 }
 /**
- * ON condition for subquery joins - maps main table column to subquery column
- * @example { id: 'storeId' } means main.id = subquery.storeId
- */
+* ON condition for subquery joins - maps main table column to subquery column
+* @example { id: 'storeId' } means main.id = subquery.storeId
+*/
 type SubqueryJoinOnCondition = Record<string, string>;
 interface SubqueryJoinDefinition {
-    subquery: SubqueryBuilderLike;
-    alias: string;
-    type: JoinType;
-    on: SubqueryJoinOnCondition;
+  subquery: SubqueryBuilderLike;
+  alias: string;
+  type: JoinType;
+  on: SubqueryJoinOnCondition;
 }
-type JoinDefinition<T extends Record<string, unknown> = Record<string, unknown>> = ModelJoinDefinition<T> | SubqueryJoinDefinition;
+type JoinDefinition<T extends Entity = Entity> = ModelJoinDefinition<T> | SubqueryJoinDefinition;
 declare function isSubqueryJoin(join: JoinDefinition): join is SubqueryJoinDefinition;
-
+//#endregion
+//#region src/query/JoinedWhereQuery.d.ts
 type ExcludeUndefined$1<T> = Exclude<T, undefined>;
-interface JoinInfo<TProperty extends string = string, TAlias extends string = string, TEntity extends Record<string, unknown> = Record<string, unknown>> {
-    property: TProperty;
-    alias: TAlias;
-    entity: TEntity;
+interface JoinInfo<TProperty extends string = string, TAlias extends string = string, TEntity extends Entity = Entity> {
+  property: TProperty;
+  alias: TAlias;
+  entity: TEntity;
 }
 /**
- * Join info for subquery joins - tracks alias and available column names.
- * Distinguished from JoinInfo by the _brand discriminator.
- */
+* Join info for subquery joins - tracks alias and available column names.
+* Distinguished from JoinInfo by the _brand discriminator.
+*/
 interface SubqueryJoinInfo<TAlias extends string = string, TColumns extends string = string> {
-    alias: TAlias;
-    columns: TColumns;
-    _brand: 'subquery';
+  alias: TAlias;
+  columns: TColumns;
+  _brand: "subquery";
 }
 /**
- * Union type for any join info (model or subquery).
- */
+* Union type for any join info (model or subquery).
+*/
 type AnyJoinInfo = JoinInfo | SubqueryJoinInfo;
 /**
- * Extracts aliases from model JoinInfo only.
- */
-type ModelJoinAliases<TJoins extends AnyJoinInfo> = Extract<TJoins, JoinInfo>['alias'];
+* Extracts aliases from model JoinInfo only.
+*/
+type ModelJoinAliases<TJoins extends AnyJoinInfo> = Extract<TJoins, JoinInfo>["alias"];
 type GetJoinedEntity<TJoins extends JoinInfo, TAlias extends string> = Extract<TJoins, {
-    alias: TAlias;
-}>['entity'];
-type JoinedPropertyConstraint<TJoinedEntity extends Record<string, unknown>, TPropertyValue> = WhereQuery<TJoinedEntity> | WhereQueryStatement<ExcludeUndefined$1<TPropertyValue>>;
+  alias: TAlias;
+}>["entity"];
+type JoinedPropertyConstraint<TJoinedEntity extends Entity, TPropertyValue> = WhereQuery<TJoinedEntity> | WhereQueryStatement<ExcludeUndefined$1<TPropertyValue>>;
 /**
- * WhereQuery that supports nested where clauses for joined relationships.
- * Note: Subquery joins do not support where clause filtering by alias.
- * @example
- * .join('store', 'primaryStore')
- * .where({ primaryStore: { name: 'Acme' } })
- *
- * .join('store')
- * .where({ store: { name: 'Acme' } })
- */
-type JoinedWhereQuery<T extends Record<string, unknown>, TJoins extends AnyJoinInfo = never> = WhereQuery<T> & ([TJoins] extends [never] ? {} : [Extract<TJoins, JoinInfo>] extends [never] ? {} : {
-    [K in ModelJoinAliases<TJoins>]?: JoinedPropertyConstraint<GetJoinedEntity<Extract<TJoins, JoinInfo>, K>, GetJoinedEntity<Extract<TJoins, JoinInfo>, K>>;
-}) & {
-    and?: JoinedWhereQuery<T, TJoins>[];
-    or?: JoinedWhereQuery<T, TJoins>[];
+* WhereQuery that supports nested where clauses for joined relationships.
+* Note: Subquery joins do not support where clause filtering by alias.
+* @example
+* .join('store', 'primaryStore')
+* .where({ primaryStore: { name: 'Acme' } })
+*
+* .join('store')
+* .where({ store: { name: 'Acme' } })
+*/
+type JoinedWhereQuery<T extends Entity, TJoins extends AnyJoinInfo = never> = WhereQuery<T> & ([TJoins] extends [never] ? {} : [Extract<TJoins, JoinInfo>] extends [never] ? {} : { [K in ModelJoinAliases<TJoins>]?: JoinedPropertyConstraint<GetJoinedEntity<Extract<TJoins, JoinInfo>, K>, GetJoinedEntity<Extract<TJoins, JoinInfo>, K>> }) & {
+  and?: JoinedWhereQuery<T, TJoins>[];
+  or?: JoinedWhereQuery<T, TJoins>[];
 };
-
-type SortString<T extends Record<string, unknown>> = `${string & keyof OmitFunctions<T>} ASC` | `${string & keyof OmitFunctions<T>} asc` | `${string & keyof OmitFunctions<T>} DESC` | `${string & keyof OmitFunctions<T>} desc` | (string & keyof OmitFunctions<T>);
-type ValidateMultipleSorts<T extends Record<string, unknown>, TNextSortPart extends string, TPreviouslyValidatedSortString extends string, TSortString extends string> = TNextSortPart extends `, ${SortString<T>}${infer TRestSortPart}` ? TRestSortPart extends '' ? TSortString : ValidateMultipleSorts<T, TRestSortPart, TNextSortPart extends `${infer TValidatedSortPart}${TRestSortPart}` ? `${TPreviouslyValidatedSortString}${TValidatedSortPart}` : never, TSortString> : `${TPreviouslyValidatedSortString}, ${SortString<T>}`;
-type MultipleSortString<T extends Record<string, unknown>, TSortString extends string = string> = TSortString extends `${SortString<T>}${infer TRestSortPart}` ? TRestSortPart extends '' ? TSortString : ValidateMultipleSorts<T, TRestSortPart, TSortString extends `${infer TPreviouslyValidatedSortString}${TRestSortPart}` ? TPreviouslyValidatedSortString : never, TSortString> : SortString<T>;
-type SortObjectValue = -1 | 'asc' | 'desc' | 1;
-interface VectorDistanceSort {
-    nearestTo: number[];
-    metric?: VectorDistanceMetric;
-}
-type SortObject<T extends Record<string, unknown>> = {
-    [K in keyof T as ExcludeFunctions<T[K], K>]?: SortObjectValue | VectorDistanceSort;
-};
-type Sort<T extends Record<string, unknown>> = MultipleSortString<T> | SortObject<T>;
-type VectorDistanceMetric = 'cosine' | 'innerProduct' | 'l1' | 'l2';
-interface OrderBy<T extends Record<string, unknown>> {
-    propertyName: string & keyof OmitFunctions<T>;
-    descending?: boolean;
-    vectorDistance?: {
-        vector: number[];
-        metric: VectorDistanceMetric;
-    };
-}
-
+//#endregion
+//#region src/query/JoinedSort.d.ts
 /**
- * Extracts all aliases from a union of join info types.
- */
-type AnyJoinAliases<TJoins extends AnyJoinInfo> = TJoins['alias'];
+* Extracts all aliases from a union of join info types.
+*/
+type AnyJoinAliases<TJoins extends AnyJoinInfo> = TJoins["alias"];
 /**
- * Gets available columns for any join type (model or subquery).
- */
+* Gets available columns for any join type (model or subquery).
+*/
 type GetJoinColumns<TJoins extends AnyJoinInfo, TAlias extends string> = Extract<TJoins, {
-    alias: TAlias;
+  alias: TAlias;
 }> extends SubqueryJoinInfo<TAlias, infer TColumns> ? TColumns : Extract<TJoins, {
-    alias: TAlias;
-}> extends JoinInfo<string, TAlias, infer TEntity> ? string & keyof OmitFunctions<TEntity> : never;
+  alias: TAlias;
+}> extends JoinInfo<string, TAlias, infer TEntity> ? string & keyof OmitFunctions<OmitEntityCollections<TEntity>> : never;
 /**
- * Creates column path strings for any join type.
- * For model joins: uses entity property names
- * For subquery joins: uses tracked column names
- */
+* Creates column path strings for any join type.
+* For model joins: uses entity property names
+* For subquery joins: uses tracked column names
+*/
 type AnyJoinedColumnPath<TJoins extends AnyJoinInfo, TAlias extends AnyJoinAliases<TJoins> = AnyJoinAliases<TJoins>> = TAlias extends string ? `${TAlias}.${GetJoinColumns<TJoins, TAlias>}` : never;
 /**
- * Sort strings for joined columns (model or subquery joins).
- */
+* Sort strings for joined columns (model or subquery joins).
+*/
 type JoinedSortString<TJoins extends AnyJoinInfo> = AnyJoinedColumnPath<TJoins> | `${AnyJoinedColumnPath<TJoins>} ASC` | `${AnyJoinedColumnPath<TJoins>} asc` | `${AnyJoinedColumnPath<TJoins>} DESC` | `${AnyJoinedColumnPath<TJoins>} desc`;
 /**
- * Sort type that supports both base entity columns and joined columns (from model or subquery joins).
- */
-type JoinedSort<T extends Record<string, unknown>, TJoins extends AnyJoinInfo = never> = [TJoins] extends [never] ? Sort<T> : JoinedSortString<TJoins> | Sort<T>;
-
-type CreateUpdateOptions<T extends Record<string, unknown>> = DoNotReturnRecords | ReturnSelect$1<T>;
-
-interface ReturnSelect<T extends Record<string, unknown>, K extends keyof T> {
-    returnSelect: (K & string & keyof OmitFunctions<T>)[];
-    returnRecords?: true;
-}
-interface ReturnRecords<T extends Record<string, unknown>, K extends keyof T> {
-    returnRecords: true;
-    returnSelect?: (K & string & keyof OmitFunctions<T>)[];
-}
-type DeleteOptions<T extends Record<string, unknown>, K extends keyof T = keyof T> = ReturnRecords<T, K> | ReturnSelect<T, K>;
-
+* Sort type that supports both base entity columns and joined columns (from model or subquery joins).
+*/
+type JoinedSort<T extends Entity, TJoins extends AnyJoinInfo = never> = [TJoins] extends [never] ? Sort<T> : JoinedSortString<TJoins> | Sort<T>;
+//#endregion
+//#region src/query/CreateUpdateOptions.d.ts
+type CreateUpdateOptions<T extends Entity> = DoNotReturnRecords | ReturnSelect<T>;
+//#endregion
+//#region src/query/DeleteOptions.d.ts
+interface ReturnSelect$1<T extends Entity, K extends keyof T> {
+  returnSelect: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+  returnRecords?: true;
+}
+interface ReturnRecords<T extends Entity, K extends keyof T> {
+  returnRecords: true;
+  returnSelect?: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+}
+type DeleteOptions<T extends Entity, K extends keyof T = keyof T> = ReturnRecords<T, K> | ReturnSelect$1<T, K>;
+//#endregion
+//#region src/query/DestroyResult.d.ts
 /**
- * Result of a destroy operation that does not return records
- */
-interface DestroyResult<TEntity extends Record<string, unknown>, TReturn> extends PromiseLike<TReturn> {
-    where(args: WhereQuery<TEntity>): DestroyResult<TEntity, TReturn>;
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
+* Result of a destroy operation that returns plain objects (after calling toJSON())
+*/
+interface DestroyResultJSON<TEntity extends Entity, TReturn> extends PromiseLike<PlainObject<TReturn>[]> {
+  where(args: WhereQuery<TEntity>): DestroyResultJSON<TEntity, TReturn>;
 }
 /**
- * Result of a destroy operation that returns records
- */
-interface DestroyResultWithRecords<TEntity extends Record<string, unknown>> extends PromiseLike<QueryResult<TEntity>[]> {
-    where(args: WhereQuery<TEntity>): DestroyResultWithRecords<TEntity>;
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
+* Result of a destroy operation that does not return records
+*/
+interface DestroyResult<TEntity extends Entity, TReturn> extends PromiseLike<TReturn> {
+  where(args: WhereQuery<TEntity>): DestroyResult<TEntity, TReturn>;
 }
-
 /**
- * Result of an update operation that returns records
- */
-interface UpdateResult<T extends Record<string, unknown>> extends PromiseLike<QueryResult<T>[]> {
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
+* Result of a destroy operation that returns records (includes toJSON method)
+*/
+interface DestroyResultWithRecords<TEntity extends Entity, TReturn> extends PromiseLike<TReturn[]> {
+  where(args: WhereQuery<TEntity>): DestroyResultWithRecords<TEntity, TReturn>;
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): DestroyResultJSON<TEntity, TReturn>;
+}
+//#endregion
+//#region src/query/UpdateResult.d.ts
+/**
+* Result of an update operation that returns plain objects (after calling toJSON())
+*/
+interface UpdateResultJSON<T extends Entity> extends PromiseLike<PlainObject<QueryResult<T>>[]> {
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): UpdateResultJSON<T>;
 }
-
-interface FindOneArgs<T extends Record<string, unknown>, K extends keyof T = string & keyof OmitFunctions<T> & keyof T> {
-    select?: (K & string & keyof OmitFunctions<T>)[];
-    where?: WhereQuery<T>;
-    sort?: Sort<T>;
-    pool?: PoolLike;
-    /** Control global filters. false = disable all, { filterName: false } = disable specific filter */
-    filters?: Record<string, false> | false;
-}
-
-interface FindArgs<T extends Record<string, unknown>, K extends keyof T = keyof T> extends FindOneArgs<T, K> {
-    skip?: number;
-    limit?: number;
-}
-
 /**
- * Options for filtering and sorting by junction table columns in through relationships.
- * Uses looser typing since the junction table entity type is determined at runtime.
- */
+* Result of an update operation that returns records
+*/
+interface UpdateResult<T extends Entity> extends PromiseLike<QueryResult<T>[]> {
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): UpdateResultJSON<T>;
+}
+//#endregion
+//#region src/query/FindOneArgs.d.ts
+interface FindOneArgs<T extends Entity, K extends keyof T = string & keyof OmitFunctions<OmitEntityCollections<T>> & keyof T> {
+  select?: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+  where?: WhereQuery<T>;
+  sort?: Sort<T>;
+  pool?: PoolLike;
+}
+//#endregion
+//#region src/query/FindArgs.d.ts
+interface FindArgs<T extends Entity, K extends keyof T = keyof T> extends FindOneArgs<T, K> {
+  skip?: number;
+  limit?: number;
+}
+//#endregion
+//#region src/query/PopulateArgs.d.ts
+/**
+* Options for filtering and sorting by junction table columns in through relationships.
+* Uses looser typing since the junction table entity type is determined at runtime.
+*/
 interface ThroughArgs {
-    /** Filter applied to the junction table query */
-    where?: Record<string, unknown>;
-    /** Sort applied to the junction table query - determines final ordering of populated items */
-    sort?: SortObject<Record<string, unknown>> | string;
-}
-interface PopulateArgs<T extends Record<string, unknown>, K extends keyof T> {
-    where?: WhereQuery<T>;
-    select?: (K & string & keyof OmitFunctions<T>)[];
-    sort?: Sort<T>;
-    skip?: number;
-    limit?: number;
-    pool?: PoolLike;
-    /**
-     * Options for filtering/sorting by junction table columns.
-     * Only applicable to many-to-many relationships that use `through`.
-     */
-    through?: ThroughArgs;
-}
-
-type AnyModel$4 = TableDefinition<string, any>;
-interface FindOneResult<T extends Record<string, unknown>, TReturn, TJoins extends JoinInfo = never, TSchema extends SchemaDefinition = SchemaDefinition, TModels extends Record<string, AnyModel$4> = DefaultModelsMap> extends PromiseLike<TReturn | null> {
-    select<TKeys extends string & keyof T>(keys: TKeys[]): FindOneResult<T, Pick<T, TKeys>, TJoins, TSchema, TModels>;
-    where(args: JoinedWhereQuery<T, TJoins>): FindOneResult<T, TReturn, TJoins, TSchema, TModels>;
-    populate<TProperty extends string & PopulatableKeys<TSchema> & keyof T, TPopulateType extends ResolveModel<TModels, ModelNameOf<TSchema[TProperty & keyof TSchema] extends SchemaEntry ? TSchema[TProperty & keyof TSchema] : never>>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindOneResult<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins, TSchema, TModels>;
-    join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindOneResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Record<string, unknown>>> | TJoins, TSchema, TModels>;
-    leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Record<string, unknown>>>): FindOneResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Record<string, unknown>>> | TJoins, TSchema, TModels>;
-    sort(value?: JoinedSort<T, TJoins>): FindOneResult<T, TReturn, TJoins, TSchema, TModels>;
-    UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Record<string, unknown>> & keyof T>(propertyName: TProperty): FindOneResult<T, Omit<TReturn, TProperty> & Pick<T, TProperty>, TJoins, TSchema, TModels>;
-    UNSAFE_withFieldValue<TProperty extends string & keyof T, TValue extends T[TProperty]>(propertyName: TProperty, value: TValue): FindOneResult<T, Omit<TReturn, TProperty> & PickAsType<T, TProperty, TValue>, TJoins, TSchema, TModels>;
-    /** Control global filters. false = disable all, { filterName: false } = disable specific */
-    filters(value: Record<string, false> | false): FindOneResult<T, TReturn, TJoins, TSchema, TModels>;
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
-}
-
+  /** Filter applied to the junction table query */
+  where?: Record<string, unknown>;
+  /** Sort applied to the junction table query - determines final ordering of populated items */
+  sort?: SortObject<Entity> | string;
+}
+interface PopulateArgs<T extends Entity, K extends keyof T> {
+  where?: WhereQuery<T>;
+  select?: (K & string & keyof OmitFunctions<OmitEntityCollections<T>>)[];
+  sort?: Sort<T>;
+  skip?: number;
+  limit?: number;
+  pool?: PoolLike;
+  /**
+  * Options for filtering/sorting by junction table columns.
+  * Only applicable to many-to-many relationships that use `through`.
+  */
+  through?: ThroughArgs;
+}
+//#endregion
+//#region src/query/FindOneResult.d.ts
+interface FindOneResultJSON<T extends Entity, TReturn, TJoins extends JoinInfo = never> extends PromiseLike<PlainObject<TReturn> | null> {
+  select<TKeys extends string & keyof OmitFunctions<QueryResult<T>>>(keys: TKeys[]): FindOneResultJSON<T, Pick<QueryResult<T>, TKeys>, TJoins>;
+  where(args: JoinedWhereQuery<T, TJoins>): FindOneResultJSON<T, TReturn, TJoins>;
+  populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindOneResultJSON<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
+  join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindOneResultJSON<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Entity>>): FindOneResultJSON<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  sort(value?: JoinedSort<T, TJoins>): FindOneResultJSON<T, TReturn, TJoins>;
+  UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T>(propertyName: TProperty): FindOneResultJSON<T, Omit<TReturn, TProperty> & Pick<T, TProperty>, TJoins>;
+  UNSAFE_withFieldValue<TProperty extends string & keyof T, TValue extends T[TProperty]>(propertyName: TProperty, value: TValue): FindOneResultJSON<T, Omit<TReturn, TProperty> & PickAsType<T, TProperty, TValue>, TJoins>;
+}
+interface FindOneResult<T extends Entity, TReturn, TJoins extends JoinInfo = never> extends PromiseLike<TReturn | null> {
+  select<TKeys extends string & keyof OmitFunctions<QueryResult<T>>>(keys: TKeys[]): FindOneResult<T, Pick<QueryResult<T>, TKeys>, TJoins>;
+  where(args: JoinedWhereQuery<T, TJoins>): FindOneResult<T, TReturn, TJoins>;
+  populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindOneResult<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
+  join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindOneResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Entity>>): FindOneResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  sort(value?: JoinedSort<T, TJoins>): FindOneResult<T, TReturn, TJoins>;
+  UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T>(propertyName: TProperty): FindOneResult<T, Omit<TReturn, TProperty> & Pick<T, TProperty>, TJoins>;
+  UNSAFE_withFieldValue<TProperty extends string & keyof T, TValue extends T[TProperty]>(propertyName: TProperty, value: TValue): FindOneResult<T, Omit<TReturn, TProperty> & PickAsType<T, TProperty, TValue>, TJoins>;
+  /**
+  * Returns result as a plain object instead of an entity class instance.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): FindOneResultJSON<T, TReturn, TJoins>;
+}
+//#endregion
+//#region src/query/PaginateOptions.d.ts
 interface PaginateOptions {
-    limit: number;
-    page: number;
+  limit: number;
+  page: number;
 }
-
+//#endregion
+//#region src/query/FindWithCountResult.d.ts
 interface FindWithCountResult<TReturn> {
-    results: TReturn[];
-    totalCount: number;
-}
-interface FindQueryWithCount<T extends Record<string, unknown>, TReturn, TJoins extends AnyJoinInfo = never> extends PromiseLike<FindWithCountResult<TReturn>> {
-    select<TKeys extends string & keyof T>(keys: TKeys[]): FindQueryWithCount<T, Pick<T, TKeys>, TJoins>;
-    where(args: JoinedWhereQuery<T, TJoins>): FindQueryWithCount<T, TReturn, TJoins>;
-    populate<TProperty extends string & keyof PickByValueType<T, Record<string, unknown>> & keyof T, TPopulateType extends GetValueType<T[TProperty], Record<string, unknown>>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindQueryWithCount<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
-    join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindQueryWithCount<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Record<string, unknown>>> | TJoins>;
-    join<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindQueryWithCount<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
-    join(subquery: SubqueryBuilderLike, alias: string, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindQueryWithCount<T, TReturn, TJoins>;
-    leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Record<string, unknown>>>): FindQueryWithCount<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Record<string, unknown>>> | TJoins>;
-    leftJoin<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindQueryWithCount<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
-    leftJoin(subquery: SubqueryBuilderLike, alias: string, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindQueryWithCount<T, TReturn, TJoins>;
-    sort(value?: JoinedSort<T, TJoins>): FindQueryWithCount<T, TReturn, TJoins>;
-    limit(value: number): FindQueryWithCount<T, TReturn, TJoins>;
-    skip(value: number): FindQueryWithCount<T, TReturn, TJoins>;
-    paginate(options: PaginateOptions): FindQueryWithCount<T, TReturn, TJoins>;
-}
-
-type AnyModel$3 = TableDefinition<string, any>;
-interface FindResult<T extends Record<string, unknown>, TReturn, TJoins extends AnyJoinInfo = never, TSchema extends SchemaDefinition = SchemaDefinition, TModels extends Record<string, AnyModel$3> = DefaultModelsMap> extends PromiseLike<TReturn[]> {
-    select<TKeys extends string & keyof T>(keys: TKeys[]): FindResult<T, Pick<T, TKeys>, TJoins, TSchema, TModels>;
-    where(args: JoinedWhereQuery<T, TJoins>): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    populate<TProperty extends string & PopulatableKeys<TSchema> & keyof T, TPopulateType extends ResolveModel<TModels, ModelNameOf<TSchema[TProperty & keyof TSchema] extends SchemaEntry ? TSchema[TProperty & keyof TSchema] : never>>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindResult<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins, TSchema, TModels>;
-    join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Record<string, unknown>>> | TJoins, TSchema, TModels>;
-    /**
-     * Join a subquery with type-safe column tracking.
-     * Use `agg()` helper when building the subquery to enable type-safe sorting.
-     * @example
-     * const counts = subquery(ProductRepository)
-     *   .select(['store', agg(s => s.count(), 'productCount')])
-     *   .groupBy(['store']);
-     * StoreRepository.find()
-     *   .join(counts, 'stats', { on: { id: 'store' } })
-     *   .sort('stats.productCount desc')  // Type-safe!
-     */
-    join<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindResult<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins, TSchema, TModels>;
-    /** @deprecated Use `agg()` helper for type-safe subquery column sorting */
-    join(subquery: SubqueryBuilderLike, alias: string, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Record<string, unknown>>>): FindResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Record<string, unknown>>> | TJoins, TSchema, TModels>;
-    /**
-     * Left join a subquery with type-safe column tracking.
-     * Use `agg()` helper when building the subquery to enable type-safe sorting.
-     */
-    leftJoin<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindResult<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins, TSchema, TModels>;
-    /** @deprecated Use `agg()` helper for type-safe subquery column sorting */
-    leftJoin(subquery: SubqueryBuilderLike, alias: string, options: {
-        on: SubqueryJoinOnCondition;
-    }): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    /**
-     * Selects distinct rows based on the specified columns (PostgreSQL DISTINCT ON).
-     * The ORDER BY clause must start with the same columns in the same order.
-     * Cannot be combined with withCount().
-     * @param columns - Column names for DISTINCT ON clause
-     */
-    distinctOn(columns: (string & keyof OmitFunctions<T>)[]): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    sort(value?: JoinedSort<T, TJoins>): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    limit(value: number): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    skip(value: number): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    paginate(options: PaginateOptions): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    withCount(): FindQueryWithCount<T, TReturn, TJoins>;
-    UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Record<string, unknown>> & keyof T>(propertyName: TProperty): FindResult<T, Omit<TReturn, TProperty> & Pick<T, TProperty>, TJoins, TSchema, TModels>;
-    /** Control global filters. false = disable all, { filterName: false } = disable specific */
-    filters(value: Record<string, false> | false): FindResult<T, TReturn, TJoins, TSchema, TModels>;
-    /** Returns the generated SQL and parameters without executing the query. */
-    toSQL(): {
-        params: readonly unknown[];
-        sql: string;
-    };
-}
-
-type AnyModel$2 = TableDefinition<string, any>;
-interface IRepository<T extends Record<string, unknown>, TSchema extends SchemaDefinition = SchemaDefinition, TModels extends Record<string, AnyModel$2> = DefaultModelsMap> extends IReadonlyRepository<T, TSchema, TModels> {
-    /**
-     * Creates an object using the specified values
-     * @param {object} values - Values to insert as multiple new objects.
-     * @param {object} [options]
-     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
-     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
-     * @returns {object}
-     */
-    create(values: CreateUpdateParams<T>, options?: OnConflictOptions<T> | (Partial<OnConflictOptions<T>> & ReturnSelect$1<T>)): CreateResult<T>;
-    /**
-     * Creates an object or objects using the specified values
-     * @param {object|object[]} values - Values to insert as multiple new objects.
-     * @param {object} options
-     * @param {boolean} options.returnRecords - Determines if inserted records should be returned
-     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
-     * @returns {void}
-     */
-    create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options: DoNotReturnRecords & Partial<OnConflictOptions<T>>): Promise<void>;
-    /**
-     * Creates objects using the specified values
-     * @param {object[]} values - Values to insert as multiple new objects.
-     * @param {object} [options]
-     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
-     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
-     * @returns {object[]}
-     */
-    create(values: CreateUpdateParams<T>[], options?: (OnConflictOptions<T> & Partial<ReturnSelect$1<T>>) | (Partial<OnConflictOptions<T>> & ReturnSelect$1<T>)): CreateResultArray<T>;
-    /**
-     * Creates an object using the specified values
-     * @param {object|object[]} values - Values to insert as a new object. If an array is specified, multiple rows will be inserted
-     * @param {object} [options]
-     * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
-     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
-     * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
-     * @returns {object|object[]|void} Return value from the db
-     */
-    create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options?: CreateOptions<T>): CreateResult<T> | CreateResultArray<T> | Promise<void>;
-    /**
-     * Updates object(s) matching the where query, with the specified values
-     * @param {object} where - Object representing the where query
-     * @param {object} values - Values to update
-     * @param {object} options
-     * @param {boolean} options.returnRecords - Determines if inserted records should be returned
-     * @param {{returnRecords: false}} options
-     * @returns {void}
-     */
-    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options: DoNotReturnRecords): Promise<void>;
-    /**
-     * Updates object(s) matching the where query, with the specified values
-     * @param {object} where - Object representing the where query
-     * @param {object} values - Values to update
-     * @param {object} [options] - Values to update
-     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
-     * @returns {object[]}
-     */
-    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: ReturnSelect$1<T>): UpdateResult<T>;
-    /**
-     * Updates object(s) matching the where query, with the specified values
-     * @param {object} where - Object representing the where query
-     * @param {object} values - Values to update
-     * @param {object} [options]
-     * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
-     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
-     * @returns {object[]|void} Return values from the db or `true` if returnRecords=false
-     */
-    update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: CreateUpdateOptions<T>): Promise<void> | UpdateResult<T>;
-    /**
-     * Destroys object(s) matching the where query
-     * @param {object} [where] - Object representing the where query
-     * @returns {void}
-     */
-    destroy(where?: WhereQuery<T>): DestroyResult<T, void>;
-    /**
-     * Destroys object(s) matching the where query
-     * @param {object} where - Object representing the where query
-     * @param {object} options - Determines if inserted records should be returned
-     * @param {boolean} [options.returnRecords] - Determines if inserted records should be returned
-     * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
-     * @returns {object[]}
-     */
-    destroy(where: WhereQuery<T>, options: DeleteOptions<T>): DestroyResultWithRecords<T>;
-}
-
-declare function subquery<T extends Record<string, unknown>>(repository: IReadonlyRepository<T> | IRepository<T>): SubqueryBuilder<T>;
-
-type AnyTableDef$1 = TableDefinition<string, any>;
+  results: TReturn[];
+  totalCount: number;
+}
+interface FindQueryWithCountJSON<T extends Entity, TReturn, TJoins extends AnyJoinInfo = never> extends PromiseLike<FindWithCountResult<PlainObject<TReturn>>> {
+  select<TKeys extends string & keyof OmitFunctions<QueryResult<T>>>(keys: TKeys[]): FindQueryWithCountJSON<T, Pick<QueryResult<T>, TKeys>, TJoins>;
+  where(args: JoinedWhereQuery<T, TJoins>): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindQueryWithCountJSON<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
+  join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindQueryWithCountJSON<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  join<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCountJSON<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  join(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Entity>>): FindQueryWithCountJSON<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  leftJoin<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCountJSON<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  leftJoin(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  sort(value?: JoinedSort<T, TJoins>): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  limit(value: number): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  skip(value: number): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  paginate(options: PaginateOptions): FindQueryWithCountJSON<T, TReturn, TJoins>;
+}
+interface FindQueryWithCount<T extends Entity, TReturn, TJoins extends AnyJoinInfo = never> extends PromiseLike<FindWithCountResult<TReturn>> {
+  select<TKeys extends string & keyof OmitFunctions<QueryResult<T>>>(keys: TKeys[]): FindQueryWithCount<T, Pick<QueryResult<T>, TKeys>, TJoins>;
+  where(args: JoinedWhereQuery<T, TJoins>): FindQueryWithCount<T, TReturn, TJoins>;
+  populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindQueryWithCount<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
+  join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindQueryWithCount<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  join<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCount<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  join(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCount<T, TReturn, TJoins>;
+  leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Entity>>): FindQueryWithCount<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  leftJoin<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCount<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  leftJoin(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindQueryWithCount<T, TReturn, TJoins>;
+  sort(value?: JoinedSort<T, TJoins>): FindQueryWithCount<T, TReturn, TJoins>;
+  limit(value: number): FindQueryWithCount<T, TReturn, TJoins>;
+  skip(value: number): FindQueryWithCount<T, TReturn, TJoins>;
+  paginate(options: PaginateOptions): FindQueryWithCount<T, TReturn, TJoins>;
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): FindQueryWithCountJSON<T, TReturn, TJoins>;
+}
+//#endregion
+//#region src/query/FindResult.d.ts
+interface FindResultJSON<T extends Entity, TReturn, TJoins extends AnyJoinInfo = never> extends PromiseLike<PlainObject<TReturn>[]> {
+  select<TKeys extends string & keyof OmitFunctions<QueryResult<T>>>(keys: TKeys[]): FindResultJSON<T, Pick<QueryResult<T>, TKeys>, TJoins>;
+  where(args: JoinedWhereQuery<T, TJoins>): FindResultJSON<T, TReturn, TJoins>;
+  populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindResultJSON<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
+  join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindResultJSON<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  /**
+  * Join a subquery with type-safe column tracking.
+  * Use `agg()` helper when building the subquery to enable type-safe sorting.
+  * @example
+  * const counts = subquery(ProductRepository)
+  *   .select(['store', agg(s => s.count(), 'productCount')])
+  *   .groupBy(['store']);
+  * StoreRepository.find()
+  *   .join(counts, 'stats', { on: { id: 'store' } })
+  *   .sort('stats.productCount desc')  // Type-safe!
+  */
+  join<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResultJSON<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  /** @deprecated Use `agg()` helper for type-safe subquery column sorting */
+  join(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResultJSON<T, TReturn, TJoins>;
+  leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Entity>>): FindResultJSON<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  /**
+  * Left join a subquery with type-safe column tracking.
+  * Use `agg()` helper when building the subquery to enable type-safe sorting.
+  */
+  leftJoin<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResultJSON<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  /** @deprecated Use `agg()` helper for type-safe subquery column sorting */
+  leftJoin(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResultJSON<T, TReturn, TJoins>;
+  /**
+  * Selects distinct rows based on the specified columns (PostgreSQL DISTINCT ON).
+  * The ORDER BY clause must start with the same columns in the same order.
+  * Cannot be combined with withCount().
+  * @param columns - Column names for DISTINCT ON clause
+  */
+  distinctOn(columns: (string & keyof OmitFunctions<OmitEntityCollections<T>>)[]): FindResultJSON<T, TReturn, TJoins>;
+  sort(value?: JoinedSort<T, TJoins>): FindResultJSON<T, TReturn, TJoins>;
+  limit(value: number): FindResultJSON<T, TReturn, TJoins>;
+  skip(value: number): FindResultJSON<T, TReturn, TJoins>;
+  paginate(options: PaginateOptions): FindResultJSON<T, TReturn, TJoins>;
+  withCount(): FindQueryWithCountJSON<T, TReturn, TJoins>;
+  UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T>(propertyName: TProperty): FindResultJSON<T, Omit<TReturn, TProperty> & Pick<T, TProperty>, TJoins>;
+}
+interface FindResult<T extends Entity, TReturn, TJoins extends AnyJoinInfo = never> extends PromiseLike<TReturn[]> {
+  select<TKeys extends string & keyof OmitFunctions<QueryResult<T>>>(keys: TKeys[]): FindResult<T, Pick<QueryResult<T>, TKeys>, TJoins>;
+  where(args: JoinedWhereQuery<T, TJoins>): FindResult<T, TReturn, TJoins>;
+  populate<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T, TPopulateType extends GetValueType<T[TProperty], Entity>, TPopulateSelectKeys extends string & keyof TPopulateType>(propertyName: TProperty, options?: PopulateArgs<TPopulateType, TPopulateSelectKeys>): FindResult<T, Omit<TReturn, TProperty> & Populated<T, TProperty, TPopulateType, TPopulateSelectKeys>, TJoins>;
+  join<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias): FindResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  /**
+  * Join a subquery with type-safe column tracking.
+  * Use `agg()` helper when building the subquery to enable type-safe sorting.
+  * @example
+  * const counts = subquery(ProductRepository)
+  *   .select(['store', agg(s => s.count(), 'productCount')])
+  *   .groupBy(['store']);
+  * StoreRepository.find()
+  *   .join(counts, 'stats', { on: { id: 'store' } })
+  *   .sort('stats.productCount desc')  // Type-safe!
+  */
+  join<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResult<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  /** @deprecated Use `agg()` helper for type-safe subquery column sorting */
+  join(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResult<T, TReturn, TJoins>;
+  leftJoin<TProperty extends ModelRelationshipKeys<T>, TAlias extends string = TProperty>(propertyName: TProperty, alias?: TAlias, on?: WhereQuery<GetValueType<T[TProperty], Entity>>): FindResult<T, TReturn, JoinInfo<TProperty, TAlias, GetValueType<T[TProperty], Entity>> | TJoins>;
+  /**
+  * Left join a subquery with type-safe column tracking.
+  * Use `agg()` helper when building the subquery to enable type-safe sorting.
+  */
+  leftJoin<TAlias extends string, TColumns extends string>(subquery: TypedSubqueryBuilder<TColumns>, alias: TAlias, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResult<T, TReturn, SubqueryJoinInfo<TAlias, TColumns> | TJoins>;
+  /** @deprecated Use `agg()` helper for type-safe subquery column sorting */
+  leftJoin(subquery: SubqueryBuilderLike, alias: string, options: {
+    on: SubqueryJoinOnCondition;
+  }): FindResult<T, TReturn, TJoins>;
+  /**
+  * Selects distinct rows based on the specified columns (PostgreSQL DISTINCT ON).
+  * The ORDER BY clause must start with the same columns in the same order.
+  * Cannot be combined with withCount().
+  * @param columns - Column names for DISTINCT ON clause
+  */
+  distinctOn(columns: (string & keyof OmitFunctions<OmitEntityCollections<T>>)[]): FindResult<T, TReturn, TJoins>;
+  sort(value?: JoinedSort<T, TJoins>): FindResult<T, TReturn, TJoins>;
+  limit(value: number): FindResult<T, TReturn, TJoins>;
+  skip(value: number): FindResult<T, TReturn, TJoins>;
+  paginate(options: PaginateOptions): FindResult<T, TReturn, TJoins>;
+  withCount(): FindQueryWithCount<T, TReturn, TJoins>;
+  UNSAFE_withOriginalFieldType<TProperty extends string & keyof PickByValueType<T, Entity> & keyof T>(propertyName: TProperty): FindResult<T, Omit<TReturn, TProperty> & Pick<T, TProperty>, TJoins>;
+  /**
+  * Returns results as plain objects instead of entity class instances.
+  * Useful for when data must be serializable.
+  */
+  toJSON(): FindResultJSON<T, TReturn, TJoins>;
+}
+//#endregion
+//#region src/IRepository.d.ts
+interface IRepository<T extends Entity> extends IReadonlyRepository<T> {
+  /**
+  * Creates an object using the specified values
+  * @param {object} values - Values to insert as multiple new objects.
+  * @param {object} [options]
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @returns {object}
+  */
+  create(values: CreateUpdateParams<T>, options?: OnConflictOptions<T> | (Partial<OnConflictOptions<T>> & ReturnSelect<T>)): CreateResult<T>;
+  /**
+  * Creates an object or objects using the specified values
+  * @param {object|object[]} values - Values to insert as multiple new objects.
+  * @param {object} options
+  * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @returns {void}
+  */
+  create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options: DoNotReturnRecords & Partial<OnConflictOptions<T>>): Promise<void>;
+  /**
+  * Creates objects using the specified values
+  * @param {object[]} values - Values to insert as multiple new objects.
+  * @param {object} [options]
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]}
+  */
+  create(values: CreateUpdateParams<T>[], options?: (OnConflictOptions<T> & Partial<ReturnSelect<T>>) | (Partial<OnConflictOptions<T>> & ReturnSelect<T>)): CreateResultArray<T>;
+  /**
+  * Creates an object using the specified values
+  * @param {object|object[]} values - Values to insert as a new object. If an array is specified, multiple rows will be inserted
+  * @param {object} [options]
+  * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @returns {object|object[]|void} Return value from the db
+  */
+  create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options?: CreateOptions<T>): CreateResult<T> | CreateResultArray<T> | Promise<void>;
+  /**
+  * Updates object(s) matching the where query, with the specified values
+  * @param {object} where - Object representing the where query
+  * @param {object} values - Values to update
+  * @param {object} options
+  * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+  * @param {{returnRecords: false}} options
+  * @returns {void}
+  */
+  update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options: DoNotReturnRecords): Promise<void>;
+  /**
+  * Updates object(s) matching the where query, with the specified values
+  * @param {object} where - Object representing the where query
+  * @param {object} values - Values to update
+  * @param {object} [options] - Values to update
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]}
+  */
+  update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: ReturnSelect<T>): UpdateResult<T>;
+  /**
+  * Updates object(s) matching the where query, with the specified values
+  * @param {object} where - Object representing the where query
+  * @param {object} values - Values to update
+  * @param {object} [options]
+  * @param {boolean} [options.returnRecords=true] - Determines if inserted records should be returned
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]|void} Return values from the db or `true` if returnRecords=false
+  */
+  update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: CreateUpdateOptions<T>): Promise<void> | UpdateResult<T>;
+  /**
+  * Destroys object(s) matching the where query
+  * @param {object} [where] - Object representing the where query
+  * @returns {void}
+  */
+  destroy(where?: WhereQuery<T>): DestroyResult<T, void>;
+  /**
+  * Destroys object(s) matching the where query
+  * @param {object} where - Object representing the where query
+  * @param {object} options - Determines if inserted records should be returned
+  * @param {boolean} [options.returnRecords] - Determines if inserted records should be returned
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]}
+  */
+  destroy(where: WhereQuery<T>, options: DeleteOptions<T>): DestroyResultWithRecords<T, QueryResult<T>>;
+}
+//#endregion
+//#region src/query/Subquery.d.ts
+declare function subquery<T extends Entity>(repository: IReadonlyRepository<T> | IRepository<T>): SubqueryBuilder<T>;
+//#endregion
+//#region src/query/WhereQuery.d.ts
 type ExcludeUndefined<T> = Exclude<T, undefined>;
 type LiteralValues<TValue> = (TValue | null)[] | TValue | null;
-type WhereClauseValue<TValue> = LiteralValues<ExcludeUndefined<TValue>>;
-type StringConstraint<TValue extends string> = Partial<Record<'contains' | 'endsWith' | 'like' | 'startsWith', LiteralValues<ExcludeUndefined<TValue>>>>;
+type WhereClauseValue<TValue> = TValue extends NotEntityBrand | undefined ? Exclude<TValue, NotEntityBrand | undefined> : Extract<TValue, Entity> extends undefined ? LiteralValues<ExcludeUndefined<TValue>> : (ExcludeUndefined<Exclude<TValue, Entity>> | null)[] | (Pick<Extract<ExcludeUndefined<TValue>, Entity>, "id"> | null)[] | ExcludeUndefined<Exclude<TValue, Entity>> | Pick<Extract<ExcludeUndefined<TValue>, Entity>, "id"> | null;
+type StringConstraint<TValue extends string> = Partial<Record<"contains" | "endsWith" | "like" | "startsWith", LiteralValues<ExcludeUndefined<TValue>>>>;
 type JsonPropertyValue = boolean | number | string | null;
-type JsonStringConstraint = Partial<Record<'contains' | 'endsWith' | 'like' | 'startsWith', string | string[]>>;
-type JsonPropertyConstraint = {
-    [key: string]: JsonPropertyConstraint | JsonPropertyValue | JsonPropertyValue[] | JsonStringConstraint | Partial<Record<'!' | '<' | '<=' | '>' | '>=', JsonPropertyValue>> | undefined;
-};
-type JsonConstraint<TValue> = Partial<Record<'contains', ExcludeUndefined<TValue> | LiteralValues<ExcludeUndefined<TValue>>>>;
-type NumberOrDateConstraint<TValue extends Date | number> = Partial<Record<'<' | '<=' | '>' | '>=', LiteralValues<ExcludeUndefined<TValue>>>>;
+interface JsonPropertyConstraint {
+  [key: string]: JsonPropertyConstraint | JsonPropertyValue | JsonPropertyValue[] | Partial<Record<"!" | "<" | "<=" | ">" | ">=", JsonPropertyValue>> | undefined;
+}
+type JsonConstraint<TValue> = Partial<Record<"contains", ExcludeUndefined<TValue> | LiteralValues<ExcludeUndefined<TValue>>>>;
+type NumberOrDateConstraint<TValue extends Date | number> = Partial<Record<"<" | "<=" | ">" | ">=", LiteralValues<ExcludeUndefined<TValue>>>>;
+interface VectorDistanceConstraint {
+  nearestTo: number[];
+  metric?: VectorDistanceMetric;
+  /**
+  * Distance bound(s) combined with AND. Required: pgvector distance operators return a number, so a where
+  * constraint without a bound would not be a boolean expression. Use `sort({ column: { nearestTo } })` to
+  * order by distance instead.
+  */
+  distance: Partial<Record<"<" | "<=" | ">" | ">=", number>>;
+}
 interface SubqueryInConstraint {
-    in: SubqueryBuilderLike;
+  in: SubqueryBuilderLike;
 }
-type ScalarSubqueryConstraint<TValue> = Partial<Record<'<' | '<=' | '>' | '>=', ScalarSubquery<TValue | undefined> | ScalarSubquery<TValue>>>;
+type ScalarSubqueryConstraint<TValue> = Partial<Record<"<" | "<=" | ">" | ">=", ScalarSubquery<TValue | undefined> | ScalarSubquery<TValue>>>;
 type NumberOrDateConstraintWithSubquery<TValue extends Date | number> = NumberOrDateConstraint<TValue> | ScalarSubqueryConstraint<TValue>;
 type NegatableConstraint<TValue> = TValue | {
-    '!': TValue;
+  "!": TValue;
 };
 type WhereQueryStatement<TValue> = [TValue] extends [string] ? NegatableConstraint<StringConstraint<TValue> | SubqueryInConstraint | WhereClauseValue<TValue>> : TValue extends string ? NegatableConstraint<StringConstraint<TValue> | SubqueryInConstraint | WhereClauseValue<TValue>> : TValue extends Date | number ? NegatableConstraint<NumberOrDateConstraintWithSubquery<TValue> | SubqueryInConstraint | WhereClauseValue<TValue>> : NegatableConstraint<JsonConstraint<TValue> | JsonPropertyConstraint | SubqueryInConstraint | WhereClauseValue<TValue>>;
-/** Structural match for repositories - carries schema via phantom `_schema` property */
-interface HasSchema<TSchema extends SchemaDefinition = SchemaDefinition> {
-    readonly _schema?: TSchema;
-}
-type ResolveRow<T> = T extends TableDefinition<string, infer TSchema> ? InferSelect<TSchema> : T extends HasSchema<infer TSchema> ? InferSelect<TSchema> : T;
-type WhereQueryRecord<T extends Record<string, unknown>> = {
-    [K in keyof T as ExcludeEntityCollections<ExcludeFunctions<T[K], K>>]?: K extends 'id' ? NegatableConstraint<WhereClauseValue<T>> | WhereQueryStatement<T[K]> : T[K] extends (infer U)[] | undefined ? WhereQueryStatement<ExcludeUndefined<U>> : NegatableConstraint<LiteralValues<ExcludeUndefined<T[K]>>> | WhereQueryStatement<ExcludeUndefined<T[K]>>;
-} & {
-    and?: WhereQueryRecord<T>[];
-    or?: WhereQueryRecord<T>[];
-    exists?: SubqueryBuilderLike;
-    '!'?: Pick<WhereQueryRecord<T>, 'exists'>;
+type WhereQuery<T extends Entity> = { [K in keyof T as ExcludeEntityCollections<T[K], ExcludeFunctions<T[K], K>>]?: K extends "id" ? NegatableConstraint<WhereClauseValue<T>> | WhereQueryStatement<T[K]> : T[K] extends (infer U)[] | undefined ? [U] extends [number] ? VectorDistanceConstraint | WhereQueryStatement<ExcludeUndefined<U>> : WhereQueryStatement<ExcludeUndefined<U>> : NegatableConstraint<LiteralValues<ExcludeUndefined<T[K]>>> | WhereQueryStatement<ExcludeUndefined<T[K]>> } & {
+  and?: WhereQuery<T>[];
+  or?: WhereQuery<T>[];
+  exists?: SubqueryBuilderLike;
+  "!"?: Pick<WhereQuery<T>, "exists">;
 };
-/**
- * Where clause type. Accepts a TableDefinition, repository, or row type:
- * - `WhereQuery<typeof Product>` - from a model or repository
- * - `WhereQuery<ProductRow>` - from a plain row type
- */
-type WhereQuery<T extends AnyTableDef$1 | HasSchema | Record<string, unknown>> = WhereQueryRecord<ResolveRow<T> extends Record<string, unknown> ? ResolveRow<T> : Record<string, unknown>>;
-
-interface CountArgs<T extends Record<string, unknown>> {
-    where?: WhereQuery<T>;
-    pool?: PoolLike;
-}
-
-type AnyModel$1 = TableDefinition<string, any>;
-interface IReadonlyRepository<T extends Record<string, unknown>, TSchema extends SchemaDefinition = SchemaDefinition, TModels extends Record<string, AnyModel$1> = DefaultModelsMap> {
-    /** @internal Phantom property for type-level schema extraction */
-    readonly _schema?: TSchema;
-    /** @internal Phantom property for type-level models map extraction */
-    readonly _models?: TModels;
-    readonly model: ModelMetadata<T>;
-    /**
-     * Gets a single object
-     * @param {object} [args] - Arguments
-     * @param {string[]} [args.select] - Array of model property names to return from the query.
-     * @param {object} [args.where] - Object representing the where query
-     * @param {string|object|string[]|object[]} [args.sort] - Property name(s) to sort by
-     * @param {object} [args.pool] - Override the db pool to use for the query
-     */
-    findOne<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | 'id'>, TSchema>>(args?: FindOneArgs<T, K> | WhereQuery<T>): FindOneResult<T, TReturn, never, TSchema, TModels>;
-    /**
-     * Gets a collection of objects
-     * @param {object} [args] - Arguments
-     * @param {string[]} [args.select] - Array of model property names to return from the query.
-     * @param {object} [args.where] - Object representing the where query
-     * @param {string|object|string[]|object[]} [args.sort] - Property name(s) to sort by
-     * @param {string|number} [args.skip] - Number of records to skip
-     * @param {string|number} [args.limit] - Number of results to return
-     * @param {object} [args.pool] - Override the db pool to use for the query
-     */
-    find<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | 'id'>, TSchema>>(args?: FindArgs<T, K> | WhereQuery<T>): FindResult<T, TReturn, never, TSchema, TModels>;
-    /**
-     * Gets a count of rows matching the where query
-     * @param {object} [args] - Arguments
-     * @param {object} [args.where] - Object representing the where query
-     * @param {object} [args.pool] - Override the db pool to use for the query
-     * @returns {number} Number of records matching the where criteria
-     */
-    count(args?: CountArgs<T> | WhereQuery<T>): CountResult<T>;
-}
-
+//#endregion
+//#region src/query/CountArgs.d.ts
+interface CountArgs<T extends Entity> {
+  where?: WhereQuery<T>;
+  pool?: PoolLike;
+}
+//#endregion
+//#region src/IReadonlyRepository.d.ts
+interface IReadonlyRepository<T extends Entity> {
+  readonly model: ModelMetadata<T>;
+  /**
+  * Gets a single object
+  * @param {object} [args] - Arguments
+  * @param {string[]} [args.select] - Array of model property names to return from the query.
+  * @param {object} [args.where] - Object representing the where query
+  * @param {string|object|string[]|object[]} [args.sort] - Property name(s) to sort by
+  * @param {object} [args.pool] - Override the db pool to use for the query
+  */
+  findOne<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | "id">>>(args: FindOneArgs<T, K> | WhereQuery<T>): FindOneResult<T, TReturn>;
+  /**
+  * Gets a collection of objects
+  * @param {object} [args] - Arguments
+  * @param {string[]} [args.select] - Array of model property names to return from the query.
+  * @param {object} [args.where] - Object representing the where query
+  * @param {string|object|string[]|object[]} [args.sort] - Property name(s) to sort by
+  * @param {string|number} [args.skip] - Number of records to skip
+  * @param {string|number} [args.limit] - Number of results to return
+  * @param {object} [args.pool] - Override the db pool to use for the query
+  */
+  find<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | "id">>>(args: FindArgs<T, K> | WhereQuery<T>): FindResult<T, TReturn>;
+  /**
+  * Gets a count of rows matching the where query
+  * @param {object} [args] - Arguments
+  * @param {object} [args.where] - Object representing the where query
+  * @param {object} [args.pool] - Override the db pool to use for the query
+  * @returns {number} Number of records matching the where criteria
+  */
+  count(args?: CountArgs<T> | WhereQuery<T>): CountResult<T>;
+}
+//#endregion
+//#region src/ReadonlyRepository.d.ts
+interface IRepositoryOptions<T extends Entity> {
+  modelMetadata: ModelMetadata<T>;
+  type: EntityStatic<T>;
+  repositoriesByModelNameLowered: Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
+  pool: PoolLike;
+  readonlyPool?: PoolLike;
+}
+interface Populate {
+  propertyName: string;
+  where?: WhereQuery<Entity>;
+  select?: string[];
+  sort?: SortObject<Entity> | string;
+  skip?: number;
+  limit?: number;
+  pool?: PoolLike;
+  asPlainObjects?: boolean;
+  through?: {
+    where?: Record<string, unknown>;
+    sort?: SortObject<Entity> | string;
+  };
+}
+declare class ReadonlyRepository<T extends Entity> implements IReadonlyRepository<T> {
+  private readonly _modelMetadata;
+  protected _type: EntityStatic<T>;
+  protected _pool: PoolLike;
+  protected _readonlyPool: PoolLike;
+  protected _repositoriesByModelNameLowered: Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
+  protected _floatProperties: string[];
+  protected _intProperties: string[];
+  protected _vectorProperties: string[];
+  constructor({
+    modelMetadata,
+    type,
+    pool,
+    readonlyPool,
+    repositoriesByModelNameLowered
+  }: IRepositoryOptions<T>);
+  get model(): ModelMetadata<T>;
+  /**
+  * Gets a single object
+  * @param {object} [args] - Arguments
+  * @param {string[]} [args.select] - Array of model property names to return from the query.
+  * @param {object} [args.where] - Object representing the where query
+  * @param {string|object} [args.sort] - Property name(s) to sort by
+  * @returns Database record or null
+  */
+  findOne<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | keyof PickFunctions<T> | "id">>>(args?: FindOneArgs<T, K> | WhereQuery<T>): FindOneResult<T, TReturn>;
+  /**
+  * Gets a collection of objects
+  * @param {object} [args] - Arguments
+  * @param {string[]} [args.select] - Array of model property names to return from the query.
+  * @param {object} [args.where] - Object representing the where query
+  * @param {string|object} [args.sort] - Property name(s) to sort by
+  * @param {string|number} [args.skip] - Number of records to skip
+  * @param {string|number} [args.limit] - Number of results to return
+  * @returns Database records
+  */
+  find<K extends string & keyof T, TReturn = QueryResult<Pick<T, K | keyof PickFunctions<T> | "id">>>(args?: FindArgs<T, K> | WhereQuery<T>): FindResult<T, TReturn>;
+  /**
+  * Gets a count of rows matching the where query
+  * @param {object} [args] - Arguments
+  * @param {object} [args.where] - Object representing the where query
+  * @param {object} [args.pool] - Override the db pool to use for the query
+  * @returns {number} Number of records matching the where criteria
+  */
+  count(args?: CountArgs<T> | WhereQuery<T>): CountResult<T>;
+  protected _buildInstance(row: Partial<QueryResult<T>>): QueryResult<T>;
+  protected _buildInstances(rows: Partial<QueryResult<T>>[]): QueryResult<T>[];
+  protected _buildPlainObject(row: Partial<QueryResult<T>>): QueryResult<T>;
+  protected _buildPlainObjects(rows: Partial<QueryResult<T>>[]): QueryResult<T>[];
+  protected _parseVectorString(value: string): number[] | undefined;
+  protected _convertSortsToOrderBy(sorts: SortObject<T> | string): OrderBy<T>[];
+  protected populateFields(entities: QueryResult<T>[], populates: Populate[]): Promise<void>;
+  private populateSingleAssociation;
+  private populateOneManyCollection;
+  private populateManyManyCollection;
+}
+//#endregion
+//#region src/Repository.d.ts
+declare class Repository<T extends Entity> extends ReadonlyRepository<T> implements IRepository<T> {
+  /**
+  * Creates an object using the specified values
+  * @param {object} values - Values to insert as multiple new objects.
+  * @param {object} [options]
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @returns {object}
+  */
+  create(values: CreateUpdateParams<T>, options?: OnConflictOptions<T> | (Partial<OnConflictOptions<T>> & ReturnSelect<T>)): CreateResult<T>;
+  /**
+  * Creates an object or objects using the specified values
+  * @param {object|object[]} values - Values to insert as multiple new objects.
+  * @param {object} options
+  * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @returns {void}
+  */
+  create(values: CreateUpdateParams<T> | CreateUpdateParams<T>[], options: DoNotReturnRecords & Partial<OnConflictOptions<T>>): Promise<void>;
+  /**
+  * Creates objects using the specified values
+  * @param {object[]} values - Values to insert as multiple new objects.
+  * @param {object} [options]
+  * @param {object} [options.onConflict] - Options to handle conflicts due to a unique constraint or exclusion constraint error during insert
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]}
+  */
+  create(values: CreateUpdateParams<T>[], options?: (OnConflictOptions<T> & Partial<ReturnSelect<T>>) | (Partial<OnConflictOptions<T>> & ReturnSelect<T>)): CreateResultArray<T>;
+  /**
+  * Updates object(s) matching the where query, with the specified values
+  * @param {object} where - Object representing the where query
+  * @param {object} values - Values to update
+  * @param {object} options
+  * @param {boolean} options.returnRecords - Determines if inserted records should be returned
+  * @returns {void}
+  */
+  update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options: DoNotReturnRecords): Promise<void>;
+  /**
+  * Updates object(s) matching the where query, with the specified values
+  * @param {object} where - Object representing the where query
+  * @param {object} values - Values to update
+  * @param {object} [options] - Values to update
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]}
+  */
+  update(where: WhereQuery<T>, values: CreateUpdateParams<T>, options?: ReturnSelect<T>): UpdateResult<T>;
+  /**
+  * Destroys object(s) matching the where query
+  * @param {object} [where] - Object representing the where query
+  * @returns {void}
+  */
+  destroy(where?: WhereQuery<T>): DestroyResult<T, void>;
+  /**
+  * Destroys object(s) matching the where query
+  * @param {object} where - Object representing the where query
+  * @param {object} options - Determines if inserted records should be returned
+  * @param {boolean} [options.returnRecords] - Determines if inserted records should be returned
+  * @param {string[]} [options.returnSelect] - Array of model property names to return from the query.
+  * @returns {object[]}
+  */
+  destroy(where: WhereQuery<T>, options: DeleteOptions<T>): DestroyResultWithRecords<T, QueryResult<T>>;
+}
+//#endregion
+//#region src/decorators/ColumnBaseOptions.d.ts
+interface ColumnBaseOptions {
+  /**
+  * Column name in the database
+  */
+  name?: string;
+  /**
+  * Indicates if a value is required for creates.
+  */
+  required?: boolean;
+}
+//#endregion
+//#region src/decorators/ColumnCollectionOptions.d.ts
+interface ColumnCollectionOptions extends ColumnBaseOptions {
+  /**
+  * Type of the items in the collection
+  */
+  collection: string | (() => string);
+  /**
+  * Property name of the on the collection item type
+  */
+  via: string;
+  /**
+  * Name of the junction table for multi-multi associations
+  */
+  through?: string | (() => string);
+}
+//#endregion
+//#region src/decorators/ColumnModelOptions.d.ts
+interface ColumnModelOptions extends ColumnBaseOptions {
+  /**
+  * Type of the entity represented by this column id
+  */
+  model: string | (() => string);
+}
+//#endregion
+//#region src/decorators/ColumnTypeOptions.d.ts
+interface ColumnTypeOptions extends ColumnBaseOptions {
+  /**
+  * Type of the column
+  */
+  type: "array" | "binary" | "boolean" | "boolean[]" | "date" | "datetime" | "float" | "float[]" | "integer" | "integer[]" | "json" | "string" | "string[]" | "uuid" | "uuid[]" | "vector";
+  /**
+  * Default database value
+  */
+  defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+  /**
+  * Number of dimensions for the column. Informational only - BigAl does not issue DDL
+  *
+  * Applies to types: vector
+  */
+  dimensions?: number;
+  /**
+  * Array of possible enumerated values
+  */
+  enum?: readonly string[];
+  /**
+  * If set, enforces a maximum length check on the column
+  *
+  * Applies to types: string | string[]
+  */
+  maxLength?: number;
+}
+//#endregion
+//#region src/decorators/column.d.ts
+type ColumnOptions$1 = ColumnCollectionOptions | ColumnModelOptions | ColumnTypeOptions;
+type ReturnFunctionType$5 = (object: ClassLike, propertyName: string) => void;
+declare function column(options?: ColumnOptions$1): ReturnFunctionType$5;
+declare function column(dbColumnName: string, options?: ColumnOptions$1): ReturnFunctionType$5;
+//#endregion
+//#region src/decorators/createDateColumn.d.ts
+type ReturnFunctionType$4 = (object: ClassLike, propertyName: string) => void;
+declare function createDateColumn(options?: ColumnTypeOptions): ReturnFunctionType$4;
+declare function createDateColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType$4;
+//#endregion
+//#region src/decorators/primaryColumn.d.ts
+type ColumnOptions = ColumnModelOptions | ColumnTypeOptions;
+type ReturnFunctionType$3 = (object: ClassLike, propertyName: string) => void;
+declare function primaryColumn(options?: ColumnOptions): ReturnFunctionType$3;
+declare function primaryColumn(dbColumnName: string, options?: ColumnOptions): ReturnFunctionType$3;
+//#endregion
+//#region src/decorators/TableOptions.d.ts
+interface TableOptions {
+  /**
+  * Table name in the database
+  */
+  name?: string;
+  /**
+  * Schema table belongs to in the database
+  */
+  schema?: string;
+  /**
+  * Connection name to use for queries
+  */
+  connection?: string;
+  /**
+  * Indicates if create, update, delete statements should be available
+  */
+  readonly?: boolean;
+}
+//#endregion
+//#region src/decorators/table.d.ts
+type ReturnFunctionType$2 = (object: any) => void;
+declare function table(options?: TableOptions): ReturnFunctionType$2;
+declare function table(dbName: string, options: TableOptions): ReturnFunctionType$2;
+//#endregion
+//#region src/decorators/updateDateColumn.d.ts
+type ReturnFunctionType$1 = (object: ClassLike, propertyName: string) => void;
+declare function updateDateColumn(options?: ColumnTypeOptions): ReturnFunctionType$1;
+declare function updateDateColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType$1;
+//#endregion
+//#region src/decorators/versionColumn.d.ts
+type ReturnFunctionType = (object: ClassLike, propertyName: string) => void;
+declare function versionColumn(options?: ColumnTypeOptions): ReturnFunctionType;
+declare function versionColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType;
+//#endregion
+//#region src/errors/QueryError.d.ts
+declare class QueryError<T extends Entity> extends Error {
+  model: ModelMetadata<T>;
+  where: WhereQuery<T> | undefined;
+  constructor(message: string, model: ModelMetadata<T>, where?: WhereQuery<T>);
+}
+//#endregion
+//#region src/index.d.ts
 interface IConnection {
-    pool: PoolLike;
-    readonlyPool?: PoolLike;
-}
-interface OnQueryEvent {
-    sql: string;
-    params: readonly unknown[];
-    duration: number;
-    error?: Error;
-    model: string;
-    operation: 'count' | 'create' | 'destroy' | 'find' | 'findOne' | 'update';
-}
-type OnQueryCallback = (event: OnQueryEvent) => void;
-type AnyModel = TableDefinition<string, any>;
-/** Infers the repository type for a model, threading the full models map for populate resolution */
-type InferRepository<TModels extends Record<string, AnyModel>, T extends AnyModel> = T extends TableDefinition<string, infer TSchema> ? T['isReadonly'] extends true ? IReadonlyRepository<InferSelect<TSchema>, TSchema, TModels> : IRepository<InferSelect<TSchema>, TSchema, TModels> : never;
-/** Maps a named models object to a typed repositories object */
-type RepositoryMap<TModels extends Record<string, AnyModel>> = {
-    [K in keyof TModels]: InferRepository<TModels, TModels[K]>;
-};
-interface InitializeOptionsArray extends IConnection {
-    models: AnyModel[];
-    connections?: Record<string, IConnection>;
-    onQuery?: OnQueryCallback;
-}
-interface InitializeOptionsObject<TModels extends Record<string, AnyModel>> extends IConnection {
-    models: TModels;
-    connections?: Record<string, IConnection>;
-    onQuery?: OnQueryCallback;
+  pool: PoolLike;
+  readonlyPool?: PoolLike;
 }
-interface InitializeResult {
-    getRepository<TName extends string, TSchema extends SchemaDefinition>(model: TableDefinition<TName, TSchema>): IRepository<InferSelect<TSchema>, TSchema>;
-    getReadonlyRepository<TName extends string, TSchema extends SchemaDefinition>(model: TableDefinition<TName, TSchema>): IReadonlyRepository<InferSelect<TSchema>, TSchema>;
+interface InitializeOptions extends IConnection {
+  models: EntityStatic<Entity>[];
+  connections?: Record<string, IConnection>;
+  expose?: (repository: ReadonlyRepository<Entity> | Repository<Entity>, tableMetadata: ModelMetadata<Entity>) => void;
 }
-type InitializeResultWithRepos<TModels extends Record<string, AnyModel>> = InitializeResult & RepositoryMap<TModels>;
-/**
- * Creates a BigAl instance with a named models object.
- * Returns typed repositories directly: `const { Product, Store } = initialize({ models: { Product, Store }, pool })`.
- *
- * @param {InitializeOptionsObject} options - Pool, models object, and optional config
- */
-declare function initialize<TModels extends Record<string, AnyModel>>(options: InitializeOptionsObject<TModels>): InitializeResultWithRepos<TModels>;
-/**
- * Creates a BigAl instance with a models array.
- * Use `getRepository(model)` to obtain typed repositories.
- *
- * @param {InitializeOptionsArray} options - Pool, models array, and optional config
- */
-declare function initialize(options: InitializeOptionsArray): InitializeResult;
-
-declare class QueryError<T extends Record<string, unknown>> extends Error {
-    model: ModelMetadata<T>;
-    where: WhereQuery<T> | undefined;
-    constructor(message: string, model: ModelMetadata<T>, where?: WhereQuery<T>);
-}
-
-type SerialConfig = ColumnBuilderConfig<number, true, true, true>;
-type BigSerialConfig = ColumnBuilderConfig<number, true, true, true>;
-type IntegerConfig = ColumnBuilderConfig<number>;
-type BigIntConfig = ColumnBuilderConfig<number>;
-type SmallIntConfig = ColumnBuilderConfig<number>;
-type RealConfig = ColumnBuilderConfig<number>;
-type DoublePrecisionConfig = ColumnBuilderConfig<number>;
-type BooleanColumnConfig = ColumnBuilderConfig<boolean>;
-type TimestampConfig = ColumnBuilderConfig<Date>;
-type TimestampTzConfig = ColumnBuilderConfig<Date>;
-type DateColumnConfig = ColumnBuilderConfig<Date>;
-type UuidConfig = ColumnBuilderConfig<string>;
-type ByteaConfig = ColumnBuilderConfig<Buffer>;
-type TextArrayConfig = ColumnBuilderConfig<string[]>;
-type IntegerArrayConfig = ColumnBuilderConfig<number[]>;
-type BooleanArrayConfig = ColumnBuilderConfig<boolean[]>;
-type CreatedAtConfig = ColumnBuilderConfig<Date, true, true, false, true>;
-type UpdatedAtConfig = ColumnBuilderConfig<Date, true, true, false, true>;
-interface ColumnOptions {
-    name?: string;
-}
-interface VarcharOptions extends ColumnOptions {
-    length?: number;
-}
-declare function serial(options?: ColumnOptions): ColumnBuilder<SerialConfig>;
-declare function bigserial(options?: ColumnOptions): ColumnBuilder<BigSerialConfig>;
-declare function text<T extends string = string>(options?: ColumnOptions): ColumnBuilder<ColumnBuilderConfig<T>>;
-declare function varchar<T extends string = string>(options?: VarcharOptions): ColumnBuilder<ColumnBuilderConfig<T>>;
-declare function integer(options?: ColumnOptions): ColumnBuilder<IntegerConfig>;
-declare function bigint(options?: ColumnOptions): ColumnBuilder<BigIntConfig>;
-declare function smallint(options?: ColumnOptions): ColumnBuilder<SmallIntConfig>;
-declare function real(options?: ColumnOptions): ColumnBuilder<RealConfig>;
-/** Alias for `real()`. Maps to PostgreSQL REAL (single-precision floating point). */
-declare const float: typeof real;
-declare function double(options?: ColumnOptions): ColumnBuilder<DoublePrecisionConfig>;
-declare function booleanColumn(options?: ColumnOptions): ColumnBuilder<BooleanColumnConfig>;
-declare function timestamp(options?: ColumnOptions): ColumnBuilder<TimestampConfig>;
-declare function timestamptz(options?: ColumnOptions): ColumnBuilder<TimestampTzConfig>;
-declare function dateColumn(options?: ColumnOptions): ColumnBuilder<DateColumnConfig>;
-declare function json<T = Record<string, unknown>>(options?: ColumnOptions): ColumnBuilder<ColumnBuilderConfig<T>>;
-declare function jsonb<T = Record<string, unknown>>(options?: ColumnOptions): ColumnBuilder<ColumnBuilderConfig<T>>;
-declare function uuid(options?: ColumnOptions): ColumnBuilder<UuidConfig>;
-declare function bytea(options?: ColumnOptions): ColumnBuilder<ByteaConfig>;
-declare function textArray(options?: ColumnOptions): ColumnBuilder<TextArrayConfig>;
-declare function integerArray(options?: ColumnOptions): ColumnBuilder<IntegerArrayConfig>;
-declare function booleanArray(options?: ColumnOptions): ColumnBuilder<BooleanArrayConfig>;
-declare function createdAt(options?: ColumnOptions): ColumnBuilder<CreatedAtConfig>;
-declare function updatedAt(options?: ColumnOptions): ColumnBuilder<UpdatedAtConfig>;
-interface VectorOptions extends ColumnOptions {
-    dimensions: number;
-}
-type VectorConfig = ColumnBuilderConfig<number[]>;
-declare function vector(options: VectorOptions): ColumnBuilder<VectorConfig>;
-
-type AnyTableDef = TableDefinition<string, any>;
-/**
- * A typed read-write repository for a model. Provides find, findOne, create,
- * update, destroy, and populate operations with full type safety.
- *
- * @example
- * ```typescript
- * import type { Repository } from 'bigal';
- *
- * function processProducts(repo: Repository<typeof Product>) {
- *   const products = await repo.find().where({ name: 'Widget' });
- * }
- * ```
- */
-type Repository<T extends AnyTableDef> = T extends TableDefinition<string, infer TSchema> ? IRepository<InferSelect<TSchema>, TSchema> : never;
 /**
- * A typed read-only repository for a model backed by a PostgreSQL view.
- * Provides find, findOne, and count operations.
- *
- * @example
- * ```typescript
- * import type { ReadonlyRepository } from 'bigal';
- *
- * function readSummary(repo: ReadonlyRepository<typeof StoreSummary>) {
- *   const summary = await repo.findOne().where({ id: 1 });
- * }
- * ```
- */
-type ReadonlyRepository<T extends AnyTableDef> = T extends TableDefinition<string, infer TSchema> ? IReadonlyRepository<InferSelect<TSchema>, TSchema> : never;
-
-export { BelongsToBuilder, ColumnBaseMetadata, ColumnBuilder, ColumnCollectionMetadata, ColumnModelMetadata, ColumnTypeMetadata, HasManyBuilder, ModelMetadata, QueryError, ScalarSubquery, SelectBuilder, SubqueryBuilder, belongsTo, bigint, bigserial, booleanColumn as boolean, booleanArray, booleanColumn, bytea, createdAt, dateColumn as date, dateColumn, double, float, hasMany, initialize, integer, integerArray, isSubqueryJoin, json, jsonb, real, serial, smallint, subquery, table, text, textArray, timestamp, timestamptz, updatedAt, uuid, varchar, vector, view };
-export type { AggregateBuilder, AggregateCallback, AnyJoinInfo, BelongsToConfig, BelongsToEntry, BelongsToKeys, ColumnBaseMetadataOptions, ColumnBuilderConfig, ColumnBuilderRuntimeConfig, ColumnCollectionMetadataOptions, ColumnMetadata$1 as ColumnMetadata, ColumnModelMetadataOptions, ColumnModifierMetadata, ColumnOptions, ColumnTypeMetadataOptions, Comparer, CountResult, CreateResult, CreateResultArray, CreateUpdateOptions, CreateUpdateParams, DefaultModelsMap, DeleteOptions, DestroyResult, DestroyResultWithRecords, DoNotReturnRecords, EntityOrId, ExcludeEntityCollections, ExcludeFunctions, FilterDefinition, FindArgs, FindOneArgs, FindOneResult, FindQueryWithCount, FindResult, FindWithCountResult, GetValueType, HasManyConfig, HasManyEntry, HasManyKeys, HasManyThroughIntermediate, HavingComparer, HavingCondition, IConnection, IReadonlyRepository, IRepository, IncludeFunctions, InferInsert, InferSelect, InitializeOptionsArray, InitializeOptionsObject, InitializeResult, InitializeResultWithRepos, IsValueOfType, JoinDefinition, JoinInfo, JoinType, JoinedSort, JoinedWhereQuery, JsonConstraint, JsonPropertyConstraint, JsonPropertyValue, LiteralValues, ModelHooks, ModelJoinDefinition, ModelMetadataOptions, ModelRelationshipKeys, MultipleSortString, NegatableConstraint, NumberOrDateConstraint, NumberOrDateConstraintWithSubquery, OmitEntityCollections, OmitFunctions, OnQueryCallback, OnQueryEvent, OptionalInsertKeys, OrderBy, PaginateOptions, PickAsType, PickByValueType, PickFunctions, PoolLike, PoolQueryResult, PopulateArgs, Populated, QueryResult, QueryResultPopulated, QueryResultRow, ReadonlyRepository, RelationshipKeys, Repository, RequiredInsertKeys, ResolveModel, ReturnSelect$1 as ReturnSelect, ScalarSubqueryConstraint, SchemaDefinition, SchemaEntry, TableOptions as SchemaTableOptions, SelectAggregateExpression, SelectItem, SelectKeys, Sort, SortObject, SortObjectValue, SortString, StringConstraint, SubqueryBuilderLike, SubqueryInConstraint, SubqueryJoinDefinition, SubqueryJoinInfo, SubqueryJoinOnCondition, TableDefinition, ThroughArgs, TypedAggregateExpression, TypedSelectItem, TypedSubqueryBuilder, UpdateResult, VarcharOptions, VectorDistanceMetric, VectorDistanceSort, VectorOptions, WhereClauseValue, WhereQuery, WhereQueryStatement };
+* Initializes BigAl
+* @param {object[]} models - Model classes - used to force decorator evaluation for all models
+* @param {object[]} modelSchemas - Model definitions
+* @param {object} pool - Postgres Pool
+* @param {object} [readonlyPool] - Postgres Pool for `find` and `findOne` operations. If not defined, `pool` will be used
+* @param {object} [connections] - Key: name of the connection; Value: { pool, readonlyPool }
+* @param {Function} [expose] - Used to expose model classes
+* @returns {object} Repositories by model name
+*/
+declare function initialize({
+  models,
+  pool,
+  readonlyPool,
+  connections,
+  expose
+}: InitializeOptions): Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
+//#endregion
+export { type AggregateBuilder, type AggregateCallback, AnyJoinInfo, ClassLike, ColumnBaseMetadata, ColumnBaseMetadataOptions, ColumnCollectionMetadata, ColumnCollectionMetadataOptions, ColumnMetadata, ColumnModelMetadata, ColumnModelMetadataOptions, ColumnModifierMetadata, ColumnTypeMetadata, ColumnTypeMetadataOptions, Comparer, CountResult, CreateResult, CreateResultArray, CreateResultArrayJSON, CreateResultJSON, CreateUpdateOptions, CreateUpdateParams, DeleteOptions, DestroyResult, DestroyResultJSON, DestroyResultWithRecords, DoNotReturnRecords, Entity, EntityFieldValue, EntityPrimitiveOrId, EntityStatic, ExcludeEntityCollections, ExcludeFunctions, FindArgs, FindOneArgs, FindOneResult, FindOneResultJSON, FindQueryWithCount, FindQueryWithCountJSON, FindResult, FindResultJSON, FindWithCountResult, GetValueType, type HavingComparer, type HavingCondition, IConnection, IReadonlyRepository, IRepository, IRepositoryOptions, IncludeFunctions, InitializeOptions, IsValueOfType, JoinDefinition, JoinInfo, JoinType, JoinedSort, JoinedWhereQuery, JsonConstraint, JsonPropertyConstraint, JsonPropertyValue, LiteralValues, ModelJoinDefinition, ModelMetadata, ModelMetadataOptions, ModelRelationshipKeys, MultipleSortString, NegatableConstraint, NotEntity, NotEntityBrand, NumberOrDateConstraint, NumberOrDateConstraintWithSubquery, OmitEntityCollections, OmitFunctions, OrderBy, PaginateOptions, PickAsType, PickByValueType, PickFunctions, PlainObject, PoolLike, PoolQueryResult, PopulateArgs, Populated, QueryError, QueryResult, QueryResultOptionalPopulated, QueryResultPopulated, QueryResultRow, ReadonlyRepository, Repository, ReturnSelect, ScalarSubquery, ScalarSubqueryConstraint, type SelectAggregateExpression, SelectBuilder, type SelectItem, Sort, SortObject, SortObjectValue, SortString, StringConstraint, SubqueryBuilder, type SubqueryBuilderLike, SubqueryInConstraint, SubqueryJoinDefinition, SubqueryJoinInfo, SubqueryJoinOnCondition, ThroughArgs, type TypedAggregateExpression, type TypedSelectItem, type TypedSubqueryBuilder, UpdateResult, UpdateResultJSON, VectorDistanceConstraint, VectorDistanceMetric, VectorDistanceSort, WhereClauseValue, WhereQuery, WhereQueryStatement, column, createDateColumn, getMetadataStorage, initialize, isSubqueryJoin, primaryColumn, subquery, table, updateDateColumn, versionColumn };