@holo-js/media 0.1.9 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _holo_js_db from '@holo-js/db';
-import { Entity as Entity$1, TableDefinition as TableDefinition$1, ModelRecord as ModelRecord$1, RelationMap as RelationMap$1, DynamicRelationResolver, ModelQueryBuilder as ModelQueryBuilder$1, ModelCollection as ModelCollection$1, EntityWithLoaded as EntityWithLoaded$1, PaginatedResult as PaginatedResult$1, SimplePaginatedResult as SimplePaginatedResult$1, CursorPaginatedResult as CursorPaginatedResult$1, ResolveEagerLoads as ResolveEagerLoads$1 } from '@holo-js/db';
+import { Entity, TableDefinition, ModelRecord, RelationMap, DynamicRelationResolver, ModelQueryBuilder, ModelRelationPath, RelationConstraintDefinition, RelatedColumnNameForRelationPath, ModelCollection, EntityWithLoaded, PaginatedResult, SimplePaginatedResult, CursorPaginatedResult, ResolveEagerLoads } from '@holo-js/db';
 import { StorageContent } from '@holo-js/storage/runtime';
 import { QueueJobDefinition, QueueJsonValue } from '@holo-js/queue';
 
@@ -96,2765 +96,6 @@ declare function normalizeMediaDefinition<TCollectionName extends string = strin
 
 type BinaryContent = Exclude<StorageContent, string>;
 
-/**
- * Capability flags exposed by a driver+dialect pair.
- *
- * The new architecture uses explicit capabilities instead of branching on
- * driver names throughout the ORM.
- */
-interface DatabaseCapabilities {
-    returning: boolean;
-    savepoints: boolean;
-    concurrentQueries: boolean;
-    workerThreadExecution: boolean;
-    lockForUpdate: boolean;
-    sharedLock: boolean;
-    jsonValueQuery: boolean;
-    jsonContains: boolean;
-    jsonLength: boolean;
-    schemaQualifiedIdentifiers: boolean;
-    nativeUpsert: boolean;
-    ddlAlterSupport: boolean;
-    introspection: boolean;
-}
-
-type LogicalColumnKind = 'id' | 'integer' | 'bigInteger' | 'string' | 'text' | 'boolean' | 'real' | 'decimal' | 'date' | 'datetime' | 'timestamp' | 'json' | 'blob' | 'uuid' | 'ulid' | 'snowflake' | 'vector' | 'enum';
-type ColumnDefaultKind = 'value' | 'now';
-type IdGenerationStrategy = 'autoIncrement' | 'uuid' | 'ulid' | 'snowflake';
-type VectorValue = readonly number[];
-interface ForeignKeyReference {
-    table: string;
-    column: string;
-    constraintName?: string;
-    onDelete?: string;
-    onUpdate?: string;
-}
-interface ColumnDefinition<_TType = unknown, TNullable extends boolean = false, THasDefault extends boolean = false, TGenerated extends boolean = false, TPrimaryKey extends boolean = false> {
-    readonly kind: LogicalColumnKind;
-    readonly name: string;
-    readonly nullable: TNullable;
-    readonly hasDefault: THasDefault;
-    readonly generated: TGenerated;
-    readonly primaryKey: TPrimaryKey;
-    readonly unique: boolean;
-    readonly defaultKind?: ColumnDefaultKind;
-    readonly defaultValue?: unknown;
-    readonly references?: ForeignKeyReference;
-    readonly idStrategy?: IdGenerationStrategy;
-    readonly enumValues?: readonly string[];
-    readonly vectorDimensions?: number;
-}
-type AnyColumnDefinition = ColumnDefinition<unknown, boolean, boolean, boolean, boolean>;
-type TableColumnsShape = Record<string, AnyColumnDefinition>;
-interface TableDefinition<TName extends string = string, TColumns extends TableColumnsShape = TableColumnsShape> {
-    readonly kind: 'table';
-    readonly tableName: TName;
-    readonly columns: TColumns;
-    readonly indexes: readonly TableIndexDefinition[];
-}
-interface TableIndexDefinition {
-    readonly name?: string;
-    readonly columns: readonly string[];
-    readonly unique: boolean;
-}
-type ColumnSelectType<TColumn extends AnyColumnDefinition> = TColumn extends ColumnDefinition<infer TValue, infer TNullable, boolean, boolean, boolean> ? TNullable extends true ? TValue | null : TValue : never;
-type ColumnInsertType<TColumn extends AnyColumnDefinition> = TColumn extends ColumnDefinition<infer TValue, infer TNullable, boolean, boolean, boolean> ? TNullable extends true ? TValue | null : TValue : never;
-type OptionalInsertKeys<TColumns extends TableColumnsShape> = {
-    [K in keyof TColumns]: TColumns[K] extends ColumnDefinition<unknown, boolean, infer THasDefault, infer TGenerated, boolean> ? THasDefault extends true ? K : TGenerated extends true ? K : never : never;
-}[keyof TColumns];
-type RequiredInsertKeys<TColumns extends TableColumnsShape> = Exclude<keyof TColumns, OptionalInsertKeys<TColumns>>;
-type InferSelect<TTable extends TableDefinition> = {
-    [K in keyof TTable['columns']]: ColumnSelectType<TTable['columns'][K]>;
-};
-type InferInsert<TTable extends TableDefinition> = {
-    [K in RequiredInsertKeys<TTable['columns']>]: ColumnInsertType<TTable['columns'][K]>;
-} & {
-    [K in OptionalInsertKeys<TTable['columns']>]?: ColumnInsertType<TTable['columns'][K]>;
-};
-type InferUpdate<TTable extends TableDefinition> = Partial<{
-    [K in keyof TTable['columns']]: ColumnInsertType<TTable['columns'][K]>;
-}>;
-
-type EntityConstructor = {
-    new <TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap>(repository: unknown, attributes: Partial<ModelRecord<TTable>>, exists?: boolean): Entity<TTable, TRelations>;
-    prototype: Entity<TableDefinition, RelationMap>;
-};
-
-declare class EntityBase<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> {
-    private readonly repository;
-    private attributes;
-    private original;
-    private changes;
-    private persisted;
-    private relations;
-    private relationLoads;
-    private peerCollection?;
-    private hiddenOverrides;
-    private visibleOverrides;
-    private visibleOnly;
-    private appendedOverrides;
-    constructor(repository: ModelRepositoryLike<TTable, EmptyScopeMap, TRelations>, attributes: Partial<ModelRecord<TTable>>, exists?: boolean);
-    getRepository(): ModelRepositoryLike<TTable>;
-    private getRepositoryRuntime;
-    is(other: unknown): boolean;
-    isNot(other: unknown): boolean;
-    exists(): boolean;
-    trashed(): boolean;
-    get<TKey extends Extract<keyof ModelRecord<TTable>, string>>(key: TKey): ModelRecord<TTable>[TKey];
-    set<TKey extends Extract<keyof ModelRecord<TTable>, string>>(key: TKey, value: ModelRecord<TTable>[TKey]): this;
-    fill(values: Partial<ModelRecord<TTable>>): this;
-    update(values: ModelUpdatePayload<TTable>): Promise<this>;
-    forceFill(values: Partial<ModelRecord<TTable>>): this;
-    isDirty(key?: Extract<keyof ModelRecord<TTable>, string>): boolean;
-    isClean(): boolean;
-    getDirty(): Partial<ModelUpdatePayload<TTable>>;
-    getChanges(): Partial<ModelUpdatePayload<TTable>>;
-    wasChanged(key?: Extract<keyof ModelRecord<TTable>, string>): boolean;
-    syncOriginal(): this;
-    syncChanges(): this;
-    syncPersisted(entity: EntityBase<TTable>, changes?: Record<string, unknown>): this;
-    bindPeerCollection(peers: readonly EntityBase<TTable, TRelations>[]): this;
-    getPeerCollection(): readonly EntityBase<TTable, TRelations>[] | undefined;
-    getPendingRelationLoad(name: string): Promise<unknown> | undefined;
-    setPendingRelationLoad(name: string, load: Promise<unknown>): this;
-    clearPendingRelationLoad(name: string): this;
-    toAttributes(): ModelRecord<TTable>;
-    setRelation(name: string, value: unknown): this;
-    setComputed(name: string, value: unknown): this;
-    makeHidden(...keys: readonly string[]): this;
-    makeVisible(...keys: readonly string[]): this;
-    setHidden(keys: readonly string[]): this;
-    setVisible(keys: readonly string[]): this;
-    append(...keys: readonly string[]): this;
-    setAppends(keys: readonly string[]): this;
-    withoutAppends(): this;
-    getRelation<TRelation = unknown>(name: string): TRelation;
-    hasRelation(name: string): boolean;
-    getLoadedRelations(): Readonly<Record<string, unknown>>;
-    getSerializationConfig(): {
-        readonly hidden: ReadonlySet<string>;
-        readonly visible: ReadonlySet<string>;
-        readonly visibleOnly: readonly string[] | null;
-        readonly appended: readonly string[] | null;
-    };
-    forgetRelation(name: string): this;
-    relation<K extends ModelRelationName<TRelations>>(name: K): RelationMethodsOf<TRelations[K]>;
-    toJSON(): ModelRecord<TTable>;
-    private applyPersistedEntity;
-    private persistEntity;
-    private deletePersistedEntity;
-    private restoreEntity;
-    private forceDeletePersistedEntity;
-    private loadAggregateDefinitions;
-    save(): Promise<this>;
-    push(): Promise<this>;
-    saveQuietly(): Promise<this>;
-    delete(): Promise<void>;
-    deleteQuietly(): Promise<void>;
-    restore(): Promise<this>;
-    restoreQuietly(): Promise<this>;
-    forceDelete(): Promise<void>;
-    forceDeleteQuietly(): Promise<void>;
-    fresh(): Promise<Entity<TTable, TRelations> | undefined>;
-    refresh(): Promise<this>;
-    replicate(except?: readonly string[]): Entity<TTable, TRelations>;
-    load<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<Omit<this, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (this extends {
-        toJSON(): infer R;
-    } ? {
-        toJSON(): R & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    } : {
-        toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    })>;
-    loadMissing<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<Omit<this, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (this extends {
-        toJSON(): infer R;
-    } ? {
-        toJSON(): R & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    } : {
-        toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    })>;
-    loadMorph(relation: ModelRelationName<TRelations>, mapping: ModelMorphLoadMap): Promise<this>;
-    loadCount(...relations: readonly ModelRelationName<TRelations>[]): Promise<this>;
-    loadExists(...relations: readonly ModelRelationName<TRelations>[]): Promise<this>;
-    loadSum<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    loadAvg<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    loadMin<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    loadMax<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    associate<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated> | null): this;
-    dissociate(relation: string): this;
-    saveRelated<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated>): Promise<Entity<TRelated>>;
-    saveManyRelated<TRelated extends TableDefinition>(relation: string, related: readonly Entity<TRelated>[]): Promise<Entity<TRelated>[]>;
-    saveRelatedQuietly<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated>): Promise<Entity<TRelated>>;
-    saveManyRelatedQuietly<TRelated extends TableDefinition>(relation: string, related: readonly Entity<TRelated>[]): Promise<Entity<TRelated>[]>;
-    createRelated(relation: string, values: Record<string, unknown>): Promise<Entity<TableDefinition>>;
-    createManyRelated(relation: string, values: readonly Record<string, unknown>[]): Promise<Entity<TableDefinition>[]>;
-    createRelatedQuietly(relation: string, values: Record<string, unknown>): Promise<Entity<TableDefinition>>;
-    createManyRelatedQuietly(relation: string, values: readonly Record<string, unknown>[]): Promise<Entity<TableDefinition>[]>;
-    attach(relation: string, ids: unknown, attributes?: Record<string, unknown>): Promise<void>;
-    detach(relation: string, ids?: unknown): Promise<number>;
-    sync(relation: string, ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-        updated: unknown[];
-    }>;
-    syncWithoutDetaching(relation: string, ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-        updated: unknown[];
-    }>;
-    updateExistingPivot(relation: string, id: unknown, attributes: Record<string, unknown>): Promise<number>;
-    toggle(relation: string, ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-    }>;
-}
-type ModelRelationMethods<TRelations extends RelationMap> = string extends ModelRelationName<TRelations> ? Record<never, never> : {
-    [K in ModelRelationName<TRelations>]: () => RelationMethodsOf<TRelations[K]>;
-};
-type ModelBase<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = EntityBase<TTable, TRelations> & ModelRecord<TTable> & {
-    relation<K extends ModelRelationName<TRelations>>(name: K): RelationMethodsOf<TRelations[K]>;
-};
-type Entity<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = ModelBase<TTable, TRelations> & ModelRelationMethods<TRelations>;
-declare const Entity: EntityConstructor;
-
-interface FactoryEntityReference<TTable extends TableDefinition = TableDefinition> {
-    attach(relation: string, ids: unknown, attributes?: Record<string, unknown>): Promise<void>;
-    exists(): boolean;
-    get(key: Extract<keyof ModelRecord<TTable>, string>): ModelRecord<TTable>[Extract<keyof ModelRecord<TTable>, string>];
-    set(key: Extract<keyof ModelRecord<TTable>, string>, value: ModelRecord<TTable>[Extract<keyof ModelRecord<TTable>, string>]): FactoryEntityReference<TTable>;
-    getRelation(name: string): unknown;
-    hasRelation(name: string): boolean;
-    setRelation(name: string, value: unknown): FactoryEntityReference<TTable>;
-    toAttributes(): Record<string, unknown>;
-    getRepository(): unknown;
-}
-interface FactoryModelReference<TTable extends TableDefinition = TableDefinition> {
-    readonly definition: {
-        table: TTable;
-        morphClass?: string;
-    };
-    getRepository(): unknown;
-    make(values?: Partial<ModelRecord<TTable>>): FactoryEntityReference<TTable>;
-    create(values?: Partial<ModelRecord<TTable>>): Promise<FactoryEntityReference<TTable>>;
-    getConnectionName?(): string | undefined;
-}
-interface FactoryContext<TModel extends FactoryModelReference = FactoryModelReference> {
-    readonly sequence: number;
-    readonly model: TModel;
-}
-type FactoryAttributes<TModel extends FactoryModelReference> = Partial<ModelRecord<TModel['definition']['table']>>;
-type FactoryDefinition<TModel extends FactoryModelReference> = (context: FactoryContext<TModel>) => FactoryAttributes<TModel> | Promise<FactoryAttributes<TModel>>;
-type FactoryStateDefinition<TModel extends FactoryModelReference> = FactoryAttributes<TModel> | ((attributes: FactoryAttributes<TModel>, context: FactoryContext<TModel>) => FactoryAttributes<TModel> | Promise<FactoryAttributes<TModel>>);
-type FactoryHook<TModel extends FactoryModelReference> = (entity: FactoryEntityReference<TModel['definition']['table']>, context: FactoryContext<TModel>) => void | Promise<void>;
-
-type RelatedEntity = FactoryEntityReference<TableDefinition>;
-type FactorySource = {
-    readonly model: Pick<FactoryModelReference, 'definition' | 'getConnectionName' | 'getRepository'>;
-    getAmount(): number;
-    createOne(sequence?: number, overrides?: Record<string, unknown>): Promise<RelatedEntity>;
-    makeOne(sequence?: number, overrides?: Record<string, unknown>): Promise<RelatedEntity>;
-    createMany(amount?: number, overrides?: Record<string, unknown>): Promise<RelatedEntity[]>;
-    makeMany(amount?: number, overrides?: Record<string, unknown>): Promise<RelatedEntity[]>;
-};
-type ParentRelationSource = FactorySource | RelatedEntity;
-type AttachedRelationSource = FactorySource | RelatedEntity | readonly RelatedEntity[];
-declare class Factory<TModel extends FactoryModelReference = FactoryModelReference> {
-    readonly model: TModel;
-    private readonly definition;
-    private readonly states;
-    private readonly afterMakingHooks;
-    private readonly afterCreatingHooks;
-    private readonly recycledEntities;
-    private readonly parentRelations;
-    private readonly childRelations;
-    private readonly attachedRelations;
-    private readonly amount;
-    constructor(model: TModel, definition: FactoryDefinition<TModel>, options?: {
-        states?: readonly FactoryStateDefinition<TModel>[];
-        afterMakingHooks?: readonly FactoryHook<TModel>[];
-        afterCreatingHooks?: readonly FactoryHook<TModel>[];
-        recycledEntities?: readonly RelatedEntity[];
-        parentRelations?: ReadonlyArray<{
-            relation: string;
-            source: ParentRelationSource;
-        }>;
-        childRelations?: ReadonlyArray<{
-            relation: string;
-            factory: FactorySource;
-        }>;
-        attachedRelations?: ReadonlyArray<{
-            relation: string;
-            source: AttachedRelationSource;
-            pivotAttributes: Record<string, unknown>;
-        }>;
-        amount?: number;
-    });
-    count(amount: number): Factory<TModel>;
-    getAmount(): number;
-    state(definition: FactoryStateDefinition<TModel>): Factory<TModel>;
-    sequence(...definitions: readonly FactoryStateDefinition<TModel>[]): Factory<TModel>;
-    afterMaking(hook: FactoryHook<TModel>): Factory<TModel>;
-    afterCreating(hook: FactoryHook<TModel>): Factory<TModel>;
-    recycle(source: RelatedEntity | readonly RelatedEntity[]): Factory<TModel>;
-    for(source: ParentRelationSource, relation: string): Factory<TModel>;
-    has(factory: FactorySource, relation: string): Factory<TModel>;
-    hasAttached(source: AttachedRelationSource, relation: string, pivotAttributes?: Record<string, unknown>): Factory<TModel>;
-    raw(overrides?: FactoryAttributes<TModel>): Promise<FactoryAttributes<TModel> | FactoryAttributes<TModel>[]>;
-    make(overrides?: FactoryAttributes<TModel>): Promise<Entity<TModel['definition']['table']> | Array<Entity<TModel['definition']['table']>>>;
-    create(overrides?: FactoryAttributes<TModel>): Promise<Entity<TModel['definition']['table']> | Array<Entity<TModel['definition']['table']>>>;
-    makeOne(sequence?: number, overrides?: FactoryAttributes<TModel>): Promise<Entity<TModel['definition']['table']>>;
-    createOne(sequence?: number, overrides?: FactoryAttributes<TModel>): Promise<Entity<TModel['definition']['table']>>;
-    makeMany(amount?: number, overrides?: FactoryAttributes<TModel>): Promise<Array<Entity<TModel['definition']['table']>>>;
-    createMany(amount?: number, overrides?: FactoryAttributes<TModel>): Promise<Array<Entity<TModel['definition']['table']>>>;
-    private clone;
-    private resolveAttributes;
-    private runHooks;
-    private makeContext;
-    private getRepository;
-    private getRelationDefinition;
-    private getPreparedRelationNames;
-    private resolveSingleSource;
-    private resolveManySource;
-    private takeRecycledEntities;
-    private applyParentRelations;
-    private applyChildRelations;
-    private applyAttachedRelations;
-    private makeChildOverrides;
-    private makeMorphChildOverrides;
-    private attachPivotAccessor;
-}
-
-declare class FactoryService {
-    private readonly factories;
-    register<TModel extends FactoryModelReference>(name: string, factory: Factory<TModel>): this;
-    get(name: string): Factory<FactoryModelReference> | undefined;
-    has(name: string): boolean;
-    list(): readonly Factory<FactoryModelReference>[];
-    clear(): void;
-}
-
-type ColumnMetadata = {
-    kind: LogicalColumnKind;
-    name?: string;
-    nullable: boolean;
-    hasDefault: boolean;
-    generated: boolean;
-    primaryKey: boolean;
-    unique: boolean;
-    defaultKind?: ColumnDefaultKind;
-    defaultValue?: unknown;
-    references?: ForeignKeyReference;
-    referenceTable?: string;
-    inferReferenceTable?: boolean;
-    referenceColumn?: string;
-    referenceConstraintName?: string;
-    referenceOnDelete?: ForeignKeyReference['onDelete'];
-    referenceOnUpdate?: ForeignKeyReference['onUpdate'];
-    idStrategy?: IdGenerationStrategy;
-    enumValues?: readonly string[];
-    vectorDimensions?: number;
-};
-type VectorOptions = {
-    dimensions: number;
-};
-type ColumnBuildOptions = {
-    name: string;
-};
-declare class ColumnBuilder<TType, TNullable extends boolean = false, THasDefault extends boolean = false, TGenerated extends boolean = false, TPrimaryKey extends boolean = false> {
-    private readonly metadata;
-    constructor(kind: LogicalColumnKind, name?: string, metadata?: Partial<ColumnMetadata>);
-    notNull(): ColumnBuilder<TType, false, THasDefault, TGenerated, TPrimaryKey>;
-    nullable(): ColumnBuilder<TType, true, THasDefault, TGenerated, TPrimaryKey>;
-    default(value: unknown): ColumnBuilder<TType, TNullable, true, TGenerated, TPrimaryKey>;
-    defaultNow(): ColumnBuilder<TType, TNullable, true, TGenerated, TPrimaryKey>;
-    generated(): ColumnBuilder<TType, TNullable, THasDefault, true, TPrimaryKey>;
-    primaryKey(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, true>;
-    unique(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    references(columnName: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    on(table: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    constraintName(name: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    constrained(table?: string, columnName?: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    onDelete(action: NonNullable<ForeignKeyReference['onDelete']>): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    onUpdate(action: NonNullable<ForeignKeyReference['onUpdate']>): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    cascadeOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    restrictOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    nullOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    noActionOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    cascadeOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    restrictOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    nullOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    noActionOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    toDefinition(options: ColumnBuildOptions): ColumnDefinition<TType, TNullable, THasDefault, TGenerated, TPrimaryKey>;
-    private clone;
-}
-declare const column: {
-    id(name?: string): ColumnBuilder<number, false, false, true, true>;
-    autoIncrementId(name?: string): ColumnBuilder<number, false, false, true, true>;
-    integer(name?: string): ColumnBuilder<number, false, false, false, false>;
-    bigInteger(name?: string): ColumnBuilder<number, false, false, false, false>;
-    string(name?: string): ColumnBuilder<string, false, false, false, false>;
-    text(name?: string): ColumnBuilder<string, false, false, false, false>;
-    boolean(name?: string): ColumnBuilder<boolean, false, false, false, false>;
-    real(name?: string): ColumnBuilder<number, false, false, false, false>;
-    decimal(name?: string): ColumnBuilder<string, false, false, false, false>;
-    date(name?: string): ColumnBuilder<Date, false, false, false, false>;
-    datetime(name?: string): ColumnBuilder<Date, false, false, false, false>;
-    timestamp(name?: string): ColumnBuilder<Date, false, false, false, false>;
-    json<TValue = unknown>(name?: string): ColumnBuilder<TValue, false, false, false, false>;
-    blob(name?: string): ColumnBuilder<Uint8Array<ArrayBufferLike>, false, false, false, false>;
-    uuid(name?: string): ColumnBuilder<string, false, false, false, false>;
-    ulid(name?: string): ColumnBuilder<string, false, false, false, false>;
-    snowflake(name?: string): ColumnBuilder<string, false, false, false, false>;
-    foreignId(name?: string): ColumnBuilder<number, false, false, false, false>;
-    foreignUuid(name?: string): ColumnBuilder<string, false, false, false, false>;
-    foreignUlid(name?: string): ColumnBuilder<string, false, false, false, false>;
-    foreignSnowflake(name?: string): ColumnBuilder<string, false, false, false, false>;
-    vector(options: VectorOptions, name?: string): ColumnBuilder<VectorValue, false, false, false, false>;
-    enum<const TValues extends readonly string[]>(values: TValues, name?: string): ColumnBuilder<TValues[number], false, false, false, false>;
-};
-type AnyColumnBuilder = ColumnBuilder<unknown, boolean, boolean, boolean, boolean>;
-type ColumnInput = AnyColumnBuilder | AnyColumnDefinition;
-
-type ColumnShapeInput$1 = Record<string, ColumnInput>;
-type ResolvedColumn<TColumn extends ColumnInput> = TColumn extends {
-    toDefinition(options: {
-        name: string;
-    }): infer TDefinition;
-} ? TDefinition extends AnyColumnDefinition ? TDefinition : never : TColumn extends AnyColumnDefinition ? TColumn : never;
-type BoundColumns<TColumns extends ColumnShapeInput$1> = {
-    [K in keyof TColumns]: ResolvedColumn<TColumns[K]>;
-};
-type BoundTableDefinition<TName extends string, TColumns extends ColumnShapeInput$1> = TableDefinition<TName, BoundColumns<TColumns>> & BoundColumns<TColumns>;
-
-declare class ForeignKeyBuilderState {
-    private readonly columnName;
-    private referenceTable?;
-    private referenceColumn;
-    private onDeleteAction?;
-    private onUpdateAction?;
-    constructor(columnName: string, referenceColumn?: string);
-    references(columnName: string): void;
-    on(table: string): void;
-    constrained(table?: string, columnName?: string): void;
-    onDelete(action: NonNullable<ForeignKeyReference['onDelete']>): void;
-    onUpdate(action: NonNullable<ForeignKeyReference['onUpdate']>): void;
-    toReference(defaultTable?: string): ForeignKeyReference;
-    applyToColumnBuilder(builder: AnyColumnBuilder): AnyColumnBuilder;
-}
-
-type ColumnShapeInput = Record<string, ColumnInput>;
-type WithColumn<TColumns extends ColumnShapeInput, TColumnName extends string, TColumn extends ColumnInput> = TColumns & {
-    [K in TColumnName]: TColumn;
-};
-type TimestampColumn = ReturnType<typeof column.timestamp>;
-type NullableTimestampColumn = ReturnType<ReturnType<typeof column.timestamp>['nullable']>;
-type StringColumn = ReturnType<typeof column.string>;
-type NullableStringColumn = ReturnType<ReturnType<typeof column.string>['nullable']>;
-type WithTimestamps<TColumns extends ColumnShapeInput> = TColumns & {
-    created_at: TimestampColumn;
-    updated_at: TimestampColumn;
-};
-type WithSoftDeletes<TColumns extends ColumnShapeInput, TColumnName extends string> = TColumns & {
-    [K in TColumnName]: NullableTimestampColumn;
-};
-type WithMorphColumns<TColumns extends ColumnShapeInput, TMorphName extends string, TIdColumn extends AnyColumnBuilder> = TColumns & {
-    [K in `${TMorphName}_type`]: StringColumn;
-} & {
-    [K in `${TMorphName}_id`]: TIdColumn;
-};
-type WithNullableMorphColumns<TColumns extends ColumnShapeInput, TMorphName extends string, TIdColumn extends AnyColumnBuilder> = TColumns & {
-    [K in `${TMorphName}_type`]: NullableStringColumn;
-} & {
-    [K in `${TMorphName}_id`]: ReturnType<TIdColumn['nullable']>;
-};
-type ColumnReference$1 = {
-    builder: AnyColumnBuilder;
-};
-declare class TableCreateColumnBuilder<TName extends string, TColumns extends ColumnShapeInput> {
-    protected readonly root: TableDefinitionBuilder<TName, TColumns>;
-    protected readonly builderRef: ColumnReference$1;
-    protected readonly columnName: string;
-    constructor(root: TableDefinitionBuilder<TName, TColumns>, builderRef: ColumnReference$1, columnName: string);
-    build(): BoundTableDefinition<TName, TColumns>;
-    notNull(): this;
-    nullable(): this;
-    default(value: unknown): this;
-    defaultNow(): this;
-    generated(): this;
-    primaryKey(): this;
-    unique(): this;
-    unique(columns: readonly string[], name?: string): TableDefinitionBuilder<TName, TColumns>;
-    index(): this;
-    index(name: string): this;
-    index(columns: readonly string[], name?: string): TableDefinitionBuilder<TName, TColumns>;
-    foreign(columnName: string): TableCreateForeignKeyBuilder<TName, TColumns>;
-    foreignId<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.bigInteger>>>;
-    foreignUuid<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.uuid>>>;
-    foreignUlid<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.ulid>>>;
-    foreignSnowflake<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.snowflake>>>;
-    id<TColumnName extends string = 'id'>(columnName?: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.id>>>;
-    autoIncrementId<TColumnName extends string = 'id'>(columnName?: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.autoIncrementId>>>;
-    integer<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.integer>>>;
-    bigInteger<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.bigInteger>>>;
-    string<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.string>>>;
-    text<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.text>>>;
-    boolean<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.boolean>>>;
-    real<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.real>>>;
-    decimal<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.decimal>>>;
-    date<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.date>>>;
-    datetime<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.datetime>>>;
-    timestamp<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.timestamp>>>;
-    json<TColumnName extends string, TValue = unknown>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.json<TValue>>>>;
-    blob<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.blob>>>;
-    uuid<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.uuid>>>;
-    ulid<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.ulid>>>;
-    snowflake<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.snowflake>>>;
-    vector<TColumnName extends string>(columnName: TColumnName, options: {
-        dimensions: number;
-    }): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.vector>>>;
-    enum<const TValues extends readonly string[], TColumnName extends string>(columnName: TColumnName, values: TValues): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.enum<TValues>>>>;
-    timestamps(): TableDefinitionBuilder<TName, WithTimestamps<TColumns>>;
-    softDeletes<TColumnName extends string = 'deleted_at'>(columnName?: TColumnName): TableDefinitionBuilder<TName, WithSoftDeletes<TColumns, TColumnName>>;
-    morphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.bigInteger>>>;
-    nullableMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.bigInteger>>>;
-    uuidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.uuid>>>;
-    nullableUuidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.uuid>>>;
-    ulidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.ulid>>>;
-    nullableUlidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.ulid>>>;
-    snowflakeMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.snowflake>>>;
-    nullableSnowflakeMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.snowflake>>>;
-}
-declare class TableCreateForeignIdBuilder<TName extends string, TColumns extends ColumnShapeInput> extends TableCreateColumnBuilder<TName, TColumns> {
-    private readonly foreignKeyState;
-    constructor(root: TableDefinitionBuilder<TName, TColumns>, builderRef: ColumnReference$1, columnName: string);
-    references(columnName: string): this;
-    on(table: string): this;
-    constrained(table?: string, columnName?: string): this;
-    onDelete(action: Parameters<ForeignKeyBuilderState['onDelete']>[0]): this;
-    onUpdate(action: Parameters<ForeignKeyBuilderState['onUpdate']>[0]): this;
-    cascadeOnDelete(): this;
-    restrictOnDelete(): this;
-    nullOnDelete(): this;
-    noActionOnDelete(): this;
-    cascadeOnUpdate(): this;
-    restrictOnUpdate(): this;
-    nullOnUpdate(): this;
-    noActionOnUpdate(): this;
-    private applyReference;
-}
-declare class TableCreateForeignKeyBuilder<TName extends string, TColumns extends ColumnShapeInput> {
-    private readonly root;
-    private readonly builderRef;
-    private readonly foreignKeyState;
-    constructor(root: TableDefinitionBuilder<TName, TColumns>, builderRef: ColumnReference$1, columnName: string);
-    references(columnName: string): this;
-    on(table: string): this;
-    constrained(table?: string, columnName?: string): this;
-    onDelete(action: Parameters<ForeignKeyBuilderState['onDelete']>[0]): this;
-    onUpdate(action: Parameters<ForeignKeyBuilderState['onUpdate']>[0]): this;
-    cascadeOnDelete(): this;
-    restrictOnDelete(): this;
-    nullOnDelete(): this;
-    noActionOnDelete(): this;
-    cascadeOnUpdate(): this;
-    restrictOnUpdate(): this;
-    nullOnUpdate(): this;
-    noActionOnUpdate(): this;
-    build(): BoundTableDefinition<TName, TColumns>;
-    private applyReference;
-}
-declare class TableDefinitionBuilder<TName extends string, TColumns extends ColumnShapeInput = Record<never, never>> {
-    readonly tableName: TName;
-    private readonly columns;
-    private readonly columnRefs;
-    private readonly indexes;
-    constructor(tableName: TName);
-    build(): BoundTableDefinition<TName, TColumns>;
-    id<TColumnName extends string = 'id'>(columnName?: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.id>>>;
-    autoIncrementId<TColumnName extends string = 'id'>(columnName?: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.autoIncrementId>>>;
-    integer<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.integer>>>;
-    bigInteger<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.bigInteger>>>;
-    foreignId<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.bigInteger>>>;
-    foreignUuid<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.uuid>>>;
-    foreignUlid<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.ulid>>>;
-    foreignSnowflake<TColumnName extends string>(columnName: TColumnName): TableCreateForeignIdBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.snowflake>>>;
-    string<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.string>>>;
-    text<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.text>>>;
-    boolean<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.boolean>>>;
-    real<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.real>>>;
-    decimal<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.decimal>>>;
-    date<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.date>>>;
-    datetime<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.datetime>>>;
-    timestamp<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.timestamp>>>;
-    json<TColumnName extends string, TValue = unknown>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.json<TValue>>>>;
-    blob<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.blob>>>;
-    uuid<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.uuid>>>;
-    ulid<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.ulid>>>;
-    snowflake<TColumnName extends string>(columnName: TColumnName): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.snowflake>>>;
-    vector<TColumnName extends string>(columnName: TColumnName, options: {
-        dimensions: number;
-    }): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.vector>>>;
-    enum<const TValues extends readonly string[], TColumnName extends string>(columnName: TColumnName, values: TValues): TableCreateColumnBuilder<TName, WithColumn<TColumns, TColumnName, ReturnType<typeof column.enum<TValues>>>>;
-    index(columns: readonly string[], name?: string): this;
-    unique(columns: readonly string[], name?: string): this;
-    foreign(columnName: string): TableCreateForeignKeyBuilder<TName, TColumns>;
-    timestamps(): TableDefinitionBuilder<TName, WithTimestamps<TColumns>>;
-    softDeletes<TColumnName extends string = 'deleted_at'>(columnName?: TColumnName): TableDefinitionBuilder<TName, WithSoftDeletes<TColumns, TColumnName>>;
-    morphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.bigInteger>>>;
-    nullableMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.bigInteger>>>;
-    uuidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.uuid>>>;
-    nullableUuidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.uuid>>>;
-    ulidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.ulid>>>;
-    nullableUlidMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.ulid>>>;
-    snowflakeMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithMorphColumns<TColumns, TMorphName, ReturnType<typeof column.snowflake>>>;
-    nullableSnowflakeMorphs<TMorphName extends string>(name: TMorphName, indexName?: string): TableDefinitionBuilder<TName, WithNullableMorphColumns<TColumns, TMorphName, ReturnType<typeof column.snowflake>>>;
-    private column;
-    private foreignColumn;
-    private applyMorphColumns;
-}
-
-interface AddColumnMutationOperation {
-    kind: 'addColumn';
-    columnName: string;
-    column: AnyColumnBuilder;
-}
-interface AlterColumnMutationOperation {
-    kind: 'alterColumn';
-    columnName: string;
-    column: AnyColumnBuilder;
-}
-interface DropColumnMutationOperation {
-    kind: 'dropColumn';
-    columnName: string;
-}
-interface RenameColumnMutationOperation {
-    kind: 'renameColumn';
-    fromColumnName: string;
-    toColumnName: string;
-}
-interface CreateIndexMutationOperation {
-    kind: 'createIndex';
-    index: TableIndexDefinition;
-}
-interface DropIndexMutationOperation {
-    kind: 'dropIndex';
-    indexName: string;
-}
-interface RenameIndexMutationOperation {
-    kind: 'renameIndex';
-    fromIndexName: string;
-    toIndexName: string;
-}
-interface CreateForeignKeyMutationOperation {
-    kind: 'createForeignKey';
-    columnName: string;
-    reference: ForeignKeyReference;
-    constraintName?: string;
-}
-interface DropForeignKeyMutationOperation {
-    kind: 'dropForeignKey';
-    constraintName: string;
-}
-interface MutableColumnMutationOperation {
-    kind: ColumnMutationMode;
-    columnName: string;
-    column: AnyColumnBuilder;
-}
-type TableMutationOperation = AddColumnMutationOperation | AlterColumnMutationOperation | DropColumnMutationOperation | RenameColumnMutationOperation | CreateIndexMutationOperation | DropIndexMutationOperation | RenameIndexMutationOperation | CreateForeignKeyMutationOperation | DropForeignKeyMutationOperation;
-type ColumnMutationMode = 'addColumn' | 'alterColumn';
-declare class TableForeignKeyBuilder {
-    private readonly operation;
-    private readonly foreignKeyState;
-    constructor(operation: CreateForeignKeyMutationOperation);
-    references(columnName: string): this;
-    on(table: string): this;
-    constrained(table?: string, columnName?: string): this;
-    onDelete(action: NonNullable<ForeignKeyReference['onDelete']>): this;
-    onUpdate(action: NonNullable<ForeignKeyReference['onUpdate']>): this;
-    cascadeOnDelete(): this;
-    restrictOnDelete(): this;
-    nullOnDelete(): this;
-    noActionOnDelete(): this;
-    cascadeOnUpdate(): this;
-    restrictOnUpdate(): this;
-    nullOnUpdate(): this;
-    noActionOnUpdate(): this;
-    private applyReference;
-}
-declare class TableColumnMutationBuilder {
-    protected readonly root: TableMutationBuilder;
-    protected readonly operation: MutableColumnMutationOperation;
-    constructor(root: TableMutationBuilder, operation: MutableColumnMutationOperation);
-    notNull(): this;
-    nullable(): this;
-    default(value: unknown): this;
-    defaultNow(): this;
-    generated(): this;
-    primaryKey(): this;
-    unique(): this;
-    index(name?: string): this;
-    foreignId(columnName: string): TableForeignIdMutationBuilder;
-    foreignUuid(columnName: string): TableForeignIdMutationBuilder;
-    foreignUlid(columnName: string): TableForeignIdMutationBuilder;
-    foreignSnowflake(columnName: string): TableForeignIdMutationBuilder;
-    change(): this;
-    morphs(name: string, indexName?: string): TableMutationBuilder;
-    nullableMorphs(name: string, indexName?: string): TableMutationBuilder;
-    uuidMorphs(name: string, indexName?: string): TableMutationBuilder;
-    nullableUuidMorphs(name: string, indexName?: string): TableMutationBuilder;
-    ulidMorphs(name: string, indexName?: string): TableMutationBuilder;
-    nullableUlidMorphs(name: string, indexName?: string): TableMutationBuilder;
-    snowflakeMorphs(name: string, indexName?: string): TableMutationBuilder;
-    nullableSnowflakeMorphs(name: string, indexName?: string): TableMutationBuilder;
-}
-declare class TableForeignIdMutationBuilder extends TableColumnMutationBuilder {
-    private readonly operations;
-    private readonly columnName;
-    private readonly foreignKeyState;
-    private foreignOperation?;
-    constructor(root: TableMutationBuilder, operation: MutableColumnMutationOperation, operations: TableMutationOperation[], columnName: string);
-    references(columnName: string): this;
-    on(table: string): this;
-    constrained(table?: string, columnName?: string): this;
-    onDelete(action: NonNullable<ForeignKeyReference['onDelete']>): this;
-    onUpdate(action: NonNullable<ForeignKeyReference['onUpdate']>): this;
-    cascadeOnDelete(): this;
-    restrictOnDelete(): this;
-    nullOnDelete(): this;
-    noActionOnDelete(): this;
-    cascadeOnUpdate(): this;
-    restrictOnUpdate(): this;
-    nullOnUpdate(): this;
-    noActionOnUpdate(): this;
-    private applyForeignKey;
-    private ensureForeignOperation;
-}
-declare class TableMutationBuilder {
-    readonly table: string;
-    private readonly operations;
-    constructor(table: string);
-    getOperations(): readonly TableMutationOperation[];
-    id(columnName: string): TableColumnMutationBuilder;
-    autoIncrementId(columnName: string): TableColumnMutationBuilder;
-    integer(columnName: string): TableColumnMutationBuilder;
-    bigInteger(columnName: string): TableColumnMutationBuilder;
-    foreignId(columnName: string): TableForeignIdMutationBuilder;
-    foreignUuid(columnName: string): TableForeignIdMutationBuilder;
-    foreignUlid(columnName: string): TableForeignIdMutationBuilder;
-    foreignSnowflake(columnName: string): TableForeignIdMutationBuilder;
-    string(columnName: string): TableColumnMutationBuilder;
-    text(columnName: string): TableColumnMutationBuilder;
-    boolean(columnName: string): TableColumnMutationBuilder;
-    real(columnName: string): TableColumnMutationBuilder;
-    decimal(columnName: string): TableColumnMutationBuilder;
-    date(columnName: string): TableColumnMutationBuilder;
-    datetime(columnName: string): TableColumnMutationBuilder;
-    timestamp(columnName: string): TableColumnMutationBuilder;
-    json<TValue = unknown>(columnName: string): TableColumnMutationBuilder;
-    blob(columnName: string): TableColumnMutationBuilder;
-    uuid(columnName: string): TableColumnMutationBuilder;
-    ulid(columnName: string): TableColumnMutationBuilder;
-    snowflake(columnName: string): TableColumnMutationBuilder;
-    vector(columnName: string, options: {
-        dimensions: number;
-    }): TableColumnMutationBuilder;
-    enum<const TValues extends readonly string[]>(columnName: string, values: TValues): TableColumnMutationBuilder;
-    dropColumn(columnName: string): void;
-    renameColumn(fromColumnName: string, toColumnName: string): void;
-    index(columns: readonly string[], name?: string): void;
-    unique(columns: readonly string[], name?: string): void;
-    dropIndex(indexName: string): void;
-    renameIndex(fromIndexName: string, toIndexName: string): void;
-    foreign(columnName: string, constraintName?: string): TableForeignKeyBuilder;
-    dropForeign(indexName: string): void;
-    morphs(name: string, indexName?: string): this;
-    nullableMorphs(name: string, indexName?: string): this;
-    uuidMorphs(name: string, indexName?: string): this;
-    nullableUuidMorphs(name: string, indexName?: string): this;
-    ulidMorphs(name: string, indexName?: string): this;
-    nullableUlidMorphs(name: string, indexName?: string): this;
-    snowflakeMorphs(name: string, indexName?: string): this;
-    nullableSnowflakeMorphs(name: string, indexName?: string): this;
-    private columnMutation;
-    private foreignColumn;
-    private applyMorphColumns;
-}
-
-interface IntrospectedColumn {
-    name: string;
-    type: string;
-    logicalType: LogicalColumnKind | null;
-    notNull: boolean;
-    defaultValue: string | null;
-    primaryKey: boolean;
-}
-interface IntrospectedIndex {
-    name: string;
-    unique: boolean;
-    columns: string[];
-}
-interface IntrospectedForeignKey {
-    table: string;
-    from: string;
-    to: string;
-    onUpdate: string;
-    onDelete: string;
-}
-interface SchemaSyncPlan {
-    readonly mode: 'create_missing_only';
-    readonly tablesToCreate: readonly string[];
-    readonly existingTables: readonly string[];
-    readonly destructiveChanges: false;
-}
-declare class SchemaService {
-    private readonly connection;
-    constructor(connection: DatabaseContext);
-    getDialectName(): string;
-    register<TTable extends TableDefinition>(table: TTable): TTable;
-    createTable<TName extends string>(tableName: TName, callback: (table: TableDefinitionBuilder<TName>) => void | Promise<void>): Promise<void>;
-    dropTable(tableName: string): Promise<void>;
-    renameTable(fromTableName: string, toTableName: string): Promise<void>;
-    table(tableName: string, callback: (table: TableMutationBuilder) => void | Promise<void>): Promise<void>;
-    enableForeignKeyConstraints(): Promise<void>;
-    disableForeignKeyConstraints(): Promise<void>;
-    withoutForeignKeyConstraints<TResult>(callback: () => TResult | Promise<TResult>): Promise<TResult>;
-    sync(tables?: readonly TableDefinition[]): Promise<void>;
-    previewSync(tables?: readonly TableDefinition[]): Promise<SchemaSyncPlan>;
-    hasTable(name: string): Promise<boolean>;
-    getTables(): Promise<string[]>;
-    getColumns(tableName: string): Promise<IntrospectedColumn[]>;
-    getIndexes(tableName: string): Promise<IntrospectedIndex[]>;
-    getForeignKeys(tableName: string): Promise<IntrospectedForeignKey[]>;
-    private createCompiler;
-    private execute;
-    private isSqlite;
-    private isPostgres;
-    private isMySQL;
-    private parsePostgresIndex;
-    private unsupportedIntrospectionError;
-    private assertAlterCapability;
-    private assertForeignKeyCapability;
-    private resolveColumnDefinition;
-    private createDefinedTable;
-    private assertTableMutationIndexNames;
-    private executeTableMutation;
-    private buildTableDefinition;
-    private updateRegisteredTable;
-    private renameRegisteredTable;
-    private withColumn;
-    private withAlteredColumn;
-    private withoutColumn;
-    private renameRegisteredColumn;
-    private withIndex;
-    private withoutIndex;
-    private renameRegisteredIndex;
-    private withForeignKey;
-    private withoutForeignKey;
-    private resolveIndexName;
-    private resolveForeignKeyName;
-    private createForeignKeyConstraintStatement;
-    private inferLogicalColumnType;
-}
-
-interface MigrationContext {
-    readonly db: DatabaseContext;
-    readonly schema: SchemaService;
-}
-interface MigrationDefinition {
-    readonly name?: string;
-    up(context: MigrationContext): unknown | Promise<unknown>;
-    down?(context: MigrationContext): unknown | Promise<unknown>;
-}
-interface MigrationStatus {
-    readonly name: string;
-    readonly status: 'pending' | 'ran';
-    readonly batch?: number;
-    readonly migratedAt?: Date;
-}
-interface MigrationSquashPlan {
-    readonly archiveName: string;
-    readonly includedMigrations: readonly string[];
-    readonly fromBatch?: number;
-    readonly toBatch?: number;
-    readonly ranCount: number;
-}
-interface MigrateOptions {
-    step?: number;
-}
-interface RollbackOptions {
-    step?: number;
-    batch?: number;
-}
-interface MigrationExecutionPolicy {
-    readonly mode: 'exclusive';
-    readonly scope: 'adapter';
-    readonly allowsConcurrentMigrations: false;
-}
-
-type RegisteredMigrationDefinition = MigrationDefinition & {
-    readonly name: string;
-};
-declare class MigrationService {
-    private readonly connection;
-    private readonly migrations;
-    constructor(connection: DatabaseContext, migrations?: readonly MigrationDefinition[]);
-    register(migration: MigrationDefinition): this;
-    getMigrations(): readonly RegisteredMigrationDefinition[];
-    getMigration(name: string): RegisteredMigrationDefinition | undefined;
-    hasRan(name: string): Promise<boolean>;
-    status(): Promise<MigrationStatus[]>;
-    planSquash(archiveName?: string): Promise<MigrationSquashPlan>;
-    migrate(options?: MigrateOptions): Promise<RegisteredMigrationDefinition[]>;
-    rollback(options?: RollbackOptions): Promise<RegisteredMigrationDefinition[]>;
-    getExecutionPolicy(): MigrationExecutionPolicy;
-    private ensureTrackingTable;
-    private getRanRecords;
-    private createContext;
-    private runMigrationLifecycle;
-    private normalizeMigratedAt;
-    private createMigrationLog;
-    private runExclusively;
-}
-
-declare class ModelEventService {
-    areEventsMuted(): boolean;
-    withoutEvents<T>(callback: () => T | Promise<T>): Promise<T>;
-    areGuardsDisabled(): boolean;
-    withoutGuards<T>(callback: () => T | Promise<T>): Promise<T>;
-}
-
-interface SecurityPolicy {
-    allowUnsafeRawSql: boolean;
-    debugSqlInLogs: boolean;
-    maxQueryComplexity?: number;
-    redactBindingsInLogs: boolean;
-    maxLoggedBindings: number;
-}
-
-declare class SchemaRegistry {
-    private readonly tables;
-    register<TTable extends TableDefinition>(table: TTable): TTable;
-    has(name: string): boolean;
-    replace<TTable extends TableDefinition>(table: TTable): TTable;
-    delete(name: string): void;
-    get<TTable extends TableDefinition = TableDefinition>(name: string): TTable | undefined;
-    list(): TableDefinition[];
-    clear(): void;
-}
-
-declare class ModelRegistry {
-    private readonly models;
-    register(reference: ModelDefinitionLike): AnyModelDefinition;
-    has(name: string): boolean;
-    get(name: string): AnyModelDefinition | undefined;
-    list(): readonly AnyModelDefinition[];
-    clear(): void;
-}
-
-type SchedulingMode = 'concurrent' | 'serialized' | 'worker';
-interface QuerySchedulerOptions {
-    connectionName: string;
-    supportsConcurrentQueries: boolean;
-    supportsWorkerThreads: boolean;
-    concurrency?: ConcurrencyOptions;
-}
-declare class QueryScheduler {
-    private readonly connectionName;
-    private readonly queueLimit;
-    private readonly supportsConcurrentQueries;
-    private readonly supportsWorkerThreads;
-    private readonly concurrentState;
-    private readonly serializedState;
-    private readonly workerState;
-    constructor(options: QuerySchedulerOptions);
-    schedule<T>(options: {
-        transactional: boolean;
-        preferWorkerThreads?: boolean;
-    }, callback: (schedulingMode: SchedulingMode) => Promise<T>): Promise<{
-        result: T;
-        schedulingMode: SchedulingMode;
-    }>;
-    preview(options: {
-        transactional: boolean;
-        preferWorkerThreads?: boolean;
-    }): SchedulingMode;
-    private resolveMode;
-    private resolveState;
-    private waitForSlot;
-    private wakeNext;
-}
-
-type DatabaseDriverName = 'sqlite' | 'postgres' | 'mysql' | string;
-type TransactionScopeKind = 'root' | 'transaction' | 'savepoint';
-interface ConcurrencyOptions {
-    maxConcurrentQueries?: number;
-    queueLimit?: number;
-    workerThreads?: boolean;
-}
-interface DatabaseOperationOptions {
-    signal?: AbortSignal;
-    timeoutMs?: number;
-}
-type TransactionCallback = () => void | Promise<void>;
-interface UnsafeStatement {
-    unsafe: true;
-    sql: string;
-    bindings?: readonly unknown[];
-    source?: string;
-}
-type CompiledQueryKind = 'select' | 'insert' | 'update' | 'upsert' | 'delete';
-type CompiledQueryResultMode = 'rows' | 'write';
-type CompiledQueryIntent = 'read' | 'write';
-type CompiledQueryStreamingMode = 'buffered';
-type CompiledQueryTransactionAffinity = 'optional' | 'required';
-interface CompiledStatementMetadata {
-    kind: CompiledQueryKind;
-    resultMode: CompiledQueryResultMode;
-    selectedShape: {
-        mode: 'all' | 'projection' | 'write';
-        columns: readonly string[];
-        aggregates: readonly string[];
-        hasRawSelections: boolean;
-        hasSubqueries: boolean;
-    };
-    safety: {
-        unsafe: boolean;
-        containsRawSql: boolean;
-    };
-    debug: {
-        tableName: string;
-        hasJoins: boolean;
-        hasUnions: boolean;
-        hasGrouping: boolean;
-        hasHaving: boolean;
-        complexity: number;
-        lockMode?: string;
-        intent: CompiledQueryIntent;
-        transactionAffinity: CompiledQueryTransactionAffinity;
-        streaming: CompiledQueryStreamingMode;
-        connectionName?: string;
-        scope?: TransactionScopeKind;
-        schedulingMode?: SchedulingMode;
-    };
-}
-interface CompiledStatement {
-    unsafe?: true;
-    sql: string;
-    bindings?: readonly unknown[];
-    source?: string;
-    metadata?: CompiledStatementMetadata;
-}
-interface DriverQueryResult<TRow extends Record<string, unknown> = Record<string, unknown>> {
-    rows: TRow[];
-    rowCount: number;
-}
-interface DriverExecutionResult {
-    affectedRows?: number;
-    lastInsertId?: number | string;
-}
-interface DriverAdapter {
-    initialize(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    runWithTransactionScope?<T>(callback: () => Promise<T>): Promise<T>;
-    introspect?<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
-    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
-    execute(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
-    beginTransaction(options?: DatabaseOperationOptions): Promise<void>;
-    commit(options?: DatabaseOperationOptions): Promise<void>;
-    rollback(options?: DatabaseOperationOptions): Promise<void>;
-    createSavepoint?(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    rollbackToSavepoint?(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    releaseSavepoint?(name: string, options?: DatabaseOperationOptions): Promise<void>;
-}
-interface Dialect {
-    readonly name: string;
-    readonly capabilities: DatabaseCapabilities;
-    quoteIdentifier(identifier: string): string;
-    createPlaceholder(index: number): string;
-}
-interface QueryStartLog {
-    kind: 'query' | 'execute';
-    connectionName: string;
-    sql: string;
-    bindings: unknown[];
-    source?: string;
-    scope: TransactionScopeKind;
-    schedulingMode?: 'concurrent' | 'serialized' | 'worker';
-}
-interface QuerySuccessLog extends QueryStartLog {
-    durationMs: number;
-    rowCount?: number;
-    affectedRows?: number;
-}
-interface QueryErrorLog extends QueryStartLog {
-    durationMs: number;
-    error: unknown;
-}
-interface TransactionLog {
-    scope: Exclude<TransactionScopeKind, 'root'>;
-    depth: number;
-    savepointName?: string;
-}
-interface MigrationStartLog {
-    connectionName: string;
-    migrationName: string;
-    action: 'up' | 'down';
-    batch?: number;
-}
-interface MigrationSuccessLog extends MigrationStartLog {
-    durationMs: number;
-}
-interface MigrationErrorLog extends MigrationStartLog {
-    durationMs: number;
-    error: unknown;
-}
-interface SeederStartLog {
-    connectionName: string;
-    seederName: string;
-    quietly: boolean;
-    environment?: string;
-}
-interface SeederSuccessLog extends SeederStartLog {
-    durationMs: number;
-}
-interface SeederErrorLog extends SeederStartLog {
-    durationMs: number;
-    error: unknown;
-}
-interface DatabaseLogger {
-    onQueryStart?(entry: QueryStartLog): void | Promise<void>;
-    onQuerySuccess?(entry: QuerySuccessLog): void | Promise<void>;
-    onQueryError?(entry: QueryErrorLog): void | Promise<void>;
-    onTransactionStart?(entry: TransactionLog): void | Promise<void>;
-    onTransactionCommit?(entry: TransactionLog): void | Promise<void>;
-    onTransactionRollback?(entry: TransactionLog & {
-        error?: unknown;
-    }): void | Promise<void>;
-    onMigrationStart?(entry: MigrationStartLog): void | Promise<void>;
-    onMigrationSuccess?(entry: MigrationSuccessLog): void | Promise<void>;
-    onMigrationError?(entry: MigrationErrorLog): void | Promise<void>;
-    onSeederStart?(entry: SeederStartLog): void | Promise<void>;
-    onSeederSuccess?(entry: SeederSuccessLog): void | Promise<void>;
-    onSeederError?(entry: SeederErrorLog): void | Promise<void>;
-}
-interface DatabaseContextOptions {
-    connectionName?: string;
-    schemaName?: string;
-    adapter: DriverAdapter;
-    dialect: Dialect;
-    driver?: DatabaseDriverName;
-    logger?: DatabaseLogger;
-    security?: Partial<SecurityPolicy>;
-    concurrency?: ConcurrencyOptions;
-    schemaRegistry?: SchemaRegistry;
-    modelRegistry?: ModelRegistry;
-}
-
-type QueryOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'between' | 'not between' | 'like';
-type QueryDirection = 'asc' | 'desc';
-type QueryLockMode = 'update' | 'share';
-type QueryJoinType = 'inner' | 'left' | 'right' | 'cross';
-interface QuerySource {
-    readonly kind: 'table';
-    readonly tableName: string;
-    readonly alias?: string;
-    readonly table?: TableDefinition;
-}
-interface QueryColumnSelection {
-    readonly kind: 'column';
-    readonly column: string;
-    readonly alias?: string;
-}
-interface QueryAggregateSelection {
-    readonly kind: 'aggregate';
-    readonly aggregate: 'count' | 'sum' | 'avg' | 'min' | 'max';
-    readonly column: string | '*';
-    readonly alias: string;
-}
-interface QueryRawSelection {
-    readonly kind: 'raw';
-    readonly sql: string;
-    readonly bindings: readonly unknown[];
-}
-interface QuerySubquerySelection {
-    readonly kind: 'subquery';
-    readonly query: SelectQueryPlan;
-    readonly alias: string;
-}
-type QuerySelection = QueryColumnSelection | QueryAggregateSelection | QueryRawSelection | QuerySubquerySelection;
-interface QueryJoinClause {
-    readonly type: QueryJoinType;
-    readonly table?: string;
-    readonly subquery?: SelectQueryPlan;
-    readonly alias?: string;
-    readonly lateral?: boolean;
-    readonly leftColumn?: string;
-    readonly operator?: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>;
-    readonly rightColumn?: string;
-}
-interface QueryUnionClause {
-    readonly all: boolean;
-    readonly query: SelectQueryPlan;
-}
-interface QueryHavingClause {
-    readonly expression: string;
-    readonly operator: Exclude<QueryOperator, 'in' | 'not in'>;
-    readonly value: unknown;
-}
-interface QueryPredicate {
-    readonly kind: 'comparison';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly operator: QueryOperator;
-    readonly value: unknown;
-}
-interface QueryColumnPredicate {
-    readonly kind: 'column';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>;
-    readonly compareTo: string;
-}
-interface QueryNullPredicate {
-    readonly kind: 'null';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly negated: boolean;
-}
-type QueryDatePart = 'date' | 'month' | 'day' | 'year' | 'time';
-interface QueryDatePredicate {
-    readonly kind: 'date';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly part: QueryDatePart;
-    readonly operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>;
-    readonly value: unknown;
-}
-type QueryJsonMode = 'value' | 'contains' | 'length';
-type QueryFullTextMode = 'natural' | 'boolean';
-interface QueryJsonPredicate {
-    readonly kind: 'json';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly path: readonly string[];
-    readonly jsonMode: QueryJsonMode;
-    readonly operator?: Exclude<QueryOperator, 'in' | 'not in'>;
-    readonly value: unknown;
-}
-interface QueryFullTextPredicate {
-    readonly kind: 'fulltext';
-    readonly boolean?: 'and' | 'or';
-    readonly columns: readonly string[];
-    readonly mode: QueryFullTextMode;
-    readonly value: string;
-}
-interface QueryVectorPredicate {
-    readonly kind: 'vector';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly vector: readonly number[];
-    readonly minSimilarity: number;
-}
-interface QueryGroupPredicate {
-    readonly kind: 'group';
-    readonly boolean?: 'and' | 'or';
-    readonly negated?: boolean;
-    readonly predicates: readonly QueryPredicateNode[];
-}
-interface QueryExistsPredicate {
-    readonly kind: 'exists';
-    readonly boolean?: 'and' | 'or';
-    readonly negated?: boolean;
-    readonly subquery: SelectQueryPlan;
-}
-interface QuerySubqueryPredicate {
-    readonly kind: 'subquery';
-    readonly boolean?: 'and' | 'or';
-    readonly column: string;
-    readonly operator: Exclude<QueryOperator, 'between' | 'not between'>;
-    readonly subquery: SelectQueryPlan;
-}
-interface QueryRawPredicate {
-    readonly kind: 'raw';
-    readonly boolean?: 'and' | 'or';
-    readonly sql: string;
-    readonly bindings: readonly unknown[];
-}
-type QueryPredicateNode = QueryPredicate | QueryColumnPredicate | QueryNullPredicate | QueryDatePredicate | QueryJsonPredicate | QueryFullTextPredicate | QueryVectorPredicate | QueryGroupPredicate | QueryExistsPredicate | QuerySubqueryPredicate | QueryRawPredicate;
-type QueryOrderBy = {
-    readonly kind: 'column';
-    readonly column: string;
-    readonly direction: QueryDirection;
-} | {
-    readonly kind: 'vector';
-    readonly column: string;
-    readonly vector: readonly number[];
-} | {
-    readonly kind: 'random';
-} | {
-    readonly kind: 'raw';
-    readonly sql: string;
-    readonly bindings: readonly unknown[];
-};
-interface SelectQueryPlan {
-    readonly kind: 'select';
-    readonly source: QuerySource;
-    readonly distinct: boolean;
-    readonly selections: readonly QuerySelection[];
-    readonly joins: readonly QueryJoinClause[];
-    readonly unions: readonly QueryUnionClause[];
-    readonly predicates: readonly QueryPredicateNode[];
-    readonly groupBy: readonly string[];
-    readonly having: readonly QueryHavingClause[];
-    readonly orderBy: readonly QueryOrderBy[];
-    readonly lockMode?: QueryLockMode;
-    readonly limit?: number;
-    readonly offset?: number;
-}
-
-type QueryCacheTtlInput = number | Date;
-type QueryCacheFlexibleTtlInput = readonly [fresh: number, stale: number] | {
-    readonly fresh: number;
-    readonly stale: number;
-};
-interface QueryCacheConfig {
-    readonly ttl?: QueryCacheTtlInput;
-    readonly key?: string;
-    readonly driver?: string;
-    readonly flexible?: QueryCacheFlexibleTtlInput;
-    readonly invalidate?: readonly string[];
-}
-interface NormalizedQueryCacheConfig extends QueryCacheConfig {
-}
-
-interface PaginationMeta {
-    readonly total: number;
-    readonly perPage: number;
-    readonly pageName: string;
-    readonly currentPage: number;
-    readonly lastPage: number;
-    readonly from: number | null;
-    readonly to: number | null;
-    readonly hasMorePages: boolean;
-}
-interface PaginatorMethods<T> {
-    items(): readonly T[];
-    firstItem(): number | null;
-    lastItem(): number | null;
-    hasPages(): boolean;
-    hasMorePages(): boolean;
-    getPageName(): string;
-    toJSON(): {
-        data: readonly T[];
-        meta: PaginationMeta;
-    };
-}
-interface SimplePaginationMeta {
-    readonly perPage: number;
-    readonly pageName: string;
-    readonly currentPage: number;
-    readonly from: number | null;
-    readonly to: number | null;
-    readonly hasMorePages: boolean;
-}
-interface SimplePaginatorMethods<T> {
-    items(): readonly T[];
-    firstItem(): number | null;
-    lastItem(): number | null;
-    hasPages(): boolean;
-    hasMorePages(): boolean;
-    getPageName(): string;
-    toJSON(): {
-        data: readonly T[];
-        meta: SimplePaginationMeta;
-    };
-}
-interface PaginatedResult<T> extends PaginatorMethods<T> {
-    readonly data: readonly T[];
-    readonly meta: PaginationMeta;
-}
-interface SimplePaginatedResult<T> extends SimplePaginatorMethods<T> {
-    readonly data: readonly T[];
-    readonly meta: SimplePaginationMeta;
-}
-interface CursorPaginatorMethods<T> {
-    items(): readonly T[];
-    hasMorePages(): boolean;
-    getCursorName(): string;
-    nextCursorToken(): string | null;
-    previousCursorToken(): string | null;
-    toJSON(): {
-        data: readonly T[];
-        perPage: number;
-        cursorName: string;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    };
-}
-interface CursorPaginatedResult<T> extends CursorPaginatorMethods<T> {
-    readonly data: readonly T[];
-    readonly perPage: number;
-    readonly cursorName: string;
-    readonly nextCursor: string | null;
-    readonly prevCursor: string | null;
-}
-interface PaginationOptions {
-    readonly pageName?: string;
-}
-interface CursorPaginationOptions {
-    readonly cursorName?: string;
-}
-
-type BuilderCallback$1<TBuilder> = (query: TBuilder) => unknown;
-type ValueBuilderCallback$1<TBuilder, TValue> = (query: TBuilder, value: TValue) => unknown;
-type RelationConstraint$1 = (query: ModelQueryBuilder<TableDefinition>) => unknown;
-type SubqueryBuilder<TSubTable extends TableDefinition = TableDefinition> = TableQueryBuilder<TSubTable, Record<string, unknown>> | ModelQueryBuilder<TSubTable>;
-type RelationFilter$1 = {
-    relation: string;
-    negate: boolean;
-    constraint?: RelationConstraint$1;
-    boolean?: 'and' | 'or';
-    morphTypes?: readonly string[];
-};
-type MorphEntityTarget = {
-    exists(): boolean;
-    getRepository(): {
-        definition: {
-            morphClass: string;
-            primaryKey: string;
-        };
-    };
-    get(key: string): unknown;
-};
-type MorphModelTarget = {
-    definition?: {
-        morphClass?: string;
-    };
-};
-type MorphRelationTypeInput = string | MorphModelTarget | readonly (string | MorphModelTarget)[];
-type MorphTypeSelector = string | MorphModelTarget | MorphEntityTarget | null;
-type EagerLoad$1 = {
-    relation: string;
-    constraint?: RelationConstraint$1;
-};
-type AggregateLoad$1 = {
-    relation: string;
-    kind: 'count' | 'exists' | 'sum' | 'avg' | 'min' | 'max';
-    constraint?: RelationConstraint$1;
-    column?: string;
-    alias?: string;
-};
-declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap, TLoaded = unknown> {
-    private readonly repository;
-    private readonly tableQuery;
-    private readonly eagerLoads;
-    private readonly relationFilters;
-    private readonly aggregateLoads;
-    private readonly queryCasts;
-    constructor(repository: ModelRepository<TTable>, tableQuery: TableQueryBuilder<TTable, Record<string, unknown>>, eagerLoads?: readonly EagerLoad$1[], relationFilters?: readonly RelationFilter$1[], aggregateLoads?: readonly AggregateLoad$1[], queryCasts?: Readonly<Record<string, ModelCastDefinition>>);
-    getConnection(): DatabaseContext;
-    getConnectionName(): string;
-    getTableQueryBuilder(): TableQueryBuilder<TTable, Record<string, unknown>>;
-    private collectNestedPredicates;
-    private replayNestedPredicates;
-    from(table: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    where(callback: BuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    where(column: ModelColumnName<TTable> | ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhere(callback: BuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhere(column: ModelColumnName<TTable> | ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNot(callback: BuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereNot(callback: BuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNotExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereNotExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'like', subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'like', subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereInSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNotInSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNotNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereNotNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    when<TValue>(value: TValue, callback: ValueBuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>, TValue>, defaultCallback?: ValueBuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>, TValue>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    unless<TValue>(value: TValue, callback: ValueBuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>, TValue>, defaultCallback?: ValueBuilderCallback$1<ModelQueryBuilder<TTable, TRelations, TLoaded>, TValue>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orderBy(column: ModelColumnName<TTable>, direction?: 'asc' | 'desc'): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    latest(column?: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    oldest(column?: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    inRandomOrder(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    reorder(column?: ModelColumnName<TTable>, direction?: 'asc' | 'desc'): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    lock(mode: 'update' | 'share'): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    lockForUpdate(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    sharedLock(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withoutGlobalScope(name: string): ModelQueryBuilder<TTable, TRelations>;
-    withoutGlobalScopes(names?: readonly string[]): ModelQueryBuilder<TTable, TRelations>;
-    limit(value?: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    offset(value?: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    skip(value: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    take(value: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    forPage(page: number, perPage?: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    select(...columns: readonly ModelSelectableColumn<TTable>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    addSelect(...columns: readonly ModelSelectableColumn<TTable>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    selectSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    addSelectSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    distinct(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withCasts(casts: Record<string, ModelCastDefinition>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereColumn(column: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', compareTo: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereIn(column: ModelColumnName<TTable>, values: readonly unknown[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNotIn(column: ModelColumnName<TTable>, values: readonly unknown[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereBetween(column: ModelColumnName<TTable>, range: readonly [unknown, unknown]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNotBetween(column: ModelColumnName<TTable>, range: readonly [unknown, unknown]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereLike(column: ModelColumnName<TTable>, pattern: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereLike(column: ModelColumnName<TTable>, pattern: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereAny(columns: readonly ModelColumnName<TTable>[], operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereAll(columns: readonly ModelColumnName<TTable>[], operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNone(columns: readonly ModelColumnName<TTable>[], operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    join(table: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    leftJoin(table: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    rightJoin(table: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    crossJoin(table: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    joinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    leftJoinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    rightJoinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    joinLateral<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    leftJoinLateral<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    union<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    unionAll<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    groupBy(...columns: readonly ModelColumnName<TTable>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    having(expression: string, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    havingBetween(expression: string, range: readonly [unknown, unknown]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    unsafeWhere(sql: string, bindings: readonly unknown[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orUnsafeWhere(sql: string, bindings: readonly unknown[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereDate(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereMonth(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereDay(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereYear(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereTime(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereJson(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereJson(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereJsonContains(columnPath: ModelJsonColumnPath<TTable>, value: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereJsonContains(columnPath: ModelJsonColumnPath<TTable>, value: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereJsonLength(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereJsonLength(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereFullText(columns: ModelColumnName<TTable> | readonly ModelColumnName<TTable>[], value: string, options?: {
-        mode?: 'natural' | 'boolean';
-    }): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereFullText(columns: ModelColumnName<TTable> | readonly ModelColumnName<TTable>[], value: string, options?: {
-        mode?: 'natural' | 'boolean';
-    }): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereVectorSimilarTo(column: ModelColumnName<TTable>, vector: readonly number[], minSimilarity?: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereVectorSimilarTo(column: ModelColumnName<TTable>, vector: readonly number[], minSimilarity?: number): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    unsafeOrderBy(sql: string, bindings: readonly unknown[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    with<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, TPaths>>;
-    with<TPath extends ModelRelationPath<TRelations>>(relation: TPath, constraint: RelationConstraint$1): ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, readonly [TPath]>>;
-    with(relations: Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    with<TPaths extends readonly ModelRelationPath<TRelations>[]>(relations: TPaths): ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, TPaths>>;
-    has(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orHas(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereHas(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereHas(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    doesntHave(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orDoesntHave(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereDoesntHave(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereDoesntHave(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: MorphRelationTypeInput, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: MorphRelationTypeInput, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereBelongsTo<TRelated extends TableDefinition, TRelatedRelations extends RelationMap = RelationMap>(relatedEntity: Entity<TRelated, TRelatedRelations>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereBelongsTo<TRelated extends TableDefinition, TRelatedRelations extends RelationMap = RelationMap>(relatedEntity: Entity<TRelated, TRelatedRelations>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereNotMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereNotMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withWhereHas<TPath extends ModelRelationPath<TRelations>>(relation: TPath, constraint?: RelationConstraint$1): ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, readonly [TPath]>>;
-    withCount(...relations: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withCount(relations: Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withExists(...relations: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withExists(relations: Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withSum<TRelationPath extends ModelRelationPath<TRelations>>(first: TRelationPath | Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withAvg<TRelationPath extends ModelRelationPath<TRelations>>(first: TRelationPath | Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withMin<TRelationPath extends ModelRelationPath<TRelations>>(first: TRelationPath | Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withMax<TRelationPath extends ModelRelationPath<TRelations>>(first: TRelationPath | Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint$1>>>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    toSQL(): CompiledStatement;
-    debug(): {
-        bindings: unknown[];
-        connectionName: string;
-        scope: TransactionScopeKind;
-        schedulingMode: "concurrent" | "serialized" | "worker";
-        metadata: {
-            debug: {
-                connectionName: string;
-                scope: TransactionScopeKind;
-                schedulingMode: "concurrent" | "serialized" | "worker";
-                tableName: string;
-                hasJoins: boolean;
-                hasUnions: boolean;
-                hasGrouping: boolean;
-                hasHaving: boolean;
-                complexity: number;
-                lockMode?: string;
-                intent: CompiledQueryIntent;
-                transactionAffinity: CompiledQueryTransactionAffinity;
-                streaming: CompiledQueryStreamingMode;
-            };
-            kind: CompiledQueryKind;
-            resultMode: CompiledQueryResultMode;
-            selectedShape: {
-                mode: "all" | "projection" | "write";
-                columns: readonly string[];
-                aggregates: readonly string[];
-                hasRawSelections: boolean;
-                hasSubqueries: boolean;
-            };
-            safety: {
-                unsafe: boolean;
-                containsRawSql: boolean;
-            };
-        } | undefined;
-        unsafe?: true;
-        sql: string;
-        source?: string;
-    };
-    dump(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    cache(config: QueryCacheTtlInput | QueryCacheConfig): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    get(): Promise<ModelCollection<TTable, TRelations, EntityWithLoaded<TTable, TRelations, TLoaded>>>;
-    getJson(): Promise<SerializedEntityWithLoaded<TTable, TLoaded>[]>;
-    first(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded> | undefined>;
-    firstJson(): Promise<SerializedEntityWithLoaded<TTable, TLoaded> | undefined>;
-    sole(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded>>;
-    soleJson(): Promise<SerializedEntityWithLoaded<TTable, TLoaded>>;
-    paginate(perPage?: number, page?: number, options?: PaginationOptions): Promise<PaginatedResult<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
-    paginateJson(perPage?: number, page?: number, options?: PaginationOptions): Promise<{
-        data: readonly SerializedEntityWithLoaded<TTable, TLoaded>[];
-        meta: PaginationMeta;
-    }>;
-    simplePaginate(perPage?: number, page?: number, options?: PaginationOptions): Promise<SimplePaginatedResult<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
-    simplePaginateJson(perPage?: number, page?: number, options?: PaginationOptions): Promise<{
-        data: readonly SerializedEntityWithLoaded<TTable, TLoaded>[];
-        meta: SimplePaginationMeta;
-    }>;
-    cursorPaginate(perPage?: number, cursor?: string | null, options?: CursorPaginationOptions): Promise<CursorPaginatedResult<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
-    cursorPaginateJson(perPage?: number, cursor?: string | null, options?: CursorPaginationOptions): Promise<{
-        data: readonly SerializedEntityWithLoaded<TTable, TLoaded>[];
-        perPage: number;
-        cursorName: string;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    }>;
-    chunk(size: number, callback: (rows: readonly EntityWithLoaded<TTable, TRelations, TLoaded>[], page: number) => unknown | Promise<unknown>): Promise<void>;
-    chunkById(size: number, callback: (rows: readonly EntityWithLoaded<TTable, TRelations, TLoaded>[], page: number) => unknown | Promise<unknown>, column?: ModelAttributeKey<TTable>): Promise<void>;
-    chunkByIdDesc(size: number, callback: (rows: readonly EntityWithLoaded<TTable, TRelations, TLoaded>[], page: number) => unknown | Promise<unknown>, column?: ModelAttributeKey<TTable>): Promise<void>;
-    lazy(size?: number): AsyncGenerator<EntityWithLoaded<TTable, TRelations, TLoaded>, void, unknown>;
-    cursor(): AsyncGenerator<EntityWithLoaded<TTable, TRelations, TLoaded>, void, unknown>;
-    count(): Promise<number>;
-    exists(): Promise<boolean>;
-    doesntExist(): Promise<boolean>;
-    pluck<TColumn extends ModelAttributeKey<TTable>>(column: TColumn): Promise<Array<ModelRecord<TTable>[TColumn]>>;
-    value<TColumn extends ModelAttributeKey<TTable>>(column: TColumn): Promise<ModelRecord<TTable>[TColumn] | undefined>;
-    valueOrFail<TColumn extends ModelAttributeKey<TTable>>(column: TColumn): Promise<ModelRecord<TTable>[TColumn]>;
-    soleValue<TColumn extends ModelAttributeKey<TTable>>(column: TColumn): Promise<ModelRecord<TTable>[TColumn]>;
-    sum(column: ModelColumnName<TTable>): Promise<number>;
-    avg(column: ModelColumnName<TTable>): Promise<number | null>;
-    min(column: ModelColumnName<TTable>): Promise<number | null>;
-    max(column: ModelColumnName<TTable>): Promise<number | null>;
-    firstOrFail(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded>>;
-    find(value: unknown, column?: string): Promise<EntityWithLoaded<TTable, TRelations, TLoaded> | undefined>;
-    findOrFail(value: unknown, column?: string): Promise<EntityWithLoaded<TTable, TRelations, TLoaded>>;
-    findOrFailJson(value: unknown, column?: string): Promise<SerializedEntityWithLoaded<TTable, TLoaded>>;
-    update(values: Partial<ModelRecord<TTable>>): Promise<DriverExecutionResult>;
-    updateJson(columnPath: ModelJsonColumnPath<TTable>, value: unknown): Promise<DriverExecutionResult>;
-    increment(column: ModelColumnName<TTable>, amount?: number, extraValues?: Partial<ModelRecord<TTable>>): Promise<DriverExecutionResult>;
-    decrement(column: ModelColumnName<TTable>, amount?: number, extraValues?: Partial<ModelRecord<TTable>>): Promise<DriverExecutionResult>;
-    upsert(values: Partial<ModelRecord<TTable>> | readonly Partial<ModelRecord<TTable>>[], uniqueBy: readonly ModelColumnName<TTable>[], updateColumns?: readonly ModelColumnName<TTable>[]): Promise<DriverExecutionResult>;
-    delete(): Promise<DriverExecutionResult>;
-    withTrashed(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    onlyTrashed(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    withoutTrashed(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    restore(): Promise<number>;
-    forceDelete(): Promise<number>;
-    private clone;
-    private normalizeExistsSubquery;
-    private withRelationFilter;
-    private withAggregateLoads;
-    private normalizeEagerLoads;
-    private mergeEagerLoads;
-    private normalizeAggregateLoads;
-    private normalizeMorphTypes;
-    private applyMorphedToFilter;
-    private applyMorphRelationFilter;
-    private normalizeMorphedToTarget;
-    private isMorphEntityTarget;
-    private getMorphTargetLabels;
-    private assertMorphToRelation;
-    private normalizeColumnAggregateLoads;
-    private parseAggregateRelation;
-    private resolveBelongsToRelation;
-    private applyBelongsToFilter;
-    private resolveBelongsToRelationName;
-    private extractNumericValues;
-    private getUnpaginatedEntities;
-    private prepareCursorPaginationQuery;
-}
-
-type CollectionLoadedItem<TItem, TTable extends TableDefinition, TRelations extends RelationMap, TPaths extends readonly ModelRelationPath<TRelations>[]> = Omit<TItem, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (TItem extends {
-    toJSON(): infer TSerialized;
-} ? {
-    toJSON(): TSerialized & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-} : {
-    toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-});
-type CollectionSerializedItem<TItem, TTable extends TableDefinition> = TItem extends {
-    toJSON(): infer TSerialized;
-} ? TSerialized : ModelRecord<TTable>;
-interface ModelCollectionMethods<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap, TItem = Entity<TTable, TRelations>> {
-    modelKeys(): unknown[];
-    toQuery(): ModelQueryBuilder<TTable, TRelations>;
-    toJSON(): Array<CollectionSerializedItem<TItem, TTable>>;
-    load<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<ModelCollection<TTable, TRelations, CollectionLoadedItem<TItem, TTable, TRelations, TPaths>>>;
-    loadMissing<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<ModelCollection<TTable, TRelations, CollectionLoadedItem<TItem, TTable, TRelations, TPaths>>>;
-    loadMorph(relation: ModelRelationName<TRelations>, mapping: ModelMorphLoadMap): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    loadCount(...relations: readonly ModelRelationName<TRelations>[]): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    loadExists(...relations: readonly ModelRelationName<TRelations>[]): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    loadSum<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    loadAvg<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    loadMin<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    loadMax<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations, TItem>>;
-    fresh(): Promise<ModelCollection<TTable, TRelations>>;
-    append(...keys: readonly string[]): ModelCollection<TTable, TRelations, TItem>;
-    withoutAppends(): ModelCollection<TTable, TRelations, TItem>;
-    makeVisible(...keys: readonly string[]): ModelCollection<TTable, TRelations, TItem>;
-    makeHidden(...keys: readonly string[]): ModelCollection<TTable, TRelations, TItem>;
-    setVisible(keys: readonly string[]): ModelCollection<TTable, TRelations, TItem>;
-    setHidden(keys: readonly string[]): ModelCollection<TTable, TRelations, TItem>;
-}
-type ModelCollection<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap, TItem = Entity<TTable, TRelations>> = Array<TItem> & ModelCollectionMethods<TTable, TRelations, TItem>;
-
-type SelectRow<TTableOrName extends string | TableDefinition> = TTableOrName extends TableDefinition ? InferSelect<TTableOrName> : Record<string, unknown>;
-type TableReference = string | TableDefinition;
-type BuilderCallback<TBuilder> = (query: TBuilder) => unknown;
-type ValueBuilderCallback<TBuilder, TValue> = (query: TBuilder, value: TValue) => unknown;
-type SelectedColumnNames<TRow extends Record<string, unknown>> = Extract<keyof TRow, string>;
-type ExactDeclaredColumnName<TTableOrName extends TableReference> = TTableOrName extends TableDefinition ? Extract<keyof SelectRow<TTableOrName>, string> : string;
-type DeclaredColumnName<TTableOrName extends TableReference> = TTableOrName extends TableDefinition ? ExactDeclaredColumnName<TTableOrName> | `${string}.${ExactDeclaredColumnName<TTableOrName>}` : string;
-type AliasedColumnSelection<TTableOrName extends TableReference> = TTableOrName extends TableDefinition ? `${DeclaredColumnName<TTableOrName>} as ${string}` : string;
-type ColumnReference<TTableOrName extends TableReference> = TTableOrName extends TableDefinition ? DeclaredColumnName<TTableOrName> | `${string}.${string}` : string;
-type JsonColumnPath<TTableOrName extends TableReference> = TTableOrName extends TableDefinition ? DeclaredColumnName<TTableOrName> | `${DeclaredColumnName<TTableOrName>}->${string}` : string;
-type SelectionResult<TTableOrName extends TableReference, TCurrentRow extends Record<string, unknown>, TColumns extends readonly SelectedColumnNames<SelectRow<TTableOrName>>[]> = TColumns extends readonly [] ? TCurrentRow : Pick<SelectRow<TTableOrName>, TColumns[number]>;
-type MergeSelections<TTableOrName extends TableReference, TCurrentRow extends Record<string, unknown>, TColumns extends readonly SelectedColumnNames<SelectRow<TTableOrName>>[]> = TCurrentRow & Pick<SelectRow<TTableOrName>, TColumns[number]>;
-type AggregateSelectionResult<TAlias extends string, TValue> = Record<TAlias, TValue>;
-declare class TableQueryBuilder<TTableOrName extends TableReference = string, TSelectedRow extends Record<string, unknown> = SelectRow<TTableOrName>> {
-    private readonly connection;
-    private readonly queryCacheConfig?;
-    private readonly source;
-    private readonly plan;
-    constructor(table: TTableOrName, connection: DatabaseContext, plan?: SelectQueryPlan, queryCacheConfig?: NormalizedQueryCacheConfig | undefined);
-    getTableName(): string;
-    getConnectionName(): string;
-    getConnection(): DatabaseContext;
-    getPlan(): SelectQueryPlan;
-    from(table: string): TableQueryBuilder<string, TSelectedRow>;
-    select<const TColumns extends readonly SelectedColumnNames<SelectRow<TTableOrName>>[]>(...columns: TColumns): TableQueryBuilder<TTableOrName, SelectionResult<TTableOrName, TSelectedRow, TColumns>>;
-    select(...columns: readonly (DeclaredColumnName<TTableOrName> | AliasedColumnSelection<TTableOrName>)[]): TableQueryBuilder<TTableOrName, Record<string, unknown>>;
-    addSelect<const TColumns extends readonly SelectedColumnNames<SelectRow<TTableOrName>>[]>(...columns: TColumns): TableQueryBuilder<TTableOrName, MergeSelections<TTableOrName, TSelectedRow, TColumns>>;
-    addSelect(...columns: readonly (DeclaredColumnName<TTableOrName> | AliasedColumnSelection<TTableOrName>)[]): TableQueryBuilder<TTableOrName, Record<string, unknown>>;
-    selectCount<TAlias extends string = 'count'>(alias?: TAlias, column?: DeclaredColumnName<TTableOrName> | '*'): TableQueryBuilder<TTableOrName, AggregateSelectionResult<TAlias, number>>;
-    addSelectCount<TAlias extends string = 'count'>(alias?: TAlias, column?: DeclaredColumnName<TTableOrName> | '*'): TableQueryBuilder<TTableOrName, TSelectedRow & AggregateSelectionResult<TAlias, number>>;
-    selectSum<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, AggregateSelectionResult<TAlias, number | null>>;
-    addSelectSum<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow & AggregateSelectionResult<TAlias, number | null>>;
-    selectAvg<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, AggregateSelectionResult<TAlias, number | null>>;
-    addSelectAvg<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow & AggregateSelectionResult<TAlias, number | null>>;
-    selectMin<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, AggregateSelectionResult<TAlias, number | null>>;
-    addSelectMin<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow & AggregateSelectionResult<TAlias, number | null>>;
-    selectMax<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, AggregateSelectionResult<TAlias, number | null>>;
-    addSelectMax<TAlias extends string>(alias: TAlias, column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow & AggregateSelectionResult<TAlias, number | null>>;
-    unsafeSelect(sql: string, bindings: readonly unknown[]): TableQueryBuilder<TTableOrName, Record<string, unknown>>;
-    addUnsafeSelect(sql: string, bindings: readonly unknown[]): TableQueryBuilder<TTableOrName, Record<string, unknown>>;
-    selectSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string): TableQueryBuilder<TTableOrName, Record<string, unknown>>;
-    addSelectSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string): TableQueryBuilder<TTableOrName, Record<string, unknown>>;
-    distinct(): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    where(callback: BuilderCallback<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    where(column: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhere(callback: BuilderCallback<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhere(column: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    private whereGroupWithBoolean;
-    whereNot(callback: BuilderCallback<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereNot(callback: BuilderCallback<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereExists(subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereExists(subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereNotExists(subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereNotExists(subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereSub(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator, subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereSub(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator, subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereInSub(column: DeclaredColumnName<TTableOrName>, subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereNotInSub(column: DeclaredColumnName<TTableOrName>, subquery: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    private whereWithBoolean;
-    private whereExistsWithBoolean;
-    private whereSubWithBoolean;
-    private whereDatePart;
-    private isScalarJsonValue;
-    private createAggregateSelection;
-    private getColumnDefinition;
-    private assertJsonRootColumn;
-    private parseJsonPath;
-    private whereJsonValueWithBoolean;
-    private whereJsonContainsWithBoolean;
-    private whereJsonLengthWithBoolean;
-    whereNull(column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereNull(column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    private whereNullWithBoolean;
-    whereNotNull(column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereNotNull(column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    private whereNotNullWithBoolean;
-    whereColumn(column: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, compareTo: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereIn(column: DeclaredColumnName<TTableOrName>, values: readonly unknown[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereNotIn(column: DeclaredColumnName<TTableOrName>, values: readonly unknown[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereBetween(column: DeclaredColumnName<TTableOrName>, range: readonly [unknown, unknown]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereNotBetween(column: DeclaredColumnName<TTableOrName>, range: readonly [unknown, unknown]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereLike(column: DeclaredColumnName<TTableOrName>, pattern: string): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereLike(column: DeclaredColumnName<TTableOrName>, pattern: string): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereAny(columns: readonly DeclaredColumnName<TTableOrName>[], operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereAll(columns: readonly DeclaredColumnName<TTableOrName>[], operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereNone(columns: readonly DeclaredColumnName<TTableOrName>[], operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereDate(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereMonth(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereDay(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereYear(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereTime(column: DeclaredColumnName<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereJson(columnPath: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereJson(columnPath: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereJsonContains(columnPath: JsonColumnPath<TTableOrName>, value: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereJsonContains(columnPath: JsonColumnPath<TTableOrName>, value: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereJsonLength(columnPath: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    groupBy(...columns: readonly DeclaredColumnName<TTableOrName>[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    join(table: string, leftColumn: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    leftJoin(table: string, leftColumn: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    rightJoin(table: string, leftColumn: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    joinSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string, leftColumn: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    leftJoinSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string, leftColumn: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    rightJoinSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string, leftColumn: ColumnReference<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    joinLateral(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    leftJoinLateral(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    crossJoin(table: string): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    union(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    unionAll(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    having(expression: string, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    havingBetween(expression: string, range: readonly [unknown, unknown]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereJsonLength(columnPath: string, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    unsafeWhere(sql: string, bindings: readonly unknown[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orUnsafeWhere(sql: string, bindings: readonly unknown[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereFullText(columns: DeclaredColumnName<TTableOrName> | readonly DeclaredColumnName<TTableOrName>[], value: string, options?: {
-        mode?: 'natural' | 'boolean';
-    }): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereFullText(columns: DeclaredColumnName<TTableOrName> | readonly DeclaredColumnName<TTableOrName>[], value: string, options?: {
-        mode?: 'natural' | 'boolean';
-    }): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    whereVectorSimilarTo(column: DeclaredColumnName<TTableOrName>, vector: readonly number[], minSimilarity?: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orWhereVectorSimilarTo(column: DeclaredColumnName<TTableOrName>, vector: readonly number[], minSimilarity?: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    when<TValue>(value: TValue, callback: ValueBuilderCallback<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>, defaultCallback?: ValueBuilderCallback<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    unless<TValue>(value: TValue, callback: ValueBuilderCallback<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>, defaultCallback?: ValueBuilderCallback<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    withoutWhereNull(column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    withoutWhereNotNull(column: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orderBy(column: DeclaredColumnName<TTableOrName>, direction?: QueryDirection): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    unsafeOrderBy(sql: string, bindings: readonly unknown[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    inRandomOrder(): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    latest(column?: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    oldest(column?: DeclaredColumnName<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    reorder(column?: DeclaredColumnName<TTableOrName>, direction?: QueryDirection): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    orderByVectorSimilarity(column: DeclaredColumnName<TTableOrName>, vector: readonly number[]): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    lock(mode: 'update' | 'share'): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    lockForUpdate(): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    sharedLock(): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    limit(value?: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    offset(value?: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    skip(value: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    take(value: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    forPage(page: number, perPage?: number): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    toSQL(): CompiledStatement;
-    debug(): {
-        bindings: unknown[];
-        connectionName: string;
-        scope: TransactionScopeKind;
-        schedulingMode: "concurrent" | "serialized" | "worker";
-        metadata: {
-            debug: {
-                connectionName: string;
-                scope: TransactionScopeKind;
-                schedulingMode: "concurrent" | "serialized" | "worker";
-                tableName: string;
-                hasJoins: boolean;
-                hasUnions: boolean;
-                hasGrouping: boolean;
-                hasHaving: boolean;
-                complexity: number;
-                lockMode?: string;
-                intent: CompiledQueryIntent;
-                transactionAffinity: CompiledQueryTransactionAffinity;
-                streaming: CompiledQueryStreamingMode;
-            };
-            kind: CompiledQueryKind;
-            resultMode: CompiledQueryResultMode;
-            selectedShape: {
-                mode: "all" | "projection" | "write";
-                columns: readonly string[];
-                aggregates: readonly string[];
-                hasRawSelections: boolean;
-                hasSubqueries: boolean;
-            };
-            safety: {
-                unsafe: boolean;
-                containsRawSql: boolean;
-            };
-        } | undefined;
-        unsafe?: true;
-        sql: string;
-        source?: string;
-    };
-    dump(): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    cache(config: QueryCacheTtlInput | QueryCacheConfig): TableQueryBuilder<TTableOrName, TSelectedRow>;
-    get<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow[]>;
-    first<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow | undefined>;
-    sole<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow>;
-    paginate<TRow extends Record<string, unknown> = TSelectedRow>(perPage?: number, page?: number, options?: PaginationOptions): Promise<PaginatedResult<TRow>>;
-    simplePaginate<TRow extends Record<string, unknown> = TSelectedRow>(perPage?: number, page?: number, options?: PaginationOptions): Promise<SimplePaginatedResult<TRow>>;
-    cursorPaginate<TRow extends Record<string, unknown> = TSelectedRow>(perPage?: number, cursor?: string | null, options?: CursorPaginationOptions): Promise<CursorPaginatedResult<TRow>>;
-    chunk<TRow extends Record<string, unknown> = TSelectedRow>(size: number, callback: (rows: readonly TRow[], page: number) => unknown | Promise<unknown>): Promise<void>;
-    chunkById<TRow extends Record<string, unknown> = TSelectedRow>(size: number, callback: (rows: readonly TRow[], page: number) => unknown | Promise<unknown>, column?: string): Promise<void>;
-    chunkByIdDesc<TRow extends Record<string, unknown> = TSelectedRow>(size: number, callback: (rows: readonly TRow[], page: number) => unknown | Promise<unknown>, column?: string): Promise<void>;
-    lazy<TRow extends Record<string, unknown> = TSelectedRow>(size?: number): AsyncGenerator<TRow, void, unknown>;
-    cursor<TRow extends Record<string, unknown> = TSelectedRow>(): AsyncGenerator<TRow, void, unknown>;
-    count(): Promise<number>;
-    exists(): Promise<boolean>;
-    doesntExist(): Promise<boolean>;
-    pluck<TKey extends SelectedColumnNames<TSelectedRow>>(column: TKey): Promise<Array<TSelectedRow[TKey]>>;
-    value<TKey extends SelectedColumnNames<TSelectedRow>>(column: TKey): Promise<TSelectedRow[TKey] | undefined>;
-    valueOrFail<TKey extends SelectedColumnNames<TSelectedRow>>(column: TKey): Promise<TSelectedRow[TKey]>;
-    soleValue<TKey extends SelectedColumnNames<TSelectedRow>>(column: TKey): Promise<TSelectedRow[TKey]>;
-    sum(column: string): Promise<number>;
-    avg(column: string): Promise<number | null>;
-    min(column: string): Promise<number | null>;
-    max(column: string): Promise<number | null>;
-    find<TRow extends Record<string, unknown> = TSelectedRow>(value: unknown, column?: string): Promise<TRow | undefined>;
-    insert(values: Readonly<Record<string, unknown>> | readonly Readonly<Record<string, unknown>>[]): Promise<DriverExecutionResult>;
-    insertOrIgnore(values: Readonly<Record<string, unknown>> | readonly Readonly<Record<string, unknown>>[]): Promise<DriverExecutionResult>;
-    insertGetId(values: Readonly<Record<string, unknown>>): Promise<number | string | undefined>;
-    upsert(values: Readonly<Record<string, unknown>> | readonly Readonly<Record<string, unknown>>[], uniqueBy: readonly string[], updateColumns?: readonly string[]): Promise<DriverExecutionResult>;
-    increment(column: string, amount?: number, extraValues?: Readonly<Record<string, unknown>>): Promise<DriverExecutionResult>;
-    decrement(column: string, amount?: number, extraValues?: Readonly<Record<string, unknown>>): Promise<DriverExecutionResult>;
-    update(values: Readonly<Record<string, unknown>>): Promise<DriverExecutionResult>;
-    updateJson(columnPath: string, value: unknown): Promise<DriverExecutionResult>;
-    delete(): Promise<DriverExecutionResult>;
-    unsafeQuery<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: Omit<UnsafeStatement, 'source'>): Promise<DriverQueryResult<TRow>>;
-    unsafeExecute(statement: Omit<UnsafeStatement, 'source'>): Promise<DriverExecutionResult>;
-    private clone;
-    private invalidateSourceTableQueries;
-    private getCompiler;
-    private getUnpaginatedRows;
-    private resolvePrimaryKeyColumn;
-    private normalizeOperatorValue;
-    private adjustNumericColumn;
-    private whereMultiColumns;
-    private whereFullTextWithBoolean;
-    private whereVectorSimilarToWithBoolean;
-    private prepareCursorPaginationQuery;
-    private aggregateNumeric;
-    private extractNumericValues;
-    private normalizeUpdateValues;
-    private normalizeWriteRecord;
-    private normalizeWriteValueForColumn;
-    private normalizePredicateValueForColumn;
-}
-
-type WriteMode = 'create' | 'update';
-type PivotAttributes = Record<string, unknown>;
-type PivotSyncResult = {
-    attached: unknown[];
-    detached: unknown[];
-    updated: unknown[];
-};
-type PivotToggleResult = {
-    attached: unknown[];
-    detached: unknown[];
-};
-type RelationConstraint = (query: ModelQueryBuilder<TableDefinition>) => unknown;
-type RelationFilter = {
-    relation: string;
-    negate: boolean;
-    constraint?: RelationConstraint;
-    boolean?: 'and' | 'or';
-    morphTypes?: readonly string[];
-};
-type EagerLoad = {
-    relation: string;
-    constraint?: RelationConstraint;
-};
-type AggregateLoad = {
-    relation: string;
-    kind: RelationAggregateKind;
-    constraint?: RelationConstraint;
-    column?: string;
-    alias?: string;
-};
-declare class ModelRepository<TTable extends TableDefinition = TableDefinition> {
-    private readonly connection;
-    readonly definition: ModelDefinition<TTable>;
-    constructor(definition: ModelDefinition<TTable>, connection: DatabaseContext);
-    static from<TTable extends TableDefinition>(reference: ModelDefinitionLike | ModelDefinition<TTable> | ModelReference<TTable>, connection?: DatabaseContext): ModelRepository<TTable>;
-    getConnection(): DatabaseContext;
-    getConnectionName(): string;
-    getDeletedAtColumn(): string | undefined;
-    getRelationNames(): readonly string[];
-    getRelationDefinition(name: string): RelationDefinition;
-    createCollection<TItem extends Entity<TTable>>(items: readonly TItem[]): ModelCollection<TTable, RelationMap, TItem>;
-    query(): ModelQueryBuilder<TTable>;
-    newQuery(): ModelQueryBuilder<TTable>;
-    newModelQuery(): ModelQueryBuilder<TTable>;
-    newQueryWithoutScopes(): ModelQueryBuilder<TTable>;
-    queryWithoutGlobalScope(name: string): ModelQueryBuilder<TTable>;
-    queryWithoutGlobalScopes(names?: readonly string[]): ModelQueryBuilder<TTable>;
-    newQueryWithoutRelationships(): ModelQueryBuilder<TTable>;
-    find(value: unknown): Promise<Entity<TTable> | undefined>;
-    findOrFail(value: unknown): Promise<Entity<TTable>>;
-    first(): Promise<Entity<TTable> | undefined>;
-    firstOrFail(): Promise<Entity<TTable>>;
-    get(): Promise<ModelCollection<TTable>>;
-    sole(): Promise<Entity<TTable>>;
-    all(): Promise<ModelCollection<TTable>>;
-    findMany(values: readonly unknown[]): Promise<ModelCollection<TTable>>;
-    firstWhere(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): Promise<Entity<TTable> | undefined>;
-    firstOrNew(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    firstOrCreate(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    make(values?: Partial<ModelRecord<TTable>>): Entity<TTable>;
-    hydrate(values: Partial<ModelRecord<TTable>>): Entity<TTable>;
-    retrieve(values: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    retrieveWithCasts(values: Partial<ModelRecord<TTable>>, casts: Record<string, ModelCastDefinition>): Promise<Entity<TTable>>;
-    freshEntity(entity: Entity<TTable>): Promise<Entity<TTable> | undefined>;
-    refreshEntity(entity: Entity<TTable>): Promise<Entity<TTable>>;
-    loadRelations(entities: readonly Entity<TTable>[], relations: readonly (string | EagerLoad)[], missingOnly?: boolean): Promise<void>;
-    filterByRelations(entities: readonly Entity<TTable>[], filters: readonly RelationFilter[]): Promise<Array<Entity<TTable>>>;
-    applyRelationExistenceFilter(query: TableQueryBuilder<TTable, Record<string, unknown>>, filter: RelationFilter): TableQueryBuilder<TTable, Record<string, unknown>>;
-    loadMorphRelations(entities: readonly Entity<TTable>[], relationName: string, mapping: Readonly<Record<string, string | readonly string[] | Readonly<Record<string, RelationConstraint>>>>): Promise<void>;
-    loadRelationAggregates(entities: readonly Entity<TTable>[], aggregates: readonly AggregateLoad[]): Promise<void>;
-    create(values: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    createQuietly(values: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    createMany(values: readonly Partial<ModelRecord<TTable>>[]): Promise<ModelCollection<TTable>>;
-    createManyQuietly(values: readonly Partial<ModelRecord<TTable>>[]): Promise<ModelCollection<TTable>>;
-    saveMany(entities: readonly Entity<TTable>[]): Promise<ModelCollection<TTable>>;
-    saveManyQuietly(entities: readonly Entity<TTable>[]): Promise<ModelCollection<TTable>>;
-    update(id: unknown, values: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    delete(id: unknown): Promise<void>;
-    destroy(ids: readonly unknown[]): Promise<number>;
-    prune(): Promise<number>;
-    associateRelation(entity: Entity<TTable>, relationName: string, relatedEntity: Entity | null): Entity<TTable>;
-    dissociateRelation(entity: Entity<TTable>, relationName: string): Entity<TTable>;
-    saveRelatedEntity(entity: Entity<TTable>, relationName: string, relatedEntity: Entity): Promise<Entity>;
-    saveRelatedEntityQuietly(entity: Entity<TTable>, relationName: string, relatedEntity: Entity): Promise<Entity>;
-    saveManyRelatedEntities(entity: Entity<TTable>, relationName: string, relatedEntities: readonly Entity[]): Promise<Entity[]>;
-    saveManyRelatedEntitiesQuietly(entity: Entity<TTable>, relationName: string, relatedEntities: readonly Entity[]): Promise<Entity[]>;
-    createRelatedEntity(entity: Entity<TTable>, relationName: string, values: Record<string, unknown>): Promise<Entity>;
-    createRelatedEntityQuietly(entity: Entity<TTable>, relationName: string, values: Record<string, unknown>): Promise<Entity>;
-    createManyRelatedEntities(entity: Entity<TTable>, relationName: string, values: readonly Record<string, unknown>[]): Promise<ModelCollection>;
-    createManyRelatedEntitiesQuietly(entity: Entity<TTable>, relationName: string, values: readonly Record<string, unknown>[]): Promise<ModelCollection>;
-    private createRecord;
-    restore(id: unknown): Promise<Entity<TTable>>;
-    forceDelete(id: unknown): Promise<void>;
-    upsert(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    updateOrCreate(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable>>;
-    sanitizeWritePayload(values: Partial<ModelRecord<TTable>> | Record<string, unknown>, mode: WriteMode, internalColumns?: ReadonlySet<string>): Partial<ModelUpdatePayload<TTable>>;
-    saveEntity(entity: Entity<TTable>, internalColumns?: ReadonlySet<string>): Promise<Entity<TTable>>;
-    saveEntityQuietly(entity: Entity<TTable>, internalColumns?: ReadonlySet<string>): Promise<Entity<TTable>>;
-    deleteEntity(entity: Entity<TTable>): Promise<void>;
-    deleteEntityQuietly(entity: Entity<TTable>): Promise<void>;
-    shouldKeepEntityPersistedOnDelete(): boolean;
-    restoreEntity(entity: Entity<TTable>): Promise<Entity<TTable>>;
-    restoreEntityQuietly(entity: Entity<TTable>): Promise<Entity<TTable>>;
-    forceDeleteEntity(entity: Entity<TTable>): Promise<void>;
-    private runWriteUnit;
-    forceDeleteEntityQuietly(entity: Entity<TTable>): Promise<void>;
-    replicateEntity(entity: Entity<TTable>, except?: readonly string[]): Entity<TTable>;
-    attachRelation(entity: Entity<TTable>, relationName: string, ids: unknown, attributes?: PivotAttributes): Promise<void>;
-    detachRelation(entity: Entity<TTable>, relationName: string, ids?: unknown): Promise<number>;
-    syncRelation(entity: Entity<TTable>, relationName: string, ids: unknown, detachMissing: boolean): Promise<PivotSyncResult>;
-    updateExistingPivot(entity: Entity<TTable>, relationName: string, id: unknown, attributes: PivotAttributes): Promise<number>;
-    toggleRelation(entity: Entity<TTable>, relationName: string, ids: unknown): Promise<PivotToggleResult>;
-    private loadRelation;
-    private createQuery;
-    private collectLoadedRelationEntities;
-    private loadBelongsToRelation;
-    private loadHasManyRelation;
-    private loadHasOneRelation;
-    private loadHasOneOfManyRelation;
-    private loadMorphManyRelation;
-    private loadMorphOneRelation;
-    private loadMorphOneOfManyRelation;
-    private loadMorphToRelation;
-    private loadHasManyThroughRelation;
-    private loadHasOneThroughRelation;
-    private loadBelongsToManyRelation;
-    private loadMorphToManyRelation;
-    private loadMorphedByManyRelation;
-    private resolveRelatedRepository;
-    private resolveThroughRepository;
-    private getMorphTypeValue;
-    private resolveMorphRepository;
-    private normalizeEagerLoads;
-    private getMatchingParentKeys;
-    private getRelationMatchCounts;
-    private applyRelationConstraint;
-    private buildRelationExistenceSubqueries;
-    private resolveMorphExistenceReferences;
-    private assertRelationExistenceSupported;
-    private applyExistsBoolean;
-    private applyExistsBooleanGroup;
-    private qualifyParentColumn;
-    private getRelationParentValue;
-    private getAggregateAttributeKey;
-    private getRelationAggregateValues;
-    private computeAggregateValue;
-    private assertNumericAggregateValue;
-    private getRelatedEntitiesByParentKey;
-    attachCollection(entities: readonly Entity<TTable>[]): readonly Entity<TTable>[];
-    resolveRelationProperty(entity: Entity<TTable>, relationName: string): unknown;
-    private getMatchingBelongsToParentKeys;
-    private getBelongsToMatchCounts;
-    private getBelongsToEntitiesByParentKey;
-    private getMatchingHasManyParentKeys;
-    private getMatchingMorphManyParentKeys;
-    private getHasManyMatchCounts;
-    private getMorphManyMatchCounts;
-    private getMatchingMorphToParentKeys;
-    private getMorphToMatchCounts;
-    private getMatchingThroughParentKeys;
-    private getThroughMatchCounts;
-    private getHasManyEntitiesByParentKey;
-    private getMorphManyEntitiesByParentKey;
-    private getMorphToEntitiesByParentKey;
-    private matchesMorphType;
-    private resolveMorphLoadTargets;
-    private normalizeMorphLoadTargets;
-    private serializeMorphLoadTargets;
-    private selectOneOfManyEntity;
-    private selectMorphOneOfManyEntity;
-    private getThroughEntitiesByParentKey;
-    private getMatchingBelongsToManyParentKeys;
-    private getMatchingMorphToManyParentKeys;
-    private getMatchingMorphedByManyParentKeys;
-    private getBelongsToManyMatchCounts;
-    private getMorphToManyMatchCounts;
-    private getMorphedByManyMatchCounts;
-    private getBelongsToManyEntitiesByParentKey;
-    private getMorphToManyEntitiesByParentKey;
-    private getMorphedByManyEntitiesByParentKey;
-    private createBelongsToManyPivotQuery;
-    private createMorphToManyPivotQuery;
-    private createMorphedByManyPivotQuery;
-    private applyPivotQueryConfig;
-    private attachPivotAttributes;
-    private extractPivotAttributes;
-    private getDefaultPivotColumns;
-    private getPivotMutationContext;
-    private normalizePivotInput;
-    private assertValidPivotEntries;
-    private assertValidPivotAttributes;
-    private getPivotRows;
-    private indexPivotRows;
-    private pivotAttributesChanged;
-    private insertPivotRow;
-    private updatePivotRow;
-    private deletePivotRows;
-    private isWritableColumn;
-    private assertPersistedParentForRelation;
-    private assertRelationSupportsManyWrites;
-    private touchOwners;
-    private resolveCompatibleRelatedRepository;
-    private syncRelationAfterPersistence;
-    private createPivotMutationQuery;
-    private getPivotRelatedIdColumn;
-    private getReservedPivotColumns;
-    private buildPivotInsertPayload;
-    private applyGeneratedUniqueIds;
-    private applyPendingAttributes;
-    private getObserverInstances;
-    private dispatchCancelableEvent;
-    private dispatchEvent;
-    private dispatchSyncEvent;
-    resolveAttribute(key: string, entity: Entity<TTable>, value: unknown): unknown;
-    shouldPreventAccessingMissingAttributes(key: string): boolean;
-    serializeEntity(entity: Entity<TTable>): Record<string, unknown>;
-    private serializeRelationValue;
-    private serializeOutputValue;
-    serializeAttributeValue(key: string, value: unknown): unknown;
-    private normalizeFromStorage;
-    private applyTimestampDefaults;
-    private normalizeForStorage;
-    private applySchemaReadNormalization;
-    private applySchemaWriteNormalization;
-    private getSchemaDialectName;
-    private applyCastGet;
-    private applyCastSet;
-    private resolveCastDefinition;
-    private parseBuiltInCast;
-    private parseVectorValue;
-    private serializeVectorValue;
-    private parseVectorString;
-    private parseVectorDimensions;
-    private formatDateCast;
-}
-
-type RuntimeState = {
-    savepointCounter: number;
-    rootTransactionTail: Promise<void>;
-    scheduler: QueryScheduler;
-};
-type ScopeState = {
-    kind: TransactionScopeKind;
-    depth: number;
-    savepointName?: string;
-};
-type TransactionCallbackState = {
-    afterCommit: TransactionCallback[];
-    afterRollback: TransactionCallback[];
-};
-type ContextInternals = {
-    contextId: number;
-    connectionName: string;
-    schemaName?: string;
-    adapter: DriverAdapter;
-    dialect: Dialect;
-    driver: DatabaseDriverName;
-    logger?: DatabaseLogger;
-    security: SecurityPolicy;
-    concurrency: ConcurrencyOptions;
-    schemaRegistry: SchemaRegistry;
-    modelRegistry: ModelRegistry;
-    runtime: RuntimeState;
-    scope: ScopeState;
-    transactionCallbacks?: TransactionCallbackState;
-};
-declare class DatabaseContext {
-    private readonly _contextId;
-    private readonly _connectionName;
-    private readonly _schemaName?;
-    private readonly _adapter;
-    private readonly _dialect;
-    private readonly _driver;
-    private readonly _logger?;
-    private readonly _security;
-    private readonly _concurrency;
-    private readonly _schemaRegistry;
-    private readonly _modelRegistry;
-    private readonly _runtime;
-    private readonly _scope;
-    private readonly _transactionCallbacks?;
-    private _migrationService?;
-    private _factoryService?;
-    private _eventService?;
-    constructor(options: DatabaseContextOptions | ContextInternals);
-    initialize(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getDriver(): DatabaseDriverName;
-    getConnectionName(): string;
-    getContextId(): number;
-    getSchemaName(): string | undefined;
-    getAdapter(): DriverAdapter;
-    getDialect(): Dialect;
-    getCapabilities(): DatabaseCapabilities;
-    getSecurityPolicy(): SecurityPolicy;
-    getConcurrencyOptions(): ConcurrencyOptions;
-    getSchemaRegistry(): SchemaRegistry;
-    getModelRegistry(): ModelRegistry;
-    getMigrationService(): MigrationService;
-    getFactoryService(): FactoryService;
-    getEventService(): ModelEventService;
-    registerModel(reference: ModelDefinitionLike): AnyModelDefinition;
-    model(reference: ModelDefinitionLike): ModelRepository;
-    getLogger(): DatabaseLogger | undefined;
-    getScope(): Readonly<ScopeState>;
-    afterCommit(callback: TransactionCallback): void;
-    afterRollback(callback: TransactionCallback): void;
-    getSchedulingModeHint(): 'concurrent' | 'serialized' | 'worker';
-    unsafeQuery<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: UnsafeStatement, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
-    unsafeExecute(statement: UnsafeStatement, options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
-    queryCompiled<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: CompiledStatement, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
-    introspectCompiled<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: CompiledStatement, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
-    executeCompiled(statement: CompiledStatement, options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
-    transaction<T>(callback: (tx: DatabaseContext) => Promise<T>, options?: DatabaseOperationOptions): Promise<T>;
-    private _runRootTransaction;
-    private _runSerializedRootTransaction;
-    private _runNestedTransaction;
-    private _createChildContext;
-    private _runTransactionCallback;
-    private _createTransactionCallbackState;
-    private _registerTransactionCallback;
-    private _mergeCommittedTransactionCallbacks;
-    private _flushTransactionCallbacks;
-    private _assertUnsafeRawAllowed;
-    private _assertUnsafeStatement;
-    private _assertCompiledStatementAllowed;
-    private _runLogged;
-    private _wrapDriverError;
-    private _callTransactionHook;
-    private _guardOperation;
-    private _assertValidOperationOptions;
-    private _throwIfAborted;
-    private _createGuardError;
-}
-
-type ModelUpdatePayload<TTable extends TableDefinition> = Partial<InferUpdate<TTable>>;
-type ModelRecord<TTable extends TableDefinition> = InferSelect<TTable>;
-
-type ModelAttributeKey<TTable extends TableDefinition> = Extract<keyof InferSelect<TTable>, string>;
-type ModelColumnName<TTable extends TableDefinition> = ModelAttributeKey<TTable> | `${string}.${ModelAttributeKey<TTable>}`;
-type ModelColumnReference<TTable extends TableDefinition> = ModelColumnName<TTable> | `${string}.${string}`;
-type ModelJsonColumnPath<TTable extends TableDefinition> = ModelColumnName<TTable> | `${ModelColumnName<TTable>}->${string}`;
-type ModelSelectableColumn<TTable extends TableDefinition> = ModelColumnName<TTable> | `${ModelColumnName<TTable>} as ${string}`;
-interface AnyModelDefinition {
-    readonly kind: 'model';
-    readonly table: TableDefinition;
-    readonly name: string;
-    readonly primaryKey: string;
-    readonly connectionName?: string;
-    readonly morphClass: string;
-    readonly with: readonly string[];
-    readonly pendingAttributes: Partial<Record<string, unknown>>;
-    readonly preventLazyLoading: boolean;
-    readonly preventAccessingMissingAttributes: boolean;
-    readonly automaticEagerLoading: boolean;
-    readonly timestamps: boolean;
-    readonly createdAtColumn?: string;
-    readonly updatedAtColumn?: string;
-    readonly fillable: readonly string[];
-    readonly hasExplicitFillable?: boolean;
-    readonly guarded: readonly string[];
-    readonly relations: RelationMap;
-    readonly casts: Record<string, ModelCastDefinition>;
-    readonly accessors: Record<string, ModelAccessor>;
-    readonly mutators: Record<string, ModelMutator>;
-    readonly hidden: readonly string[];
-    readonly visible: readonly string[];
-    readonly appended: readonly string[];
-    readonly serializeDate?: ModelDateSerializer;
-    readonly massPrunable: boolean;
-    readonly touches: readonly string[];
-    readonly replicationExcludes: readonly string[];
-    readonly softDeletes: boolean;
-    readonly deletedAtColumn?: string;
-    readonly events: Partial<Record<ModelLifecycleEventName, readonly ModelLifecycleEventHandler[]>>;
-    readonly observers: readonly unknown[];
-}
-interface AnyEntity {
-    getRepository(): {
-        definition: AnyModelDefinition;
-    };
-    toAttributes(): Record<string, unknown>;
-    getChanges(): Record<string, unknown>;
-}
-type ModelDefinitionLike<TTable extends TableDefinition = TableDefinition> = (AnyModelDefinition & {
-    readonly table: TTable;
-}) | {
-    readonly definition: AnyModelDefinition & {
-        readonly table: TTable;
-    };
-};
-interface ModelScopeMap<TTable extends TableDefinition = TableDefinition> {
-    readonly [key: string]: (query: ModelQueryBuilder<TTable>, ...args: readonly unknown[]) => ModelQueryBuilder<TTable>;
-}
-type RelationConstraintDefinition = (query: ModelQueryBuilder<TableDefinition>) => unknown;
-interface ScopedRelationDefinition {
-    readonly constraint?: RelationConstraintDefinition;
-}
-type ModelDefinitionTable<TReference extends ModelDefinitionLike> = TReference extends {
-    readonly definition: {
-        readonly table: infer TTable extends TableDefinition;
-    };
-} ? TTable : TReference extends {
-    readonly table: infer TTable extends TableDefinition;
-} ? TTable : TableDefinition;
-type PivotTableColumnName<TPivotTable extends string | TableDefinition> = TPivotTable extends TableDefinition ? Extract<keyof InferSelect<TPivotTable>, string> : string;
-interface BelongsToRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'belongsTo';
-    readonly related: () => TRelated;
-    readonly foreignKey: string;
-    readonly ownerKey: string;
-}
-interface HasManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'hasMany';
-    readonly related: () => TRelated;
-    readonly foreignKey: string;
-    readonly localKey: string;
-}
-interface HasOneRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'hasOne';
-    readonly related: () => TRelated;
-    readonly foreignKey: string;
-    readonly localKey: string;
-}
-interface HasOneOfManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'hasOneOfMany';
-    readonly related: () => TRelated;
-    readonly foreignKey: string;
-    readonly localKey: string;
-    readonly aggregateColumn: string;
-    readonly aggregate: 'min' | 'max';
-}
-interface MorphOneRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'morphOne';
-    readonly related: () => TRelated;
-    readonly morphName: string;
-    readonly morphTypeColumn: string;
-    readonly morphIdColumn: string;
-    readonly localKey: string;
-}
-interface MorphManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'morphMany';
-    readonly related: () => TRelated;
-    readonly morphName: string;
-    readonly morphTypeColumn: string;
-    readonly morphIdColumn: string;
-    readonly localKey: string;
-}
-interface MorphOneOfManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'morphOneOfMany';
-    readonly related: () => TRelated;
-    readonly morphName: string;
-    readonly morphTypeColumn: string;
-    readonly morphIdColumn: string;
-    readonly localKey: string;
-    readonly aggregateColumn: string;
-    readonly aggregate: 'min' | 'max';
-}
-interface MorphToRelationDefinition<TTable extends TableDefinition = TableDefinition> extends ScopedRelationDefinition {
-    readonly kind: 'morphTo';
-    readonly morphName: string;
-    readonly morphTypeColumn: string;
-    readonly morphIdColumn: string;
-}
-interface BelongsToManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TPivotTable extends string | TableDefinition = string | TableDefinition> extends ScopedRelationDefinition, PivotRelationMethods<BelongsToManyRelationDefinition<TRelated, TPivotTable>, TPivotTable> {
-    readonly kind: 'belongsToMany';
-    readonly related: () => TRelated;
-    readonly pivotTable: TPivotTable;
-    readonly foreignPivotKey: string;
-    readonly relatedPivotKey: string;
-    readonly parentKey: string;
-    readonly relatedKey: string;
-    readonly pivotColumns: readonly PivotTableColumnName<TPivotTable>[];
-    readonly pivotWheres: readonly PivotWhereDefinition[];
-    readonly pivotOrderBy: readonly PivotOrderDefinition[];
-    readonly pivotAccessor: string;
-    readonly pivotModel?: () => ModelDefinitionLike;
-}
-interface MorphToManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TPivotTable extends string | TableDefinition = string | TableDefinition> extends ScopedRelationDefinition, PivotRelationMethods<MorphToManyRelationDefinition<TRelated, TPivotTable>, TPivotTable> {
-    readonly kind: 'morphToMany';
-    readonly related: () => TRelated;
-    readonly pivotTable: TPivotTable;
-    readonly morphName: string;
-    readonly morphTypeColumn: string;
-    readonly morphIdColumn: string;
-    readonly foreignPivotKey: string;
-    readonly parentKey: string;
-    readonly relatedKey: string;
-    readonly pivotColumns: readonly PivotTableColumnName<TPivotTable>[];
-    readonly pivotWheres: readonly PivotWhereDefinition[];
-    readonly pivotOrderBy: readonly PivotOrderDefinition[];
-    readonly pivotAccessor: string;
-    readonly pivotModel?: () => ModelDefinitionLike;
-}
-interface MorphedByManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TPivotTable extends string | TableDefinition = string | TableDefinition> extends ScopedRelationDefinition, PivotRelationMethods<MorphedByManyRelationDefinition<TRelated, TPivotTable>, TPivotTable> {
-    readonly kind: 'morphedByMany';
-    readonly related: () => TRelated;
-    readonly pivotTable: TPivotTable;
-    readonly morphName: string;
-    readonly morphTypeColumn: string;
-    readonly morphIdColumn: string;
-    readonly foreignPivotKey: string;
-    readonly parentKey: string;
-    readonly relatedKey: string;
-    readonly pivotColumns: readonly PivotTableColumnName<TPivotTable>[];
-    readonly pivotWheres: readonly PivotWhereDefinition[];
-    readonly pivotOrderBy: readonly PivotOrderDefinition[];
-    readonly pivotAccessor: string;
-    readonly pivotModel?: () => ModelDefinitionLike;
-}
-interface PivotWhereDefinition {
-    readonly column: string;
-    readonly operator: string;
-    readonly value: unknown;
-}
-interface PivotOrderDefinition {
-    readonly column: string;
-    readonly direction: 'asc' | 'desc';
-}
-interface PivotRelationMethods<TRelation, TPivotTable extends string | TableDefinition = string | TableDefinition> {
-    withPivot(...columns: readonly PivotTableColumnName<TPivotTable>[]): TRelation;
-    wherePivot(column: PivotTableColumnName<TPivotTable>, operator: unknown, value?: unknown): TRelation;
-    orderByPivot(column: PivotTableColumnName<TPivotTable>, direction?: 'asc' | 'desc'): TRelation;
-    as(accessor: string): TRelation;
-    using(model: () => ModelDefinitionLike): TRelation;
-}
-interface HasOneThroughRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TThrough extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'hasOneThrough';
-    readonly related: () => TRelated;
-    readonly through: () => TThrough;
-    readonly firstKey: string;
-    readonly secondKey: string;
-    readonly localKey: string;
-    readonly secondLocalKey: string;
-}
-interface HasManyThroughRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TThrough extends ModelDefinitionLike = ModelDefinitionLike> extends ScopedRelationDefinition {
-    readonly kind: 'hasManyThrough';
-    readonly related: () => TRelated;
-    readonly through: () => TThrough;
-    readonly firstKey: string;
-    readonly secondKey: string;
-    readonly localKey: string;
-    readonly secondLocalKey: string;
-}
-type RelationDefinition = BelongsToRelationDefinition | HasManyRelationDefinition | HasOneRelationDefinition | HasOneOfManyRelationDefinition | MorphOneRelationDefinition | MorphManyRelationDefinition | MorphOneOfManyRelationDefinition | MorphToRelationDefinition | BelongsToManyRelationDefinition | MorphToManyRelationDefinition | MorphedByManyRelationDefinition | HasOneThroughRelationDefinition | HasManyThroughRelationDefinition;
-/**
- * Methods available on BelongsTo relations when called as a method (e.g., post.category())
- */
-interface BelongsToRelationMethods<TRelated> {
-    associate(related: TRelated | null): void;
-    dissociate(): void;
-}
-/**
- * Methods available on HasOne/HasOneThrough relations when called as a method
- */
-interface HasOneRelationMethods<TRelated> {
-    create(values: Record<string, unknown>): Promise<TRelated>;
-    save(related: TRelated): Promise<TRelated>;
-}
-/**
- * Methods available on HasMany/HasManyThrough relations when called as a method
- */
-interface HasManyRelationMethods<TRelated> {
-    create(values: Record<string, unknown>): Promise<TRelated>;
-    createMany(values: readonly Record<string, unknown>[]): Promise<TRelated[]>;
-    save(related: TRelated): Promise<TRelated>;
-    saveMany(related: readonly TRelated[]): Promise<TRelated[]>;
-}
-/**
- * Methods available on BelongsToMany relations when called as a method (e.g., post.tags())
- */
-interface BelongsToManyRelationMethods<TRelated, TPivot = Record<string, unknown>> {
-    attach(ids: unknown | readonly unknown[], attributes?: TPivot): Promise<void>;
-    detach(ids?: unknown | readonly unknown[]): Promise<number>;
-    sync(ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-        updated: unknown[];
-    }>;
-    toggle(ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-    }>;
-    updateExistingPivot(id: unknown, attributes: TPivot): Promise<number>;
-    create(values: Record<string, unknown>): Promise<TRelated>;
-    save(related: TRelated): Promise<TRelated>;
-}
-/**
- * Converts a RelationDefinition to its corresponding methods type
- */
-type RelationMethodsOf<TRelation extends RelationDefinition> = TRelation extends BelongsToRelationDefinition<infer TRelated> ? BelongsToRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends HasOneRelationDefinition<infer TRelated> ? HasOneRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends HasOneOfManyRelationDefinition<infer TRelated> ? HasOneRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends HasManyRelationDefinition<infer TRelated> ? HasManyRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends HasOneThroughRelationDefinition<infer TRelated> ? HasOneRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends HasManyThroughRelationDefinition<infer TRelated> ? HasManyRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends BelongsToManyRelationDefinition<infer TRelated> ? BelongsToManyRelationMethods<Entity<ModelDefinitionTable<TRelated>>, Record<string, unknown>> : TRelation extends MorphOneRelationDefinition<infer TRelated> ? HasOneRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends MorphOneOfManyRelationDefinition<infer TRelated> ? HasOneRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends MorphManyRelationDefinition<infer TRelated> ? HasManyRelationMethods<Entity<ModelDefinitionTable<TRelated>>> : TRelation extends MorphToManyRelationDefinition<infer TRelated> ? BelongsToManyRelationMethods<Entity<ModelDefinitionTable<TRelated>>, Record<string, unknown>> : TRelation extends MorphedByManyRelationDefinition<infer TRelated> ? BelongsToManyRelationMethods<Entity<ModelDefinitionTable<TRelated>>, Record<string, unknown>> : never;
-interface RelationMap {
-    readonly [key: string]: RelationDefinition;
-}
-type ModelRelationName<TRelations extends RelationMap = RelationMap> = Extract<keyof TRelations, string>;
-type ModelRelationPath<TRelations extends RelationMap = RelationMap> = InternalRelationPath<TRelations, 15>;
-type InternalRelationPath<TRelations extends RelationMap, TDepth extends number> = ModelRelationName<TRelations> | NestedRelationPath<TRelations, TDepth>;
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
-type NestedRelationPath<TRelations extends RelationMap, TDepth extends number> = TDepth extends 0 ? never : string extends ModelRelationName<TRelations> ? `${string}.${string}` : {
-    [K in ModelRelationName<TRelations>]: TRelations[K] extends {
-        readonly kind: 'morphTo';
-    } ? `${K}.${string}` : TRelations[K] extends {
-        readonly related: () => infer TRef;
-    } ? `${K}.${InternalRelationPath<RelatedRelationsOfDefinition<TRef>, Prev[TDepth]>}` : never;
-}[ModelRelationName<TRelations>];
-type RelationRootName<TRelations extends RelationMap, TRelationPath extends ModelRelationPath<TRelations>> = TRelationPath extends `${infer TRoot}.${string}` ? TRoot extends ModelRelationName<TRelations> ? TRoot : never : TRelationPath extends ModelRelationName<TRelations> ? TRelationPath : never;
-type RelatedTableOfRelation<TRelation extends RelationDefinition> = TRelation extends {
-    readonly related: () => infer TReference extends ModelDefinitionLike;
-} ? ModelDefinitionTable<TReference> : TableDefinition;
-type RelatedColumnNameOfRelation<TRelation extends RelationDefinition> = ModelAttributeKey<RelatedTableOfRelation<TRelation>>;
-type RelatedColumnNameForRelationPath<TRelations extends RelationMap, TRelationPath extends ModelRelationPath<TRelations>> = RelatedColumnNameOfRelation<TRelations[RelationRootName<TRelations, TRelationPath>]>;
-/**
- * Extracts the RelationMap from a related model definition referenced by a
- * relation. This enables recursive type resolution for nested eager loads
- * like `'posts.comments'`.
- */
-type RelatedRelationsOfDefinition<TRef> = TRef extends {
-    readonly relations: infer R extends RelationMap;
-} ? R : TRef extends {
-    readonly definition: {
-        readonly relations: infer R extends RelationMap;
-    };
-} ? R : RelationMap;
-type RelatedRelationsOfRelation<TRelation extends RelationDefinition> = TRelation extends {
-    readonly related: () => infer TRef;
-} ? RelatedRelationsOfDefinition<TRef> : RelationMap;
-/** True for relation kinds that resolve to an array of entities. */
-type IsToManyRelation<TRelation extends RelationDefinition> = TRelation extends {
-    readonly kind: 'hasMany' | 'belongsToMany' | 'morphMany' | 'morphToMany' | 'morphedByMany' | 'hasManyThrough';
-} ? true : false;
-/** Resolves a single (non-nested) relation to its typed entity shape. */
-type ResolveRelationEntity<TRelation extends RelationDefinition> = Entity<RelatedTableOfRelation<TRelation>, RelatedRelationsOfRelation<TRelation>>;
-type ResolveNestedRelationEntity<TRelation extends RelationDefinition, TLoaded> = EntityWithLoaded<RelatedTableOfRelation<TRelation>, RelatedRelationsOfRelation<TRelation>, TLoaded>;
-/**
- * Wraps a base entity type in the correct cardinality for a relation:
- * - to-many  → `TEntity[]`
- * - to-one   → `TEntity | null`
- */
-type WrapRelationCardinality<TRelation extends RelationDefinition, TEntity> = IsToManyRelation<TRelation> extends true ? TEntity[] : TEntity | null;
-/**
- * Recursively resolves a dot-separated eager-load path against a RelationMap.
- *
- * - `'posts'`            → `{ posts: Entity<PostsTable>[] }`
- * - `'posts.comments'`   → `{ posts: (Entity<PostsTable> & { comments: Entity<CommentsTable>[] })[] }`
- * - `'profile'`          → `{ profile: Entity<ProfileTable> | null }`
- *
- * Depth is bounded by TS's recursion limit (~25), but real-world nesting
- * rarely exceeds 3-4 levels.
- */
-type ResolveEagerLoadPath<TRelations extends RelationMap, TPath extends string> = string extends TPath ? unknown : TPath extends `${infer TRoot}.${infer TRest}` ? TRoot extends keyof TRelations & string ? TRelations[TRoot] extends {
-    readonly kind: 'morphTo';
-} ? {
-    readonly [K in TRoot]: WrapRelationCardinality<TRelations[TRoot], ResolveRelationEntity<TRelations[TRoot]>>;
-} : {
-    readonly [K in TRoot]: WrapRelationCardinality<TRelations[TRoot], ResolveNestedRelationEntity<TRelations[TRoot], ResolveEagerLoadPath<RelatedRelationsOfRelation<TRelations[TRoot]>, TRest>>>;
-} : never : TPath extends keyof TRelations & string ? {
-    readonly [K in TPath]: WrapRelationCardinality<TRelations[TPath], ResolveRelationEntity<TRelations[TPath]>>;
-} : never;
-/**
- * Merges multiple eager-load paths into a single intersection type.
- * Used by `with()` and `load()` to accumulate loaded relation shapes.
- */
-type ResolveEagerLoads<TRelations extends RelationMap, TPaths extends readonly string[]> = TPaths extends readonly [] ? unknown : TPaths extends readonly [infer TFirst extends string, ...infer TRest extends readonly string[]] ? ResolveEagerLoadPath<TRelations, TFirst> & ResolveEagerLoads<TRelations, TRest> : ResolveEagerLoadUnion<TRelations, TPaths[number]>;
-/**
- * Converts a union to an intersection via distributive conditional types.
- * `A | B` → `A & B`
- */
-type UnionToIntersection<TUnion> = (TUnion extends unknown ? (x: TUnion) => void : never) extends (x: infer TIntersection) => void ? TIntersection : never;
-/**
- * Resolves a union of eager-load paths into an intersection of their
- * resolved shapes. Used by the object-form `with()` overload where
- * the paths come from `keyof TMap` (a union, not a tuple).
- */
-type ResolveEagerLoadUnion<TRelations extends RelationMap, TPaths extends string> = UnionToIntersection<TPaths extends unknown ? ResolveEagerLoadPath<TRelations, TPaths> : never>;
-/**
- * Recursively converts an eager-loaded shape from entity types to their
- * serialized (JSON) form. Replaces `Entity<T>` with `ModelRecord<T>` and
- * recurses into nested loaded relations.
- *
- * - `Entity<T>[]`        → `ModelRecord<T>[]`
- * - `Entity<T> | null`   → `ModelRecord<T> | null`
- * - `Entity<T> & { r: Entity<U>[] }` → `ModelRecord<T> & { r: ModelRecord<U>[] }`
- */
-type SerializeLoadedValue<TValue> = TValue extends readonly (infer TItem)[] ? SerializeLoadedValue<TItem>[] : TValue extends null ? null : TValue extends Entity<infer TTable, infer _TRelations> ? ModelRecord<TTable> & SerializeLoaded<Omit<TValue, keyof Entity<TTable, _TRelations>>> : TValue;
-type SerializeLoaded<TLoaded> = unknown extends TLoaded ? unknown : {
-    readonly [K in keyof TLoaded]: SerializeLoadedValue<TLoaded[K]>;
-};
-/**
- * The serialized (JSON) form of an entity with eager-loaded relations.
- * This is the return type of `toJSON()` when called on an entity that
- * has loaded relations via `with()` or `load()`.
- */
-type SerializedEntityWithLoaded<TTable extends TableDefinition, TLoaded> = ModelRecord<TTable> & SerializeLoaded<TLoaded>;
-/**
- * The entity type returned by terminal query methods when eager loads
- * have been accumulated via `with()`.
- */
-type EntityWithLoaded<TTable extends TableDefinition, TRelations extends RelationMap, TLoaded> = ModelBase<TTable, TRelations> & Omit<ModelRelationMethods<TRelations>, Extract<keyof TLoaded, string>> & TLoaded & {
-    toJSON(): SerializedEntityWithLoaded<TTable, TLoaded>;
-};
-type EmptyScopeMap = Record<never, never>;
-type ModelScopesDefinition = Readonly<Record<string, unknown>>;
-type ModelLifecycleEventName = 'retrieved' | 'creating' | 'created' | 'updating' | 'updated' | 'saving' | 'saved' | 'deleting' | 'trashed' | 'forceDeleting' | 'forceDeleted' | 'restoring' | 'restored' | 'deleted' | 'replicating';
-type ModelLifecycleEventHandler = (...args: readonly unknown[]) => unknown | Promise<unknown>;
-type BuiltInCastName = 'boolean' | 'number' | 'string' | 'json' | 'date' | 'datetime' | 'timestamp' | 'vector';
-type BuiltInCastString = BuiltInCastName | `${BuiltInCastName}:${string}`;
-type UniqueIdTraitKind = 'uuid' | 'ulid' | 'snowflake' | 'custom';
-type RelationAggregateKind = 'count' | 'exists' | 'sum' | 'avg' | 'min' | 'max';
-interface EnumCastDefinition {
-    readonly kind: 'enum';
-    readonly enumObject: Readonly<Record<string, string | number>>;
-    readonly values: readonly (string | number)[];
-}
-interface CastableDefinition {
-    castUsing(): ModelCastDefinition;
-}
-type ModelCastDefinition = BuiltInCastString | EnumCastDefinition | CastableDefinition | {
-    get?: (value: unknown) => unknown;
-    set?: (value: unknown) => unknown;
-};
-type ModelAccessor = (value: unknown, entity: AnyEntity) => unknown;
-type ModelMutator = (value: unknown, entity?: AnyEntity) => unknown;
-type ModelDateSerializer = (value: Date) => unknown;
-type ModelCollectionFactory<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = <TItem extends Entity<TTable, TRelations>>(items: readonly TItem[]) => ModelCollection<TTable, TRelations, TItem>;
-type ModelPrunableDefinition<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = (query: ModelQueryBuilder<TTable, TRelations>) => unknown;
-interface UniqueIdTrait<TTable extends TableDefinition = TableDefinition> {
-    readonly kind: 'uniqueIds';
-    readonly name: string;
-    readonly type: UniqueIdTraitKind;
-    readonly columns?: readonly ModelAttributeKey<TTable>[];
-    readonly generator?: () => string;
-}
-type ModelTrait<TTable extends TableDefinition = TableDefinition> = UniqueIdTrait<TTable>;
-interface UniqueIdRuntimeConfig<TTable extends TableDefinition = TableDefinition> {
-    readonly usesUniqueIds: boolean;
-    readonly columns: readonly ModelAttributeKey<TTable>[];
-    readonly generator: () => string;
-    readonly traitName: string;
-    readonly traitType: UniqueIdTraitKind;
-}
-interface ModelDefinition<TTable extends TableDefinition = TableDefinition, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap> {
-    readonly kind: 'model';
-    readonly table: TTable;
-    readonly name: string;
-    readonly primaryKey: ModelAttributeKey<TTable>;
-    readonly connectionName?: string;
-    readonly morphClass: string;
-    readonly with: readonly string[];
-    readonly pendingAttributes: Partial<InferInsert<TTable>>;
-    readonly preventLazyLoading: boolean;
-    readonly preventAccessingMissingAttributes: boolean;
-    readonly automaticEagerLoading: boolean;
-    readonly timestamps: boolean;
-    readonly createdAtColumn?: ModelAttributeKey<TTable>;
-    readonly updatedAtColumn?: ModelAttributeKey<TTable>;
-    readonly fillable: readonly string[];
-    readonly hasExplicitFillable?: boolean;
-    readonly guarded: readonly string[];
-    readonly scopes: TScopes;
-    readonly globalScopes: ModelScopeMap<TTable>;
-    readonly relations: TRelations;
-    readonly casts: Record<string, ModelCastDefinition>;
-    readonly accessors: Record<string, ModelAccessor>;
-    readonly mutators: Record<string, ModelMutator>;
-    readonly hidden: readonly string[];
-    readonly visible: readonly string[];
-    readonly appended: readonly string[];
-    readonly serializeDate?: ModelDateSerializer;
-    readonly collection?: ModelCollectionFactory<TTable>;
-    readonly prunable?: ModelPrunableDefinition<TTable>;
-    readonly massPrunable: boolean;
-    readonly touches: readonly string[];
-    readonly traits: readonly ModelTrait<TTable>[];
-    readonly uniqueIdConfig: UniqueIdRuntimeConfig<TTable> | null;
-    readonly replicationExcludes: readonly string[];
-    readonly softDeletes: boolean;
-    readonly deletedAtColumn?: ModelAttributeKey<TTable>;
-    readonly events: Partial<Record<ModelLifecycleEventName, readonly ModelLifecycleEventHandler[]>>;
-    readonly observers: readonly unknown[];
-}
-interface ModelReference<TTable extends TableDefinition = TableDefinition, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap> {
-    readonly definition: ModelDefinition<TTable, TScopes, TRelations>;
-}
-type ModelMorphLoadMap = Readonly<Record<string, string | readonly string[] | Readonly<Record<string, RelationConstraintDefinition>>>>;
-interface ModelRepositoryLike<TTable extends TableDefinition = TableDefinition, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap> {
-    readonly definition: ModelDefinition<TTable, TScopes, TRelations>;
-    getConnection(): DatabaseContext;
-}
-
 type MediaModelDefinitionRef = {
     readonly name: string;
     readonly morphClass?: string;
@@ -2910,12 +151,12 @@ interface MediaPathGenerator {
     conversionPath<TCollectionName extends string = string, TConversionName extends string = string>(input: MediaConversionPathInput<TCollectionName, TConversionName>): string;
 }
 declare function registerMediaDefinition(target: MediaModelReferenceLike, definition: NormalizedMediaDefinition): NormalizedMediaDefinition;
-declare function getMediaDefinition(target: MediaModelReferenceLike | Entity$1<TableDefinition$1>): NormalizedMediaDefinition | undefined;
-declare function requireMediaDefinition(target: MediaModelReferenceLike | Entity$1<TableDefinition$1>): NormalizedMediaDefinition;
+declare function getMediaDefinition(target: MediaModelReferenceLike | Entity<TableDefinition>): NormalizedMediaDefinition | undefined;
+declare function requireMediaDefinition(target: MediaModelReferenceLike | Entity<TableDefinition>): NormalizedMediaDefinition;
 declare function getMediaDefinitionForMorphClass(morphClass: string): NormalizedMediaDefinition | undefined;
 declare function requireMediaDefinitionForMorphClass(morphClass: string): NormalizedMediaDefinition;
-declare function resolveMediaCollection(target: MediaModelReferenceLike | Entity$1<TableDefinition$1>, collectionName?: string): NormalizedMediaCollectionDefinition;
-declare function resolveMediaConversion(target: MediaModelReferenceLike | Entity$1<TableDefinition$1>, conversionName: string): NormalizedMediaConversionDefinition | undefined;
+declare function resolveMediaCollection(target: MediaModelReferenceLike | Entity<TableDefinition>, collectionName?: string): NormalizedMediaCollectionDefinition;
+declare function resolveMediaConversion(target: MediaModelReferenceLike | Entity<TableDefinition>, conversionName: string): NormalizedMediaConversionDefinition | undefined;
 declare function setMediaPathGenerator(generator: MediaPathGenerator): void;
 declare function resetMediaPathGenerator(): void;
 declare function getMediaPathGenerator(): MediaPathGenerator;
@@ -2942,20 +183,20 @@ declare const Media: _holo_js_db.StaticModelApi<_holo_js_db.BoundTableDefinition
     created_at: _holo_js_db.ColumnBuilder<Date, false, true, false, false>;
     updated_at: _holo_js_db.ColumnBuilder<Date, false, true, false, false>;
 }>, _holo_js_db.EmptyScopeMap, {
-    model: MorphToRelationDefinition<_holo_js_db.TableDefinition<string, _holo_js_db.TableColumnsShape>>;
+    model: _holo_js_db.MorphToRelationDefinition<_holo_js_db.TableDefinition<string, _holo_js_db.TableColumnsShape>>;
 }>;
 
-type MediaRecord = ModelRecord$1<typeof Media.definition.table>;
-declare class MediaItem<TCollectionName extends string = string, TConversionName extends string = string, TEntity extends Entity$1<TableDefinition$1> = Entity$1<TableDefinition$1>> {
+type MediaRecord = ModelRecord<typeof Media.definition.table>;
+declare class MediaItem<TCollectionName extends string = string, TConversionName extends string = string, TEntity extends Entity<TableDefinition> = Entity<TableDefinition>> {
     private readonly entity;
     private readonly owner?;
-    constructor(entity: Entity$1<typeof Media.definition.table>, owner?: TEntity | undefined);
+    constructor(entity: Entity<typeof Media.definition.table>, owner?: TEntity | undefined);
     get record(): MediaRecord;
     get collectionName(): TCollectionName;
     get fileName(): string;
     get mimeType(): string | null;
     get size(): number;
-    getEntity(): Entity$1<typeof Media.definition.table>;
+    getEntity(): Entity<typeof Media.definition.table>;
     getAvailableConversions(): readonly TConversionName[];
     getPath(conversion?: TConversionName): string | null;
     getUrl(conversion?: TConversionName): string | null;
@@ -2997,11 +238,11 @@ type MediaAddError = {
     readonly extension?: string;
     readonly acceptedExtensions?: readonly string[];
 };
-type MediaAddResult<TCollectionName extends string = string, TConversionName extends string = string, TEntity extends Entity$1<TableDefinition$1> = Entity$1<TableDefinition$1>> = MediaItem<TCollectionName, TConversionName, TEntity> & {
+type MediaAddResult<TCollectionName extends string = string, TConversionName extends string = string, TEntity extends Entity<TableDefinition> = Entity<TableDefinition>> = MediaItem<TCollectionName, TConversionName, TEntity> & {
     readonly data: MediaItem<TCollectionName, TConversionName, TEntity> | null;
     readonly error: MediaAddError | null;
 };
-declare class MediaAdder<TEntity extends Entity$1<TableDefinition$1> = Entity$1<TableDefinition$1>, TCollectionName extends string = string, TConversionName extends string = string> {
+declare class MediaAdder<TEntity extends Entity<TableDefinition> = Entity<TableDefinition>, TCollectionName extends string = string, TConversionName extends string = string> {
     private readonly entity;
     private readonly source;
     private readonly state;
@@ -3019,14 +260,14 @@ declare class MediaAdder<TEntity extends Entity$1<TableDefinition$1> = Entity$1<
 
 type MediaCollectionName<TDefinition extends MediaDefinitionInput> = 'default' | CollectionNamesOf<TDefinition>;
 type MediaConversionName<TDefinition extends MediaDefinitionInput> = ConversionNamesOf<TDefinition>;
-type MediaEnabledEntity<TTable extends TableDefinition$1 = TableDefinition$1, TCollectionName extends string = string, TConversionName extends string = string, TRelations extends RelationMap$1 = RelationMap$1> = Entity$1<TTable, TRelations> & MediaEnabledEntityMethods<TCollectionName, TConversionName>;
+type MediaEnabledEntity<TTable extends TableDefinition = TableDefinition, TCollectionName extends string = string, TConversionName extends string = string, TRelations extends RelationMap = RelationMap> = Entity<TTable, TRelations> & MediaEnabledEntityMethods<TCollectionName, TConversionName>;
 type MediaEnabledEntityMethods<TCollectionName extends string, TConversionName extends string> = {
-    addMedia(source: MediaSourceInput): MediaAdder<Entity$1<TableDefinition$1>, TCollectionName, TConversionName>;
-    addMediaFromUrl(url: string): MediaAdder<Entity$1<TableDefinition$1>, TCollectionName, TConversionName>;
-    getMedia(collectionName?: TCollectionName): Promise<MediaItem<TCollectionName, TConversionName, Entity$1<TableDefinition$1>>[]>;
+    addMedia(source: MediaSourceInput): MediaAdder<Entity<TableDefinition>, TCollectionName, TConversionName>;
+    addMediaFromUrl(url: string): MediaAdder<Entity<TableDefinition>, TCollectionName, TConversionName>;
+    getMedia(collectionName?: TCollectionName): Promise<MediaItem<TCollectionName, TConversionName, Entity<TableDefinition>>[]>;
     getMediaUrls(collectionName?: TCollectionName, conversionName?: TConversionName): Promise<string[]>;
     getMediaPaths(collectionName?: TCollectionName, conversionName?: TConversionName): Promise<string[]>;
-    getFirstMedia(collectionName?: TCollectionName): Promise<MediaItem<TCollectionName, TConversionName, Entity$1<TableDefinition$1>> | null>;
+    getFirstMedia(collectionName?: TCollectionName): Promise<MediaItem<TCollectionName, TConversionName, Entity<TableDefinition>> | null>;
     getFirstMediaUrl(collectionName?: TCollectionName, conversionName?: TConversionName): Promise<string | null>;
     getFirstMediaPath(collectionName?: TCollectionName, conversionName?: TConversionName): Promise<string | null>;
     getFirstTemporaryUrl(collectionName?: TCollectionName, conversionName?: TConversionName, options?: {
@@ -3037,7 +278,7 @@ type MediaEnabledEntityMethods<TCollectionName extends string, TConversionName e
     clearMediaCollection(collectionName?: TCollectionName): Promise<void>;
     regenerateMedia(collectionName?: TCollectionName, conversions?: TConversionName | readonly TConversionName[]): Promise<void>;
 };
-type MediaEnabledEntityResult<TEntity, TCollectionName extends string, TConversionName extends string> = TEntity extends EntityWithLoaded$1<infer _TTable extends TableDefinition$1, infer _TRelations extends RelationMap$1, infer _TLoaded> ? TEntity & MediaEnabledEntityMethods<TCollectionName, TConversionName> : TEntity extends Entity$1<infer _TTable extends TableDefinition$1, infer _TRelations extends RelationMap$1> ? TEntity & MediaEnabledEntityMethods<TCollectionName, TConversionName> : TEntity;
+type MediaEnabledEntityResult<TEntity, TCollectionName extends string, TConversionName extends string> = TEntity extends EntityWithLoaded<infer _TTable extends TableDefinition, infer _TRelations extends RelationMap, infer _TLoaded> ? unknown extends _TLoaded ? MediaEnabledEntity<_TTable, TCollectionName, TConversionName, _TRelations> : TEntity & MediaEnabledEntityMethods<TCollectionName, TConversionName> : TEntity extends Entity<infer _TTable extends TableDefinition, infer _TRelations extends RelationMap> ? TEntity & MediaEnabledEntityMethods<TCollectionName, TConversionName> : TEntity;
 type MediaEnabledFunction<TFunction, TCollectionName extends string, TConversionName extends string> = TFunction extends {
     (...args: infer TArgs1): infer TReturn1;
     (...args: infer TArgs2): infer TReturn2;
@@ -3063,39 +304,46 @@ type MediaEnabledFunction<TFunction, TCollectionName extends string, TConversion
     (...args: TArgs1): MediaEnabledResult<TReturn1, TCollectionName, TConversionName>;
     (...args: TArgs2): MediaEnabledResult<TReturn2, TCollectionName, TConversionName>;
 } : TFunction extends (...args: infer TArgs) => infer TReturn ? (...args: TArgs) => MediaEnabledResult<TReturn, TCollectionName, TConversionName> : TFunction;
-type MediaEnabledQueryBuilder<TBuilder, TCollectionName extends string, TConversionName extends string> = TBuilder & {
-    [K in keyof TBuilder]: MediaEnabledFunction<TBuilder[K], TCollectionName, TConversionName>;
+type MediaEnabledQueryBuilder<TBuilder, TCollectionName extends string, TConversionName extends string> = {
+    [K in keyof TBuilder]: K extends 'with' ? MediaEnabledQueryBuilderWith<TBuilder, TCollectionName, TConversionName> : K extends 'withCount' | 'withExists' ? MediaEnabledRelationAggregate<TBuilder, TCollectionName, TConversionName> : K extends 'withSum' | 'withAvg' | 'withMin' | 'withMax' ? MediaEnabledRelationColumnAggregate<TBuilder, TCollectionName, TConversionName> : MediaEnabledFunction<TBuilder[K], TCollectionName, TConversionName>;
 };
 type MediaEnabledPaginatedResult<TResult, TPaginator, TCollectionName extends string, TConversionName extends string> = Omit<TResult, keyof TPaginator> & TPaginator & (TResult extends {
     readonly data: infer TData;
 } ? {
     readonly data: MediaEnabledResult<TData, TCollectionName, TConversionName>;
 } : Record<never, never>);
-type MediaEnabledResult<TValue, TCollectionName extends string, TConversionName extends string> = TValue extends Promise<infer TResult> ? Promise<MediaEnabledResult<TResult, TCollectionName, TConversionName>> : TValue extends AsyncGenerator<infer TYield, infer TReturn, infer TNext> ? AsyncGenerator<MediaEnabledResult<TYield, TCollectionName, TConversionName>, TReturn, TNext> : TValue extends ModelQueryBuilder$1<infer TTable extends TableDefinition$1, infer TRelations extends RelationMap$1, infer TLoaded> ? MediaEnabledQueryBuilder<ModelQueryBuilder$1<TTable, TRelations, TLoaded>, TCollectionName, TConversionName> : TValue extends ModelCollection$1<infer TTable extends TableDefinition$1, infer TRelations extends RelationMap$1, infer TItem> ? TItem extends Entity$1<TTable, TRelations> ? ModelCollection$1<TTable, TRelations, MediaEnabledEntityResult<TItem, TCollectionName, TConversionName>> : TValue : TValue extends PaginatedResult$1<infer TItem> ? MediaEnabledPaginatedResult<TValue, PaginatedResult$1<MediaEnabledResult<TItem, TCollectionName, TConversionName>>, TCollectionName, TConversionName> : TValue extends SimplePaginatedResult$1<infer TItem> ? MediaEnabledPaginatedResult<TValue, SimplePaginatedResult$1<MediaEnabledResult<TItem, TCollectionName, TConversionName>>, TCollectionName, TConversionName> : TValue extends CursorPaginatedResult$1<infer TItem> ? MediaEnabledPaginatedResult<TValue, CursorPaginatedResult$1<MediaEnabledResult<TItem, TCollectionName, TConversionName>>, TCollectionName, TConversionName> : MediaEnabledEntityResult<TValue, TCollectionName, TConversionName>;
+type MediaEnabledResult<TValue, TCollectionName extends string, TConversionName extends string> = TValue extends Promise<infer TResult> ? Promise<MediaEnabledResult<TResult, TCollectionName, TConversionName>> : TValue extends AsyncGenerator<infer TYield, infer TReturn, infer TNext> ? AsyncGenerator<MediaEnabledResult<TYield, TCollectionName, TConversionName>, TReturn, TNext> : TValue extends ModelQueryBuilder<infer TTable extends TableDefinition, infer TRelations extends RelationMap, infer TLoaded> ? MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded>, TCollectionName, TConversionName> : TValue extends ModelCollection<infer TTable extends TableDefinition, infer TRelations extends RelationMap, infer TItem> ? TItem extends Entity<TTable, TRelations> ? ModelCollection<TTable, TRelations, MediaEnabledEntityResult<TItem, TCollectionName, TConversionName>> : TValue : TValue extends PaginatedResult<infer TItem> ? MediaEnabledPaginatedResult<TValue, PaginatedResult<MediaEnabledResult<TItem, TCollectionName, TConversionName>>, TCollectionName, TConversionName> : TValue extends SimplePaginatedResult<infer TItem> ? MediaEnabledPaginatedResult<TValue, SimplePaginatedResult<MediaEnabledResult<TItem, TCollectionName, TConversionName>>, TCollectionName, TConversionName> : TValue extends CursorPaginatedResult<infer TItem> ? MediaEnabledPaginatedResult<TValue, CursorPaginatedResult<MediaEnabledResult<TItem, TCollectionName, TConversionName>>, TCollectionName, TConversionName> : MediaEnabledEntityResult<TValue, TCollectionName, TConversionName>;
 type MediaModelStatic = {
     readonly definition: {
         readonly name: string;
-        readonly table: TableDefinition$1;
+        readonly table: TableDefinition;
     };
     readonly resolveRelationUsing: (name: string, resolver: DynamicRelationResolver) => unknown;
 };
-type MediaRelationPath<TRelations extends RelationMap$1> = Extract<keyof TRelations, string> | `${Extract<keyof TRelations, string>}.${string}`;
-type MediaRelationConstraint<TTable extends TableDefinition$1, TRelations extends RelationMap$1> = (query: ModelQueryBuilder$1<TTable, TRelations>) => unknown;
-type MediaEnabledStaticMethodKey = 'create' | 'cursorPaginate' | 'find' | 'findMany' | 'findOrFail' | 'first' | 'firstOrFail' | 'firstWhere' | 'make' | 'paginate' | 'simplePaginate' | 'update' | 'with';
-type MediaEnabledStaticMethods<TModel extends MediaModelStatic, TCollectionName extends string, TConversionName extends string> = {
-    [K in keyof TModel as K extends MediaEnabledStaticMethodKey ? K : never]: K extends 'with' ? MediaEnabledWith<TModel, TCollectionName, TConversionName> : MediaEnabledFunction<TModel[K], TCollectionName, TConversionName>;
-};
-type MediaEnabledWith<TModel extends MediaModelStatic, TCollectionName extends string, TConversionName extends string> = TModel extends {
-    query(): ModelQueryBuilder$1<infer TTable extends TableDefinition$1, infer TRelations extends RelationMap$1>;
-} ? {
-    <TPaths extends readonly MediaRelationPath<TRelations>[]>(...relations: TPaths): MediaEnabledQueryBuilder<ModelQueryBuilder$1<TTable, TRelations, ResolveEagerLoads$1<TRelations, TPaths>>, TCollectionName, TConversionName>;
-    <TPath extends MediaRelationPath<TRelations>>(relation: TPath, constraint: MediaRelationConstraint<TTable, TRelations>): MediaEnabledQueryBuilder<ModelQueryBuilder$1<TTable, TRelations, ResolveEagerLoads$1<TRelations, readonly [TPath]>>, TCollectionName, TConversionName>;
-    (relations: Readonly<Partial<Record<MediaRelationPath<TRelations>, MediaRelationConstraint<TTable, TRelations>>>>): MediaEnabledQueryBuilder<ModelQueryBuilder$1<TTable, TRelations>, TCollectionName, TConversionName>;
-    <TPaths extends readonly MediaRelationPath<TRelations>[]>(relations: TPaths): MediaEnabledQueryBuilder<ModelQueryBuilder$1<TTable, TRelations, ResolveEagerLoads$1<TRelations, TPaths>>, TCollectionName, TConversionName>;
-} : TModel extends {
+type MediaRelationPath<TRelations extends RelationMap> = ModelRelationPath<TRelations>;
+type MediaRelationConstraint<TTable extends TableDefinition, TRelations extends RelationMap> = RelationConstraintDefinition & ((query: ModelQueryBuilder<TTable, TRelations>) => unknown);
+type MediaRelationConstraintMap<TRelations extends RelationMap> = Readonly<Partial<Record<MediaRelationPath<TRelations>, MediaRelationConstraint<TableDefinition, TRelations>>>>;
+type MediaEnabledQueryBuilderWith<TBuilder, TCollectionName extends string, TConversionName extends string> = TBuilder extends ModelQueryBuilder<infer TTable extends TableDefinition, infer TRelations extends RelationMap, infer TLoaded> ? {
+    <TPaths extends readonly MediaRelationPath<TRelations>[]>(...relations: TPaths): MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, TPaths>>, TCollectionName, TConversionName>;
+    <TPath extends MediaRelationPath<TRelations>>(relation: TPath, constraint: MediaRelationConstraint<TTable, TRelations>): MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, readonly [TPath]>>, TCollectionName, TConversionName>;
+    (relations: MediaRelationConstraintMap<TRelations>): MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded>, TCollectionName, TConversionName>;
+    <TPaths extends readonly MediaRelationPath<TRelations>[]>(relations: TPaths): MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, TPaths>>, TCollectionName, TConversionName>;
+} : TBuilder extends {
+    with: infer TWith;
+} ? MediaEnabledFunction<TWith, TCollectionName, TConversionName> : never;
+type MediaEnabledRelationAggregate<TBuilder, TCollectionName extends string, TConversionName extends string> = TBuilder extends ModelQueryBuilder<infer TTable extends TableDefinition, infer TRelations extends RelationMap, infer TLoaded> ? {
+    (...relations: readonly MediaRelationPath<TRelations>[]): MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded>, TCollectionName, TConversionName>;
+    (relations: MediaRelationConstraintMap<TRelations>): MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded>, TCollectionName, TConversionName>;
+} : never;
+type MediaEnabledRelationColumnAggregate<TBuilder, TCollectionName extends string, TConversionName extends string> = TBuilder extends ModelQueryBuilder<infer TTable extends TableDefinition, infer TRelations extends RelationMap, infer TLoaded> ? <TPath extends MediaRelationPath<TRelations>>(first: TPath | MediaRelationConstraintMap<TRelations>, column: RelatedColumnNameForRelationPath<TRelations, TPath>, ...rest: readonly MediaRelationPath<TRelations>[]) => MediaEnabledQueryBuilder<ModelQueryBuilder<TTable, TRelations, TLoaded>, TCollectionName, TConversionName> : never;
+type MediaEnabledStaticWith<TModel extends MediaModelStatic, TCollectionName extends string, TConversionName extends string> = TModel extends {
+    query(): infer TBuilder;
+} ? MediaEnabledQueryBuilderWith<TBuilder, TCollectionName, TConversionName> : TModel extends {
     with: infer TWith;
 } ? MediaEnabledFunction<TWith, TCollectionName, TConversionName> : never;
-type MediaEnabledModel<TModel extends MediaModelStatic, TDefinition extends MediaDefinitionInput> = Omit<TModel, MediaEnabledStaticMethodKey> & MediaEnabledStaticMethods<TModel, MediaCollectionName<TDefinition>, MediaConversionName<TDefinition>>;
+type MediaEnabledModel<TModel extends MediaModelStatic, TDefinition extends MediaDefinitionInput> = {
+    [K in keyof TModel]: K extends 'with' ? MediaEnabledStaticWith<TModel, MediaCollectionName<TDefinition>, MediaConversionName<TDefinition>> : MediaEnabledFunction<TModel[K], MediaCollectionName<TDefinition>, MediaConversionName<TDefinition>>;
+} & TModel;
 declare function defineMediaModel<TModel extends MediaModelStatic, const TDefinition extends MediaDefinitionInput>(model: TModel, definition: TDefinition | MediaDefinitionFactory<TDefinition>): MediaEnabledModel<TModel, TDefinition>;
 
 declare const MEDIA_GENERATE_CONVERSIONS_JOB = "media.generate-conversions";