@holo-js/db 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3789 @@
+import { PoolConfig, QueryResult } from 'pg';
+import { PoolOptions } from 'mysql2/promise';
+
+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> {
+    readonly kind: LogicalColumnKind;
+    readonly name: string;
+    readonly nullable: TNullable;
+    readonly hasDefault: THasDefault;
+    readonly generated: TGenerated;
+    readonly primaryKey: boolean;
+    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>;
+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> ? TNullable extends true ? TValue | null : TValue : never;
+type ColumnInsertType<TColumn extends AnyColumnDefinition> = TColumn extends ColumnDefinition<infer TValue, infer TNullable, 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> ? 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 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> {
+    private readonly metadata;
+    constructor(kind: LogicalColumnKind, name?: string, metadata?: Partial<ColumnMetadata>);
+    notNull(): ColumnBuilder<TType, false, THasDefault, TGenerated>;
+    nullable(): ColumnBuilder<TType, true, THasDefault, TGenerated>;
+    default(value: unknown): ColumnBuilder<TType, TNullable, true, TGenerated>;
+    defaultNow(): ColumnBuilder<TType, TNullable, true, TGenerated>;
+    generated(): ColumnBuilder<TType, TNullable, THasDefault, true>;
+    primaryKey(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    unique(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    references(columnName: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    on(table: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    constraintName(name: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    constrained(table?: string, columnName?: string): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    onDelete(action: NonNullable<ForeignKeyReference['onDelete']>): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    onUpdate(action: NonNullable<ForeignKeyReference['onUpdate']>): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    cascadeOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    restrictOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    nullOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    noActionOnDelete(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    cascadeOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    restrictOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    nullOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    noActionOnUpdate(): ColumnBuilder<TType, TNullable, THasDefault, TGenerated>;
+    toDefinition(options: ColumnBuildOptions): ColumnDefinition<TType, TNullable, THasDefault, TGenerated>;
+    private clone;
+}
+declare const column: {
+    id(name?: string): ColumnBuilder<number, false, false, true>;
+    autoIncrementId(name?: string): ColumnBuilder<number, false, false, true>;
+    integer(name?: string): ColumnBuilder<number, false, false, false>;
+    bigInteger(name?: string): ColumnBuilder<number, false, false, false>;
+    string(name?: string): ColumnBuilder<string, false, false, false>;
+    text(name?: string): ColumnBuilder<string, false, false, false>;
+    boolean(name?: string): ColumnBuilder<boolean, false, false, false>;
+    real(name?: string): ColumnBuilder<number, false, false, false>;
+    decimal(name?: string): ColumnBuilder<string, false, false, false>;
+    date(name?: string): ColumnBuilder<Date, false, false, false>;
+    datetime(name?: string): ColumnBuilder<Date, false, false, false>;
+    timestamp(name?: string): ColumnBuilder<Date, false, false, false>;
+    json<TValue = unknown>(name?: string): ColumnBuilder<TValue, false, false, false>;
+    blob(name?: string): ColumnBuilder<Uint8Array<ArrayBufferLike>, false, false, false>;
+    uuid(name?: string): ColumnBuilder<string, false, false, false>;
+    ulid(name?: string): ColumnBuilder<string, false, false, false>;
+    snowflake(name?: string): ColumnBuilder<string, false, false, false>;
+    foreignId(name?: string): ColumnBuilder<number, false, false, false>;
+    foreignUuid(name?: string): ColumnBuilder<string, false, false, false>;
+    foreignUlid(name?: string): ColumnBuilder<string, false, false, false>;
+    foreignSnowflake(name?: string): ColumnBuilder<string, false, false, false>;
+    vector(options: VectorOptions, name?: string): ColumnBuilder<VectorValue, false, false, false>;
+    enum<const TValues extends readonly string[]>(values: TValues, name?: string): ColumnBuilder<TValues[number], false, false, false>;
+};
+type AnyColumnBuilder = ColumnBuilder<unknown, boolean, boolean, boolean>;
+type ColumnInput = AnyColumnBuilder | AnyColumnDefinition;
+
+type ColumnShapeInput$2 = 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$2> = {
+    [K in keyof TColumns]: ResolvedColumn<TColumns[K]>;
+};
+type BoundTableDefinition<TName extends string, TColumns extends ColumnShapeInput$2> = TableDefinition<TName, BoundColumns<TColumns>> & BoundColumns<TColumns>;
+
+interface GeneratedSchemaTables {
+}
+type GeneratedSchemaTableName = Extract<keyof GeneratedSchemaTables, string>;
+type GeneratedSchemaTable<TName extends string> = TName extends GeneratedSchemaTableName ? GeneratedSchemaTables[TName] : TableDefinition<TName, TableColumnsShape>;
+declare function registerGeneratedTables<TTables extends Record<string, TableDefinition>>(tables: TTables): TTables;
+declare function defineGeneratedTable<TName extends string, TColumns extends Record<string, ColumnInput>>(tableName: TName, columns: TColumns, options?: {
+    indexes?: readonly TableIndexDefinition[];
+}): BoundTableDefinition<TName, TColumns>;
+declare function clearGeneratedTables(): void;
+declare function getGeneratedTableDefinition<TName extends string>(tableName: TName): GeneratedSchemaTable<TName> | undefined;
+declare function resolveGeneratedTableDefinition<TTables extends Record<string, TableDefinition>, TName extends Extract<keyof TTables, string>>(tableName: TName, tables: TTables): TTables[TName];
+declare function resolveGeneratedTableDefinition<TName extends string>(tableName: TName, tables: Partial<Record<string, TableDefinition>>): GeneratedSchemaTable<TName>;
+declare function listGeneratedTableDefinitions(): readonly TableDefinition[];
+declare function renderGeneratedSchemaPlaceholder(): string;
+declare function renderGeneratedSchemaModule(tables: readonly TableDefinition[]): string;
+
+type EntityConstructor = {
+    new <TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap>(repository: ModelRepositoryLike<TTable, EmptyScopeMap, TRelations>, attributes: Partial<ModelRecord<TTable>>, exists?: boolean): Entity<TTable, TRelations>;
+    prototype: EntityBase<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;
+    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;
+    toJSON(): ModelRecord<TTable>;
+    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<this & 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<this & 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[];
+    }>;
+    private initializeModelProperties;
+}
+type Entity<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = EntityBase<TTable, TRelations> & ModelRecord<TTable>;
+declare const Entity: EntityConstructor;
+
+/**
+ * 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;
+}
+declare const DEFAULT_CAPABILITIES: DatabaseCapabilities;
+declare function createCapabilities(overrides?: Partial<DatabaseCapabilities>): DatabaseCapabilities;
+
+interface SecurityPolicy {
+    allowUnsafeRawSql: boolean;
+    debugSqlInLogs: boolean;
+    maxQueryComplexity?: number;
+    redactBindingsInLogs: boolean;
+    maxLoggedBindings: number;
+}
+declare const DEFAULT_SECURITY_POLICY: SecurityPolicy;
+declare function createSecurityPolicy(overrides?: Partial<SecurityPolicy>): SecurityPolicy;
+declare function redactBindings(bindings: readonly unknown[], policy: SecurityPolicy): unknown[];
+declare function redactSql(sql: string, policy: SecurityPolicy): string;
+
+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 function createSchemaRegistry(): SchemaRegistry;
+
+declare class ModelRegistry {
+    private readonly models;
+    register(reference: ModelDefinitionLike): AnyModelDefinition;
+    has(name: string): boolean;
+    get(name: string): AnyModelDefinition | undefined;
+    list(): readonly AnyModelDefinition[];
+    clear(): void;
+}
+declare function createModelRegistry(): ModelRegistry;
+
+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;
+}
+declare function createQueryScheduler(options: QuerySchedulerOptions): QueryScheduler;
+
+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;
+}
+
+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 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;
+}
+interface InsertQueryPlan {
+    readonly kind: 'insert';
+    readonly source: QuerySource;
+    readonly ignoreConflicts: boolean;
+    readonly values: readonly Record<string, unknown>[];
+}
+interface UpsertQueryPlan {
+    readonly kind: 'upsert';
+    readonly source: QuerySource;
+    readonly values: readonly Record<string, unknown>[];
+    readonly uniqueBy: readonly string[];
+    readonly updateColumns: readonly string[];
+}
+interface UpdateQueryPlan {
+    readonly kind: 'update';
+    readonly source: QuerySource;
+    readonly predicates: readonly QueryPredicateNode[];
+    readonly values: Readonly<Record<string, QueryUpdateValue>>;
+}
+interface DeleteQueryPlan {
+    readonly kind: 'delete';
+    readonly source: QuerySource;
+    readonly predicates: readonly QueryPredicateNode[];
+}
+type QueryPlan = SelectQueryPlan | InsertQueryPlan | UpsertQueryPlan | UpdateQueryPlan | DeleteQueryPlan;
+interface QueryJsonUpdateOperation {
+    readonly kind: 'json-set';
+    readonly path: readonly string[];
+    readonly value: unknown;
+}
+type QueryUpdateValue = unknown | QueryJsonUpdateOperation | readonly QueryJsonUpdateOperation[];
+declare function createTableSource(table: string | TableDefinition): QuerySource;
+declare function createSelectQueryPlan(source: QuerySource): SelectQueryPlan;
+declare function withSelections(plan: SelectQueryPlan, columns: readonly string[]): SelectQueryPlan;
+declare function withPredicate(plan: SelectQueryPlan, predicate: QueryPredicateNode): SelectQueryPlan;
+declare function withOrderBy(plan: SelectQueryPlan, orderBy: QueryOrderBy): SelectQueryPlan;
+declare function withLimit(plan: SelectQueryPlan, limit?: number): SelectQueryPlan;
+declare function withOffset(plan: SelectQueryPlan, offset?: number): SelectQueryPlan;
+declare function createInsertQueryPlan(source: QuerySource, values: readonly Record<string, unknown>[], options?: {
+    ignoreConflicts?: boolean;
+}): InsertQueryPlan;
+declare function createUpdateQueryPlan(source: QuerySource, predicates: readonly QueryPredicateNode[], values: Readonly<Record<string, unknown>>): UpdateQueryPlan;
+declare function createDeleteQueryPlan(source: QuerySource, predicates: readonly QueryPredicateNode[]): DeleteQueryPlan;
+
+type SelectRow<TTableOrName extends string | TableDefinition> = TTableOrName extends TableDefinition ? InferSelect<TTableOrName> : Record<string, unknown>;
+type TableReference = string | TableDefinition;
+type BuilderCallback$2<TBuilder> = (query: TBuilder) => unknown;
+type ValueBuilderCallback$2<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$1<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 source;
+    private readonly plan;
+    constructor(table: TTableOrName, connection: DatabaseContext, plan?: SelectQueryPlan);
+    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$2<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    where(column: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    orWhere(callback: BuilderCallback$2<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    orWhere(column: JsonColumnPath<TTableOrName>, operator: QueryOperator | unknown, value?: unknown): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    private whereGroupWithBoolean;
+    whereNot(callback: BuilderCallback$2<TableQueryBuilder<TTableOrName, SelectRow<TTableOrName>>>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    orWhereNot(callback: BuilderCallback$2<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$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, compareTo: ColumnReference$1<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$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference$1<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    leftJoin(table: string, leftColumn: ColumnReference$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference$1<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    rightJoin(table: string, leftColumn: ColumnReference$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference$1<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    joinSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string, leftColumn: ColumnReference$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference$1<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    leftJoinSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string, leftColumn: ColumnReference$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference$1<TTableOrName>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    rightJoinSub(query: TableQueryBuilder<TableDefinition, Record<string, unknown>>, alias: string, leftColumn: ColumnReference$1<TTableOrName>, operator: Exclude<QueryOperator, 'in' | 'not in' | 'between' | 'not between'>, rightColumn: ColumnReference$1<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$2<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>, defaultCallback?: ValueBuilderCallback$2<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    unless<TValue>(value: TValue, callback: ValueBuilderCallback$2<TableQueryBuilder<TTableOrName, TSelectedRow>, TValue>, defaultCallback?: ValueBuilderCallback$2<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>;
+    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 getCompiler;
+    private getUnpaginatedRows;
+    private resolvePrimaryKeyColumn;
+    private normalizeOperatorValue;
+    private adjustNumericColumn;
+    private whereMultiColumns;
+    private whereFullTextWithBoolean;
+    private whereVectorSimilarToWithBoolean;
+    private assertPositiveInteger;
+    private normalizePaginationParameterName;
+    private prepareCursorPaginationQuery;
+    private encodeCursor;
+    private decodeCursor;
+    private aggregateNumeric;
+    private extractNumericValues;
+    private normalizeUpdateValues;
+    private normalizeWriteRecord;
+    private normalizeWriteValueForColumn;
+    private normalizePredicateValueForColumn;
+}
+
+type CollectionLoadedItem<TItem, TTable extends TableDefinition, TRelations extends RelationMap, TPaths extends readonly ModelRelationPath<TRelations>[]> = TItem & ResolveEagerLoads<TRelations, TPaths> & (TItem extends {
+    toJSON(): infer TSerialized;
+} ? {
+    toJSON(): TSerialized & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
+} : {
+    toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
+});
+type CollectionItem<TCollection, TTable extends TableDefinition, TRelations extends RelationMap> = TCollection extends readonly (infer TItem)[] ? TItem : Entity<TTable, TRelations>;
+interface ModelCollectionMethods<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> {
+    modelKeys(): unknown[];
+    toQuery(): ModelQueryBuilder<TTable, TRelations>;
+    load<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<this & Array<CollectionLoadedItem<CollectionItem<this, TTable, TRelations>, TTable, TRelations, TPaths>>>;
+    loadMissing<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<this & Array<CollectionLoadedItem<CollectionItem<this, TTable, TRelations>, TTable, TRelations, TPaths>>>;
+    loadMorph(relation: ModelRelationName<TRelations>, mapping: ModelMorphLoadMap): Promise<ModelCollection<TTable, TRelations>>;
+    loadCount(...relations: readonly ModelRelationName<TRelations>[]): Promise<ModelCollection<TTable, TRelations>>;
+    loadExists(...relations: readonly ModelRelationName<TRelations>[]): Promise<ModelCollection<TTable, TRelations>>;
+    loadSum<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations>>;
+    loadAvg<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations>>;
+    loadMin<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations>>;
+    loadMax<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<ModelCollection<TTable, TRelations>>;
+    fresh(): Promise<ModelCollection<TTable, TRelations>>;
+    append(...keys: readonly string[]): ModelCollection<TTable, TRelations>;
+    withoutAppends(): ModelCollection<TTable, TRelations>;
+    makeVisible(...keys: readonly string[]): ModelCollection<TTable, TRelations>;
+    makeHidden(...keys: readonly string[]): ModelCollection<TTable, TRelations>;
+    setVisible(keys: readonly string[]): ModelCollection<TTable, TRelations>;
+    setHidden(keys: readonly string[]): ModelCollection<TTable, TRelations>;
+}
+type ModelCollection<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = Array<Entity<TTable, TRelations>> & ModelCollectionMethods<TTable, TRelations>;
+declare function createModelCollection<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap>(items: readonly Entity<TTable, TRelations>[]): ModelCollection<TTable, TRelations>;
+
+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$1 = (query: ModelQueryBuilder<TableDefinition>) => unknown;
+type RelationFilter$1 = {
+    relation: string;
+    negate: boolean;
+    constraint?: RelationConstraint$1;
+    boolean?: 'and' | 'or';
+    morphTypes?: readonly string[];
+};
+type EagerLoad$1 = {
+    relation: string;
+    constraint?: RelationConstraint$1;
+};
+type AggregateLoad$1 = {
+    relation: string;
+    kind: RelationAggregateKind;
+    constraint?: RelationConstraint$1;
+    column?: string;
+    alias?: string;
+};
+declare function getModelDefinition<TTable extends TableDefinition>(reference: ModelDefinitionLike | ModelDefinition<TTable> | ModelReference<TTable>): ModelDefinition<TTable>;
+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(items: readonly Entity<TTable>[]): ModelCollection<TTable>;
+    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$1)[], missingOnly?: boolean): Promise<void>;
+    filterByRelations(entities: readonly Entity<TTable>[], filters: readonly RelationFilter$1[]): Promise<Array<Entity<TTable>>>;
+    applyRelationExistenceFilter(query: TableQueryBuilder<TTable, Record<string, unknown>>, filter: RelationFilter$1): TableQueryBuilder<TTable, Record<string, unknown>>;
+    loadMorphRelations(entities: readonly Entity<TTable>[], relationName: string, mapping: Readonly<Record<string, string | readonly string[] | Readonly<Record<string, RelationConstraint$1>>>>): Promise<void>;
+    loadRelationAggregates(entities: readonly Entity<TTable>[], aggregates: readonly AggregateLoad$1[]): 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 BuilderCallback$1<TBuilder> = (query: TBuilder) => unknown;
+type ValueBuilderCallback$1<TBuilder, TValue> = (query: TBuilder, value: TValue) => unknown;
+type RelationConstraint = (query: ModelQueryBuilder<TableDefinition>) => unknown;
+type SubqueryBuilder$1<TSubTable extends TableDefinition = TableDefinition> = TableQueryBuilder<TSubTable, Record<string, unknown>> | ModelQueryBuilder<TSubTable>;
+type RelationFilter = {
+    relation: string;
+    negate: boolean;
+    constraint?: RelationConstraint;
+    boolean?: 'and' | 'or';
+    morphTypes?: readonly string[];
+};
+type MorphEntityTarget$1 = {
+    exists(): boolean;
+    getRepository(): {
+        definition: {
+            morphClass: string;
+            primaryKey: string;
+        };
+    };
+    get(key: string): unknown;
+};
+type MorphModelTarget$1 = {
+    definition?: {
+        morphClass?: string;
+    };
+};
+type MorphTypeSelector$1 = string | MorphModelTarget$1 | MorphEntityTarget$1 | null;
+type EagerLoad = {
+    relation: string;
+    constraint?: RelationConstraint;
+};
+type AggregateLoad = {
+    relation: string;
+    kind: 'count' | 'exists' | 'sum' | 'avg' | 'min' | 'max';
+    constraint?: RelationConstraint;
+    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[], relationFilters?: readonly RelationFilter[], aggregateLoads?: readonly AggregateLoad[], queryCasts?: Readonly<Record<string, ModelCastDefinition>>);
+    getConnection(): DatabaseContext;
+    getConnectionName(): string;
+    getTableQueryBuilder(): TableQueryBuilder<TTable, Record<string, unknown>>;
+    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$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereNotExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereNotExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'like', subquery: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'like', subquery: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereInSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, subquery: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereNotInSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, subquery: SubqueryBuilder$1<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$1<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    addSelectSub<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<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$1<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    leftJoinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    rightJoinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    joinLateral<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    leftJoinLateral<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    union<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<TSubTable>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    unionAll<TSubTable extends TableDefinition>(query: SubqueryBuilder$1<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): ModelQueryBuilder<TTable, TRelations, TLoaded & ResolveEagerLoads<TRelations, readonly [TPath]>>;
+    with(relations: Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint>>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    has(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orHas(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereHas(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereHas(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint): 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): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereDoesntHave(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint): 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: string | {
+        definition?: {
+            morphClass?: string;
+        };
+    } | readonly (string | {
+        definition?: {
+            morphClass?: string;
+        };
+    })[], column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: string | {
+        definition?: {
+            morphClass?: string;
+        };
+    } | readonly (string | {
+        definition?: {
+            morphClass?: string;
+        };
+    })[], column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereBelongsTo<TRelated extends TableDefinition>(relatedEntity: Entity<TRelated>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereBelongsTo<TRelated extends TableDefinition>(relatedEntity: Entity<TRelated>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereNotMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereNotMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    withWhereHas<TPath extends ModelRelationPath<TRelations>>(relation: TPath, constraint?: RelationConstraint): 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>>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    withExists(...relations: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    withExists(relations: Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint>>>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    withSum<TRelationPath extends ModelRelationPath<TRelations>>(first: TRelationPath | Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraint>>>, 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>>>, 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>>>, 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>>>, 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>;
+    get(): Promise<ModelCollection<TTable, TRelations> & Array<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
+    first(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded> | undefined>;
+    sole(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded>>;
+    paginate(perPage?: number, page?: number, options?: PaginationOptions): Promise<PaginatedResult<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
+    simplePaginate(perPage?: number, page?: number, options?: PaginationOptions): Promise<SimplePaginatedResult<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
+    cursorPaginate(perPage?: number, cursor?: string | null, options?: CursorPaginationOptions): Promise<CursorPaginatedResult<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
+    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>>;
+    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 normalizeMorphedToTarget;
+    private isMorphEntityTarget;
+    private getMorphTargetLabels;
+    private assertMorphToRelation;
+    private normalizeColumnAggregateLoads;
+    private parseAggregateRelation;
+    private resolveBelongsToRelation;
+    private resolveBelongsToRelationName;
+    private extractNumericValues;
+    private getUnpaginatedEntities;
+    private encodeCursor;
+    private decodeCursor;
+    private assertPositiveInteger;
+    private normalizePaginationParameterName;
+    private prepareCursorPaginationQuery;
+}
+
+type ModelInsertPayload<TTable extends TableDefinition> = Partial<InferInsert<TTable>>;
+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 {
+    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;
+    withPivot(...columns: readonly PivotTableColumnName<TPivotTable>[]): BelongsToManyRelationDefinition<TRelated, TPivotTable>;
+    wherePivot(column: PivotTableColumnName<TPivotTable>, operator: unknown, value?: unknown): BelongsToManyRelationDefinition<TRelated, TPivotTable>;
+    orderByPivot(column: PivotTableColumnName<TPivotTable>, direction?: 'asc' | 'desc'): BelongsToManyRelationDefinition<TRelated, TPivotTable>;
+    as(accessor: string): BelongsToManyRelationDefinition<TRelated, TPivotTable>;
+    using(model: () => ModelDefinitionLike): BelongsToManyRelationDefinition<TRelated, TPivotTable>;
+}
+interface MorphToManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TPivotTable extends string | TableDefinition = string | TableDefinition> extends ScopedRelationDefinition {
+    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;
+    withPivot(...columns: readonly PivotTableColumnName<TPivotTable>[]): MorphToManyRelationDefinition<TRelated, TPivotTable>;
+    wherePivot(column: PivotTableColumnName<TPivotTable>, operator: unknown, value?: unknown): MorphToManyRelationDefinition<TRelated, TPivotTable>;
+    orderByPivot(column: PivotTableColumnName<TPivotTable>, direction?: 'asc' | 'desc'): MorphToManyRelationDefinition<TRelated, TPivotTable>;
+    as(accessor: string): MorphToManyRelationDefinition<TRelated, TPivotTable>;
+    using(model: () => ModelDefinitionLike): MorphToManyRelationDefinition<TRelated, TPivotTable>;
+}
+interface MorphedByManyRelationDefinition<TRelated extends ModelDefinitionLike = ModelDefinitionLike, TPivotTable extends string | TableDefinition = string | TableDefinition> extends ScopedRelationDefinition {
+    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;
+    withPivot(...columns: readonly PivotTableColumnName<TPivotTable>[]): MorphedByManyRelationDefinition<TRelated, TPivotTable>;
+    wherePivot(column: PivotTableColumnName<TPivotTable>, operator: unknown, value?: unknown): MorphedByManyRelationDefinition<TRelated, TPivotTable>;
+    orderByPivot(column: PivotTableColumnName<TPivotTable>, direction?: 'asc' | 'desc'): MorphedByManyRelationDefinition<TRelated, TPivotTable>;
+    as(accessor: string): MorphedByManyRelationDefinition<TRelated, TPivotTable>;
+    using(model: () => ModelDefinitionLike): MorphedByManyRelationDefinition<TRelated, TPivotTable>;
+}
+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;
+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>>;
+/**
+ * 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], ResolveRelationEntity<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> = Entity<TTable, TRelations> & 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> = (items: readonly Entity<TTable, TRelations>[]) => ModelCollection<TTable, TRelations>;
+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 DefineModelOptions<TTable extends TableDefinition = TableDefinition, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap> {
+    name?: string;
+    primaryKey?: ModelAttributeKey<TTable>;
+    connectionName?: string;
+    morphClass?: string;
+    with?: readonly string[];
+    pendingAttributes?: Partial<InferInsert<TTable>>;
+    preventLazyLoading?: boolean;
+    preventAccessingMissingAttributes?: boolean;
+    automaticEagerLoading?: boolean;
+    timestamps?: boolean;
+    createdAtColumn?: ModelAttributeKey<TTable>;
+    updatedAtColumn?: ModelAttributeKey<TTable>;
+    fillable?: readonly (ModelAttributeKey<TTable> | '*')[];
+    guarded?: readonly (ModelAttributeKey<TTable> | '*')[];
+    scopes?: TScopes;
+    globalScopes?: ModelScopeMap<TTable>;
+    relations?: TRelations;
+    casts?: Record<string, ModelCastDefinition>;
+    accessors?: Record<string, ModelAccessor>;
+    mutators?: Record<string, ModelMutator>;
+    hidden?: readonly string[];
+    visible?: readonly string[];
+    appended?: readonly string[];
+    serializeDate?: ModelDateSerializer;
+    collection?: ModelCollectionFactory<TTable>;
+    prunable?: ModelPrunableDefinition<TTable>;
+    massPrunable?: boolean;
+    touches?: readonly string[];
+    traits?: readonly ModelTrait<TTable>[];
+    uniqueIds?: readonly ModelAttributeKey<TTable>[];
+    newUniqueId?: () => string;
+    replicationExcludes?: readonly string[];
+    softDeletes?: boolean;
+    deletedAtColumn?: ModelAttributeKey<TTable>;
+    events?: Partial<Record<ModelLifecycleEventName, ModelLifecycleEventHandler | readonly ModelLifecycleEventHandler[]>>;
+    observers?: readonly unknown[];
+}
+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 DynamicRelationResolver = () => RelationDefinition;
+type ModelMorphLoadMap = Readonly<Record<string, string | readonly string[] | Readonly<Record<string, RelationConstraintDefinition>>>>;
+type ModelScopeArgs<TScope> = TScope extends (query: unknown, ...args: infer TArgs) => unknown ? TArgs : never;
+type ModelScopeMethods<TTable extends TableDefinition, TScopes extends ModelScopesDefinition, TRelations extends RelationMap = RelationMap> = {
+    [K in keyof TScopes]: TScopes[K] extends (query: ModelQueryBuilder<TTable, TRelations>, ...args: infer TArgs) => ModelQueryBuilder<TTable, TRelations> ? (...args: TArgs) => ModelQueryBuilder<TTable, TRelations> : never;
+};
+interface ModelRepositoryLike<TTable extends TableDefinition = TableDefinition, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap> {
+    readonly definition: ModelDefinition<TTable, TScopes, TRelations>;
+    getConnection(): DatabaseContext;
+}
+
+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;
+}
+declare function createFactoryService(): FactoryService;
+
+type ColumnShapeInput$1 = Record<string, ColumnInput>;
+type WithColumn<TColumns extends ColumnShapeInput$1, 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$1> = TColumns & {
+    created_at: TimestampColumn;
+    updated_at: TimestampColumn;
+};
+type WithSoftDeletes<TColumns extends ColumnShapeInput$1, TColumnName extends string> = TColumns & {
+    [K in TColumnName]: NullableTimestampColumn;
+};
+type WithMorphColumns<TColumns extends ColumnShapeInput$1, TMorphName extends string, TIdColumn extends AnyColumnBuilder> = TColumns & {
+    [K in `${TMorphName}_type`]: StringColumn;
+} & {
+    [K in `${TMorphName}_id`]: TIdColumn;
+};
+type WithNullableMorphColumns<TColumns extends ColumnShapeInput$1, TMorphName extends string, TIdColumn extends AnyColumnBuilder> = TColumns & {
+    [K in `${TMorphName}_type`]: NullableStringColumn;
+} & {
+    [K in `${TMorphName}_id`]: ReturnType<TIdColumn['nullable']>;
+};
+type ColumnReference = {
+    builder: AnyColumnBuilder;
+};
+declare class TableCreateColumnBuilder<TName extends string, TColumns extends ColumnShapeInput$1> {
+    protected readonly root: TableDefinitionBuilder<TName, TColumns>;
+    protected readonly builderRef: ColumnReference;
+    constructor(root: TableDefinitionBuilder<TName, TColumns>, builderRef: ColumnReference);
+    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>;
+    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>>>>;
+    index(columns: readonly string[], name?: string): TableDefinitionBuilder<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>>>;
+}
+declare class TableCreateForeignIdBuilder<TName extends string, TColumns extends ColumnShapeInput$1> extends TableCreateColumnBuilder<TName, TColumns> {
+    private readonly columnName;
+    private referenceTable?;
+    private referenceColumn;
+    private onDeleteAction?;
+    private onUpdateAction?;
+    constructor(root: TableDefinitionBuilder<TName, TColumns>, builderRef: ColumnReference, 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 applyReference;
+}
+declare class TableCreateForeignKeyBuilder<TName extends string, TColumns extends ColumnShapeInput$1> {
+    private readonly root;
+    private readonly builderRef;
+    private readonly columnName;
+    private referenceTable?;
+    private referenceColumn;
+    private onDeleteAction?;
+    private onUpdateAction?;
+    constructor(root: TableDefinitionBuilder<TName, TColumns>, builderRef: ColumnReference, 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;
+    build(): BoundTableDefinition<TName, TColumns>;
+    private applyReference;
+}
+declare class TableDefinitionBuilder<TName extends string, TColumns extends ColumnShapeInput$1 = 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;
+    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;
+}
+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;
+    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 foreignOperation?;
+    private referenceTable?;
+    private referenceColumn;
+    private onDeleteAction?;
+    private onUpdateAction?;
+    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 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;
+}
+declare function createSchemaService(connection: DatabaseContext): SchemaService;
+
+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 MigrationTemplateKind = 'blank' | 'create_table' | 'alter_table' | 'drop_table';
+interface MigrationTemplateOptions {
+    date?: Date;
+    kind?: MigrationTemplateKind;
+    tableName?: string;
+}
+interface GeneratedMigrationTemplate {
+    readonly fileName: string;
+    readonly migrationName: string;
+    readonly kind: MigrationTemplateKind;
+    readonly tableName?: string;
+    readonly contents: string;
+}
+
+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 normalizeMigratedAt;
+    private createMigrationLog;
+    private runExclusively;
+}
+declare function createMigrationService(connection: DatabaseContext, migrations?: readonly MigrationDefinition[]): MigrationService;
+
+declare class ModelEventService {
+    areEventsMuted(): boolean;
+    withoutEvents<T>(callback: () => T | Promise<T>): Promise<T>;
+    areGuardsDisabled(): boolean;
+    withoutGuards<T>(callback: () => T | Promise<T>): Promise<T>;
+}
+declare function createModelEventService(): ModelEventService;
+
+type RuntimeState = {
+    savepointCounter: number;
+    scheduler: QueryScheduler;
+};
+type ScopeState = {
+    kind: TransactionScopeKind;
+    depth: number;
+    savepointName?: string;
+};
+type TransactionCallbackState = {
+    afterCommit: TransactionCallback[];
+    afterRollback: TransactionCallback[];
+};
+type ContextInternals = {
+    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 _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;
+    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 _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;
+}
+declare function createDatabase(options: DatabaseContextOptions): DatabaseContext;
+
+declare function unsafeSql(sql: string, bindings?: readonly unknown[], source?: string): UnsafeStatement;
+
+declare class DatabaseError extends Error {
+    readonly name: string;
+    readonly code: string;
+    readonly cause?: unknown;
+    constructor(message: string, code?: string, cause?: unknown);
+}
+declare class ConfigurationError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class CompilerError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class CapabilityError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SecurityError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SchemaError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class RelationError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class TransactionError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class HydrationError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+declare class ModelNotFoundException extends DatabaseError {
+    readonly statusCode = 404;
+    readonly model: string;
+    constructor(model: string, message?: string, cause?: unknown);
+}
+declare class SerializationError extends DatabaseError {
+    constructor(message: string, cause?: unknown);
+}
+
+interface ConnectionManagerOptions {
+    defaultConnection: string;
+    connections: Record<string, DatabaseContext | DatabaseContextOptions>;
+}
+declare class ConnectionManager {
+    private readonly defaultConnection;
+    private readonly definitions;
+    private readonly resolved;
+    constructor(options: ConnectionManagerOptions);
+    getDefaultConnectionName(): string;
+    getConnectionNames(): string[];
+    hasConnection(name: string): boolean;
+    connection(name?: string): DatabaseContext;
+    initializeAll(): Promise<void>;
+    disconnectAll(): Promise<void>;
+    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName?: string): Promise<T>;
+}
+declare function createConnectionManager(options: ConnectionManagerOptions): ConnectionManager;
+
+declare class DatabaseFacade {
+    private manager?;
+    configure(manager: ConnectionManager): void;
+    reset(): void;
+    getManager(): ConnectionManager;
+    connection(name?: string): DatabaseContext;
+    table<TTable extends TableDefinition>(table: TTable, connectionName?: string): TableQueryBuilder<TTable>;
+    table(name: string, connectionName?: string): TableQueryBuilder<string>;
+    raw(sql: string, bindings?: readonly unknown[], source?: string): UnsafeStatement;
+    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName?: string, options?: DatabaseOperationOptions): Promise<T>;
+    afterCommit(callback: () => void | Promise<void>, connectionName?: string): void;
+    afterRollback(callback: () => void | Promise<void>, connectionName?: string): void;
+    unsafeQuery<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: UnsafeStatement, connectionName?: string, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
+    unsafeExecute(statement: UnsafeStatement, connectionName?: string, options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
+}
+declare const DB: DatabaseFacade;
+declare function configureDB(manager: ConnectionManager): void;
+declare function resetDB(): void;
+
+interface ActiveConnectionScope {
+    connectionName: string;
+    connection: DatabaseContext;
+}
+declare class AsyncConnectionContext {
+    private readonly storage;
+    run<T>(scope: ActiveConnectionScope, callback: () => T): T;
+    getActive(): ActiveConnectionScope | undefined;
+}
+declare const connectionAsyncContext: AsyncConnectionContext;
+
+interface SQLiteStatementLike {
+    all(...params: readonly unknown[]): Record<string, unknown>[];
+    run(...params: readonly unknown[]): {
+        changes?: number;
+        lastInsertRowid?: unknown;
+    };
+}
+interface SQLiteDatabaseLike {
+    prepare(sql: string): SQLiteStatementLike;
+    exec(sql: string): unknown;
+    close(): unknown;
+}
+interface SQLiteAdapterOptions {
+    filename?: string;
+    database?: SQLiteDatabaseLike;
+    createDatabase?: (filename: string) => SQLiteDatabaseLike;
+}
+declare class SQLiteAdapter implements DriverAdapter {
+    private database?;
+    private connected;
+    private readonly filename;
+    private readonly createDatabaseInstance;
+    constructor(options?: SQLiteAdapterOptions);
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    createSavepoint(name: string): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    private getDatabase;
+    private normalizeSavepointName;
+    private invokeStatement;
+    private isBindingArityError;
+}
+declare function createSQLiteAdapter(options?: SQLiteAdapterOptions): SQLiteAdapter;
+
+interface PostgresQueryableLike {
+    query(sql: string, bindings?: readonly unknown[]): Promise<QueryResult<Record<string, unknown>> | {
+        rows: Record<string, unknown>[];
+        rowCount?: number | null;
+    }>;
+}
+interface PostgresClientLike extends PostgresQueryableLike {
+    release?(): void;
+    end?(): Promise<void>;
+}
+interface PostgresPoolLike extends PostgresQueryableLike {
+    connect(): Promise<PostgresClientLike>;
+    end(): Promise<void>;
+}
+interface PostgresAdapterOptions {
+    connectionString?: string;
+    config?: PoolConfig;
+    client?: PostgresClientLike;
+    pool?: PostgresPoolLike;
+    createPool?: (config?: PoolConfig) => PostgresPoolLike;
+}
+declare class PostgresAdapter implements DriverAdapter {
+    private pool?;
+    private readonly directClient?;
+    private readonly createPoolInstance?;
+    private readonly config?;
+    private connected;
+    private transactionClient?;
+    private leasedTransactionClient;
+    private readonly transactionScope;
+    constructor(options?: PostgresAdapterOptions);
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    createSavepoint(name: string): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    private getQueryable;
+    private leaseTransactionClient;
+    private requireTransactionClient;
+    private releaseTransactionClient;
+    private releaseScopedTransaction;
+    private normalizeSavepointName;
+}
+declare function createPostgresAdapter(options?: PostgresAdapterOptions): PostgresAdapter;
+
+interface MySQLQueryableLike {
+    query(sql: string, bindings?: readonly unknown[]): Promise<readonly [unknown, unknown]>;
+}
+interface MySQLClientLike extends MySQLQueryableLike {
+    release?(): void;
+    end?(): Promise<void>;
+}
+interface MySQLPoolLike extends MySQLQueryableLike {
+    getConnection(): Promise<MySQLClientLike>;
+    end(): Promise<void>;
+}
+interface MySQLAdapterOptions {
+    uri?: string;
+    config?: PoolOptions;
+    client?: MySQLClientLike;
+    pool?: MySQLPoolLike;
+    createPool?: (config: PoolOptions) => MySQLPoolLike;
+}
+declare class MySQLAdapter implements DriverAdapter {
+    private pool?;
+    private readonly directClient?;
+    private readonly createPoolInstance?;
+    private readonly config;
+    private connected;
+    private transactionClient?;
+    private leasedTransactionClient;
+    private readonly transactionScope;
+    constructor(options?: MySQLAdapterOptions);
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    createSavepoint(name: string): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    private getQueryable;
+    private leaseTransactionClient;
+    private requireTransactionClient;
+    private releaseTransactionClient;
+    private releaseScopedTransaction;
+    private normalizeSavepointName;
+}
+declare function createMySQLAdapter(options?: MySQLAdapterOptions): MySQLAdapter;
+
+type SupportedDatabaseDriver = 'sqlite' | 'postgres' | 'mysql';
+interface RuntimeConnectionConfig {
+    driver?: SupportedDatabaseDriver | string;
+    url?: string;
+    host?: string;
+    port?: number | string;
+    username?: string;
+    password?: string;
+    database?: string;
+    filename?: string;
+    schema?: string;
+    ssl?: boolean | Record<string, unknown>;
+    logging?: boolean;
+}
+interface RuntimeDatabaseConfig {
+    defaultConnection?: string;
+    connections?: Record<string, RuntimeConnectionConfig | string>;
+}
+interface RuntimeHoloConfig {
+    appEnv?: 'production' | 'development' | 'test';
+    appDebug?: boolean;
+    appUrl?: string;
+}
+interface RuntimeConfigInput {
+    holo?: RuntimeHoloConfig;
+    db?: RuntimeDatabaseConfig;
+}
+type RuntimeAdapterConnectionConfig = {
+    url?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    database?: string;
+    ssl?: boolean | Record<string, unknown>;
+};
+declare function isSupportedDatabaseDriver(value: string): value is SupportedDatabaseDriver;
+declare function parseDatabaseDriver(value: string | undefined, fallback: SupportedDatabaseDriver): SupportedDatabaseDriver;
+declare function createDialect(driver: SupportedDatabaseDriver): Dialect;
+declare function createAdapter(driver: SupportedDatabaseDriver, connection: string | RuntimeAdapterConnectionConfig): SQLiteAdapter | PostgresAdapter | MySQLAdapter;
+declare function createRuntimeLogger(enabled: boolean): DatabaseLogger | undefined;
+declare function createRuntimeConnectionOptions(driver: SupportedDatabaseDriver, connection: string | RuntimeAdapterConnectionConfig, dbLogging: boolean, schemaName?: string, connectionName?: string): DatabaseContextOptions;
+declare function resolveRuntimeConnectionManagerOptions(config: RuntimeConfigInput): ConnectionManager;
+
+declare function validateQueryPlan(plan: QueryPlan): void;
+
+type IdentifierQuoter$1 = (identifier: string) => string;
+type PlaceholderFactory = (index: number) => string;
+declare class SQLQueryCompiler {
+    protected readonly quoteIdentifier: IdentifierQuoter$1;
+    protected readonly createPlaceholder: PlaceholderFactory;
+    constructor(quoteIdentifier: IdentifierQuoter$1, createPlaceholder: PlaceholderFactory);
+    compile(plan: QueryPlan): CompiledStatement;
+    protected compileSelect(plan: SelectQueryPlan): CompiledStatement;
+    protected compileSelectSql(plan: SelectQueryPlan, bindings: unknown[]): string;
+    protected compileInsert(plan: InsertQueryPlan): CompiledStatement;
+    protected compileUpsert(plan: UpsertQueryPlan): CompiledStatement;
+    protected compileUpdate(plan: UpdateQueryPlan): CompiledStatement;
+    protected compileDelete(plan: DeleteQueryPlan): CompiledStatement;
+    protected withMetadata(statement: CompiledStatement, metadata: CompiledStatementMetadata): CompiledStatement;
+    protected createSelectMetadata(plan: SelectQueryPlan): CompiledStatementMetadata;
+    protected createWriteMetadata(kind: 'insert' | 'update' | 'upsert' | 'delete', tableName: string, complexity: number): CompiledStatementMetadata;
+    protected calculatePlanComplexity(plan: QueryPlan): number;
+    private selectionComplexity;
+    private predicateComplexity;
+    protected planContainsRawSql(plan: SelectQueryPlan): boolean;
+    protected predicateContainsRawSql(predicate: QueryPredicateNode): boolean;
+    protected compilePredicates(predicates: readonly QueryPredicateNode[], bindings: unknown[]): string;
+    protected compileJoins(joins: readonly QueryJoinClause[], bindings: unknown[]): string;
+    protected compileUnions(unions: SelectQueryPlan['unions'], bindings: unknown[]): string;
+    protected compileHaving(clauses: readonly QueryHavingClause[], bindings: unknown[]): string;
+    protected compilePredicate(predicate: QueryPredicateNode, bindings: unknown[]): string;
+    protected compileDatePredicate(predicate: QueryDatePredicate, placeholder: string): string;
+    protected compileJsonPredicate(predicate: QueryJsonPredicate, _bindings: unknown[]): string;
+    protected compileFullTextPredicate(predicate: QueryFullTextPredicate, _bindings: unknown[]): string;
+    protected compileVectorPredicate(predicate: QueryVectorPredicate, bindings: unknown[]): string;
+    protected compileOrderBy(orderBy: SelectQueryPlan['orderBy'][number], bindings: unknown[]): string;
+    protected compileRandomOrder(): string;
+    protected compileInsertPrefix(_plan: InsertQueryPlan): string;
+    protected compileInsertSuffix(_plan: InsertQueryPlan): string;
+    protected compileUpsertSuffix(plan: UpsertQueryPlan, _insertColumns: readonly string[]): string;
+    protected compileHavingExpression(expression: string): string;
+    protected compileColumnReference(reference: string): string;
+    protected compileTableReference(reference: string): string;
+    protected compileSource(source: SelectQueryPlan['source']): string;
+    protected compileJoinSource(join: QueryJoinClause, bindings: unknown[]): string;
+    protected compileLateralJoinSource(_subquery: string, _alias: string): string;
+    protected compileUpdateValue(column: string, value: QueryUpdateValue, bindings: unknown[]): string;
+    protected compileJsonUpdateOperations(column: string, _operations: readonly QueryJsonUpdateOperation[], _bindings: unknown[]): string;
+    protected compileVectorDistanceExpression(_column: string, _vector: readonly number[], _bindings: unknown[]): string;
+    protected compileLockClause(_lockMode: QueryLockMode): string;
+    protected escapeSqlString(value: string): string;
+    protected createSqlStringLiteral(value: string): string;
+    protected createJsonPathLiteral(path: readonly string[]): string;
+    protected createPostgresPathLiteral(path: readonly string[]): string;
+    protected isJsonUpdateOperation(value: QueryUpdateValue): value is QueryJsonUpdateOperation;
+    protected isUnsafeSelectPlan(plan: SelectQueryPlan): boolean;
+    protected isUnsafePredicate(predicate: QueryPredicateNode): boolean;
+    private compilePredicateSequence;
+    protected prefixPredicate(predicate: QueryPredicateNode, compiled: string, index: number): string;
+}
+
+declare class SQLiteQueryCompiler extends SQLQueryCompiler {
+    protected compileJsonPredicate(predicate: QueryJsonPredicate, bindings: unknown[]): string;
+    protected compileJsonUpdateOperations(column: string, operations: readonly QueryJsonUpdateOperation[], bindings: unknown[]): string;
+    protected compileDatePredicate(predicate: QueryDatePredicate, placeholder: string): string;
+    protected compileInsertPrefix(plan: InsertQueryPlan): string;
+}
+
+declare class PostgresQueryCompiler extends SQLQueryCompiler {
+    protected compileLateralJoinSource(subquery: string, alias: string): string;
+    protected compileLockClause(lockMode: QueryLockMode): string;
+    protected compileInsertSuffix(plan: InsertQueryPlan): string;
+    protected compileUpsertSuffix(plan: UpsertQueryPlan, insertColumns: readonly string[]): string;
+    protected compileJsonPredicate(predicate: QueryJsonPredicate, bindings: unknown[]): string;
+    protected compileJsonUpdateOperations(column: string, operations: readonly QueryJsonUpdateOperation[], bindings: unknown[]): string;
+    protected compileFullTextPredicate(predicate: QueryFullTextPredicate, bindings: unknown[]): string;
+    protected compileVectorDistanceExpression(column: string, vector: readonly number[], bindings: unknown[]): string;
+    protected compileDatePredicate(predicate: QueryDatePredicate, placeholder: string): string;
+}
+
+declare class MySQLQueryCompiler extends SQLQueryCompiler {
+    protected compileLateralJoinSource(subquery: string, alias: string): string;
+    protected compileLockClause(lockMode: QueryLockMode): string;
+    protected compileInsertPrefix(plan: InsertQueryPlan): string;
+    protected compileUpsertSuffix(plan: UpsertQueryPlan, insertColumns: readonly string[]): string;
+    protected compileRandomOrder(): string;
+    protected compileJsonPredicate(predicate: QueryJsonPredicate, bindings: unknown[]): string;
+    protected compileJsonUpdateOperations(column: string, operations: readonly QueryJsonUpdateOperation[], bindings: unknown[]): string;
+    protected compileFullTextPredicate(predicate: QueryFullTextPredicate, bindings: unknown[]): string;
+    protected compileDatePredicate(predicate: QueryDatePredicate, placeholder: string): string;
+}
+
+declare function createPaginator<T>(data: readonly T[], meta: Omit<PaginationMeta, 'pageName'> & {
+    pageName?: string;
+}): PaginatedResult<T>;
+declare function createSimplePaginator<T>(data: readonly T[], meta: Omit<SimplePaginationMeta, 'pageName'> & {
+    pageName?: string;
+}): SimplePaginatedResult<T>;
+declare function createCursorPaginator<T>(data: readonly T[], meta: {
+    perPage: number;
+    nextCursor: string | null;
+    prevCursor: string | null;
+    cursorName?: string;
+}): CursorPaginatedResult<T>;
+
+interface SchemaColumnMismatch {
+    readonly column: string;
+    readonly expected: {
+        readonly type: string;
+        readonly notNull: boolean;
+        readonly primaryKey: boolean;
+    };
+    readonly actual: {
+        readonly type: string;
+        readonly notNull: boolean;
+        readonly primaryKey: boolean;
+    };
+}
+interface SchemaIndexMismatch {
+    readonly index: string;
+    readonly expected: {
+        readonly unique: boolean;
+        readonly columns: readonly string[];
+    };
+    readonly actual: {
+        readonly unique: boolean;
+        readonly columns: readonly string[];
+    };
+}
+interface SchemaForeignKeyMismatch {
+    readonly foreignKey: string;
+    readonly expected: {
+        readonly table: string;
+        readonly from: string;
+        readonly to: string;
+        readonly onUpdate: string;
+        readonly onDelete: string;
+    };
+    readonly actual: {
+        readonly table: string;
+        readonly from: string;
+        readonly to: string;
+        readonly onUpdate: string;
+        readonly onDelete: string;
+    };
+}
+interface TableSchemaDiff {
+    readonly table: string;
+    readonly missingColumns: readonly string[];
+    readonly extraColumns: readonly string[];
+    readonly mismatchedColumns: readonly SchemaColumnMismatch[];
+    readonly missingIndexes: readonly string[];
+    readonly extraIndexes: readonly string[];
+    readonly mismatchedIndexes: readonly SchemaIndexMismatch[];
+    readonly missingForeignKeys: readonly string[];
+    readonly extraForeignKeys: readonly string[];
+    readonly mismatchedForeignKeys: readonly SchemaForeignKeyMismatch[];
+    readonly hasChanges: boolean;
+}
+interface SchemaDiff {
+    readonly missingTables: readonly string[];
+    readonly extraTables: readonly string[];
+    readonly tables: readonly TableSchemaDiff[];
+    readonly hasChanges: boolean;
+}
+declare function diffSchema(schema: SchemaService, tables: readonly TableDefinition[]): Promise<SchemaDiff>;
+
+interface CreateTableOperation {
+    readonly kind: 'createTable';
+    readonly table: TableDefinition;
+}
+interface DropTableOperation {
+    readonly kind: 'dropTable';
+    readonly tableName: string;
+}
+interface RenameTableOperation {
+    readonly kind: 'renameTable';
+    readonly fromTableName: string;
+    readonly toTableName: string;
+}
+interface CreateIndexOperation {
+    readonly kind: 'createIndex';
+    readonly tableName: string;
+    readonly index: {
+        readonly name?: string;
+        readonly columns: readonly string[];
+        readonly unique: boolean;
+    };
+}
+interface DropIndexOperation {
+    readonly kind: 'dropIndex';
+    readonly tableName: string;
+    readonly indexName: string;
+}
+interface RenameIndexOperation {
+    readonly kind: 'renameIndex';
+    readonly tableName: string;
+    readonly fromIndexName: string;
+    readonly toIndexName: string;
+}
+interface AddColumnOperation {
+    readonly kind: 'addColumn';
+    readonly tableName: string;
+    readonly column: AnyColumnDefinition;
+}
+interface DropColumnOperation {
+    readonly kind: 'dropColumn';
+    readonly tableName: string;
+    readonly columnName: string;
+}
+interface RenameColumnOperation {
+    readonly kind: 'renameColumn';
+    readonly tableName: string;
+    readonly fromColumnName: string;
+    readonly toColumnName: string;
+}
+interface AlterColumnOperation {
+    readonly kind: 'alterColumn';
+    readonly tableName: string;
+    readonly column: AnyColumnDefinition;
+}
+interface CreateForeignKeyOperation {
+    readonly kind: 'createForeignKey';
+    readonly tableName: string;
+    readonly columnName: string;
+    readonly reference: ForeignKeyReference;
+    readonly constraintName?: string;
+}
+interface DropForeignKeyOperation {
+    readonly kind: 'dropForeignKey';
+    readonly tableName: string;
+    readonly constraintName: string;
+}
+type DDLOperation = CreateTableOperation | DropTableOperation | RenameTableOperation | CreateIndexOperation | DropIndexOperation | RenameIndexOperation | AddColumnOperation | DropColumnOperation | RenameColumnOperation | AlterColumnOperation | CreateForeignKeyOperation | DropForeignKeyOperation;
+interface DDLStatement {
+    readonly sql: string;
+    readonly bindings?: readonly unknown[];
+    readonly source: string;
+}
+declare function createTableOperation(table: TableDefinition): CreateTableOperation;
+declare function dropTableOperation(tableName: string): DropTableOperation;
+declare function renameTableOperation(fromTableName: string, toTableName: string): RenameTableOperation;
+declare function createIndexOperation(tableName: string, index: CreateIndexOperation['index']): CreateIndexOperation;
+declare function dropIndexOperation(tableName: string, indexName: string): DropIndexOperation;
+declare function renameIndexOperation(tableName: string, fromIndexName: string, toIndexName: string): RenameIndexOperation;
+declare function addColumnOperation(tableName: string, column: AnyColumnDefinition): AddColumnOperation;
+declare function dropColumnOperation(tableName: string, columnName: string): DropColumnOperation;
+declare function renameColumnOperation(tableName: string, fromColumnName: string, toColumnName: string): RenameColumnOperation;
+declare function alterColumnOperation(tableName: string, column: AnyColumnDefinition): AlterColumnOperation;
+declare function createForeignKeyOperation(tableName: string, columnName: string, reference: ForeignKeyReference, constraintName?: string): CreateForeignKeyOperation;
+declare function dropForeignKeyOperation(tableName: string, constraintName: string): DropForeignKeyOperation;
+
+type IdentifierQuoter = (identifier: string) => string;
+declare abstract class SQLSchemaCompiler {
+    protected readonly quoteIdentifier: IdentifierQuoter;
+    constructor(quoteIdentifier: IdentifierQuoter);
+    compile(operation: DDLOperation): DDLStatement[];
+    compileCreateTable(table: TableDefinition): DDLStatement[];
+    compileAddColumn(tableName: string, column: AnyColumnDefinition): DDLStatement;
+    compileDropColumn(tableName: string, columnName: string): DDLStatement;
+    compileRenameColumn(tableName: string, fromColumnName: string, toColumnName: string): DDLStatement;
+    compileAlterColumn(tableName: string, column: AnyColumnDefinition): DDLStatement[];
+    compileCreateForeignKey(tableName: string, columnName: string, reference: NonNullable<AnyColumnDefinition['references']>, constraintName?: string): DDLStatement;
+    compileDropForeignKey(tableName: string, constraintName: string): DDLStatement;
+    compileCreateIndex(tableName: string, index: TableIndexDefinition): DDLStatement;
+    compileDropIndex(tableName: string, indexName: string): DDLStatement;
+    compileRenameTable(fromTableName: string, toTableName: string): DDLStatement;
+    compileRenameIndex(tableName: string, fromIndexName: string, toIndexName: string): DDLStatement;
+    protected compileColumn(column: AnyColumnDefinition): string;
+    protected appendPrimaryKeyExtras(_parts: string[], _column: AnyColumnDefinition): void;
+    protected compileCurrentTimestamp(): string;
+    protected compileIdentifierPath(identifier: string): string;
+    protected assertSupportedDefaultValue(value: unknown, column: AnyColumnDefinition): void;
+    protected isSupportedDefaultValue(value: unknown): boolean;
+    protected resolveIndexName(tableName: string, index: TableIndexDefinition): string;
+    protected resolveForeignKeyName(tableName: string, columnName: string, constraintName?: string): string;
+    protected assertSupportedAlterColumnDefinition(column: AnyColumnDefinition): void;
+    protected abstract getDialectLabel(): string;
+    protected abstract compileColumnType(column: AnyColumnDefinition): string;
+    protected abstract compileDefaultValue(value: unknown): string;
+}
+
+declare class SQLiteSchemaCompiler extends SQLSchemaCompiler {
+    protected getDialectLabel(): string;
+    protected appendPrimaryKeyExtras(parts: string[], column: ColumnDefinition): void;
+    protected compileColumnType(column: ColumnDefinition): string;
+    protected compileDefaultValue(value: unknown): string;
+}
+
+declare class PostgresSchemaCompiler extends SQLSchemaCompiler {
+    protected getDialectLabel(): string;
+    protected compileColumnType(column: ColumnDefinition): string;
+    protected compileDefaultValue(value: unknown): string;
+    compileAlterColumn(tableName: string, column: ColumnDefinition): Array<{
+        sql: string;
+        source: string;
+    }>;
+}
+
+declare class MySQLSchemaCompiler extends SQLSchemaCompiler {
+    protected getDialectLabel(): string;
+    protected compileColumnType(column: ColumnDefinition): string;
+    protected compileDefaultValue(value: unknown): string;
+    compileRenameTable(fromTableName: string, toTableName: string): {
+        sql: string;
+        source: string;
+    };
+    compileRenameIndex(tableName: string, fromIndexName: string, toIndexName: string): {
+        sql: string;
+        source: string;
+    };
+    compileCreateIndex(tableName: string, index: TableIndexDefinition): {
+        sql: string;
+        source: string;
+    };
+    compileDropIndex(tableName: string, indexName: string): {
+        sql: string;
+        source: string;
+    };
+    compileDropForeignKey(tableName: string, constraintName: string): {
+        sql: string;
+        source: string;
+    };
+}
+
+type SchemaDefaultDialectName = 'sqlite' | 'postgres' | 'mysql';
+declare function compileDialectDefaultLiteral(dialect: SchemaDefaultDialectName, value: unknown): string;
+
+type SchemaDialectName = 'sqlite' | 'postgres' | 'mysql';
+type ColumnTypeResolver = (column: AnyColumnDefinition) => string;
+type DialectTypeEntry = string | ColumnTypeResolver;
+type DialectTypeMapping = Readonly<Record<LogicalColumnKind, DialectTypeEntry>>;
+type DialectIdStrategyMap = Readonly<Record<IdGenerationStrategy, string>>;
+declare const DIALECT_ID_STRATEGY_MAP: Readonly<Record<SchemaDialectName, DialectIdStrategyMap>>;
+declare function resolveDialectIdStrategyType(dialect: SchemaDialectName, strategy: IdGenerationStrategy): string;
+declare const DIALECT_LOGICAL_TYPE_MAP: Readonly<Record<SchemaDialectName, DialectTypeMapping>>;
+declare function resolveDialectColumnType(dialect: SchemaDialectName, column: AnyColumnDefinition): string;
+
+declare const DIALECT_VECTOR_SUPPORT: Readonly<Record<SchemaDialectName, boolean>>;
+declare function normalizeDialectReadValue(dialect: SchemaDialectName, column: AnyColumnDefinition, value: unknown): unknown;
+declare function normalizeDialectWriteValue(dialect: SchemaDialectName, column: AnyColumnDefinition, value: unknown): unknown;
+
+declare function defineMigration<TDefinition extends MigrationDefinition>(definition: TDefinition): TDefinition;
+
+declare function normalizeMigrationSlug(name: string): string;
+declare function createMigrationTimestamp(date?: Date): string;
+declare function createMigrationFileName(name: string, date?: Date): string;
+declare function inferMigrationTemplateKind(slug: string): MigrationTemplateKind;
+declare function inferMigrationTableName(slug: string, kind: MigrationTemplateKind): string | undefined;
+declare function generateMigrationTemplate(name: string, options?: MigrationTemplateOptions): GeneratedMigrationTemplate;
+
+interface SeederContext {
+    readonly db: DatabaseContext;
+    readonly schema: SchemaService;
+    call(...names: readonly string[]): Promise<readonly SeederDefinition[]>;
+}
+interface SeederDefinition {
+    readonly name: string;
+    run(context: SeederContext): unknown | Promise<unknown>;
+}
+interface SeedOptions {
+    only?: readonly string[];
+    quietly?: boolean;
+    force?: boolean;
+    environment?: string;
+}
+
+declare class SeederService {
+    private readonly connection;
+    private readonly seeders;
+    constructor(connection: DatabaseContext, seeders?: readonly SeederDefinition[]);
+    register(seeder: SeederDefinition): this;
+    getSeeders(): readonly SeederDefinition[];
+    getSeeder(name: string): SeederDefinition | undefined;
+    seed(options?: SeedOptions): Promise<SeederDefinition[]>;
+    private selectSeeders;
+    private runSeeders;
+    private createContext;
+    private assertCanSeed;
+    private createSeederLog;
+}
+declare function createSeederService(connection: DatabaseContext, seeders?: readonly SeederDefinition[]): SeederService;
+
+declare function defineSeeder<TSeeder extends SeederDefinition>(seeder: TSeeder): TSeeder;
+
+declare function defineFactory<TModel extends FactoryModelReference>(model: TModel, definition: FactoryDefinition<TModel>): Factory<TModel>;
+
+declare function enumCast<TEnum extends Record<string, string | number>>(enumObject: TEnum): EnumCastDefinition;
+declare function binaryCast(): Readonly<{
+    get(value: unknown): Uint8Array | null | undefined;
+    set(value: unknown): Uint8Array | null | undefined;
+}>;
+declare function encryptedCast(secret: string): Readonly<{
+    get(value: unknown): unknown;
+    set(value: unknown): string | null | undefined;
+}>;
+
+type BuilderCallback<TBuilder> = (query: TBuilder) => unknown;
+type ValueBuilderCallback<TBuilder, TValue> = (query: TBuilder, value: TValue) => unknown;
+type RelationConstraintCallback = (query: ModelQueryBuilder<TableDefinition>) => unknown;
+type RelationConstraintMap<TRelations extends RelationMap> = Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraintCallback>>>;
+type MorphEntityTarget = {
+    exists(): boolean;
+    getRepository(): {
+        definition: {
+            morphClass: string;
+            primaryKey: string;
+        };
+    };
+    get(key: string): unknown;
+};
+type MorphModelTarget = {
+    definition?: {
+        morphClass?: string;
+    };
+};
+type MorphTypeSelector = string | MorphModelTarget | MorphEntityTarget | null;
+type SubqueryBuilder<TSubTable extends TableDefinition = TableDefinition> = ModelQueryBuilder<TSubTable> | TableQueryBuilder<TSubTable, Record<string, unknown>>;
+type ColumnShapeInput = Record<string, ColumnInput>;
+type EmptyColumnShape = Record<never, never>;
+type ModelTableBuilderResult<TName extends string, TColumns extends ColumnShapeInput> = {
+    build(): BoundTableDefinition<TName, TColumns>;
+};
+type StaticModelApi<TTable extends TableDefinition, TScopes extends ModelScopesDefinition, TRelations extends RelationMap = RelationMap> = ModelReference<TTable, TScopes, TRelations> & ModelScopeMethods<TTable, TScopes, TRelations> & {
+    query(): ModelQueryBuilder<TTable, TRelations>;
+    newQuery(): ModelQueryBuilder<TTable, TRelations>;
+    newModelQuery(): ModelQueryBuilder<TTable, TRelations>;
+    newQueryWithoutScopes(): ModelQueryBuilder<TTable, TRelations>;
+    newQueryWithoutRelationships(): ModelQueryBuilder<TTable, TRelations>;
+    from(table: string): ModelQueryBuilder<TTable, TRelations>;
+    debug(): ReturnType<ModelQueryBuilder<TTable, TRelations>['debug']>;
+    dump(): ModelQueryBuilder<TTable, TRelations>;
+    preventLazyLoading(value?: boolean): StaticModelApi<TTable, TScopes, TRelations>;
+    preventAccessingMissingAttributes(value?: boolean): StaticModelApi<TTable, TScopes, TRelations>;
+    automaticallyEagerLoadRelationships(value?: boolean): StaticModelApi<TTable, TScopes, TRelations>;
+    withoutEvents<TResult>(callback: () => TResult | Promise<TResult>): Promise<TResult>;
+    unguarded<TResult>(callback: () => TResult | Promise<TResult>): Promise<TResult>;
+    where(callback: BuilderCallback<ModelQueryBuilder<TTable, TRelations>>): ModelQueryBuilder<TTable, TRelations>;
+    where(column: ModelColumnName<TTable> | ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    orWhere(callback: BuilderCallback<ModelQueryBuilder<TTable, TRelations>>): ModelQueryBuilder<TTable, TRelations>;
+    orWhere(column: ModelColumnName<TTable> | ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereNot(callback: BuilderCallback<ModelQueryBuilder<TTable, TRelations>>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereNot(callback: BuilderCallback<ModelQueryBuilder<TTable, TRelations>>): ModelQueryBuilder<TTable, TRelations>;
+    whereExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    whereNotExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereNotExists<TSubTable extends TableDefinition>(subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    whereSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'like', subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'like', subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    whereInSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    whereNotInSub<TSubTable extends TableDefinition>(column: ModelColumnName<TTable>, subquery: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    select(...columns: readonly ModelSelectableColumn<TTable>[]): ModelQueryBuilder<TTable, TRelations>;
+    addSelect(...columns: readonly ModelSelectableColumn<TTable>[]): ModelQueryBuilder<TTable, TRelations>;
+    withCasts(casts: Record<string, ModelCastDefinition>): ModelQueryBuilder<TTable, TRelations>;
+    selectSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations>;
+    addSelectSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations>;
+    whereNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    whereNotNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereNotNull(column: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    when<TValue>(value: TValue, callback: ValueBuilderCallback<ModelQueryBuilder<TTable, TRelations>, TValue>, defaultCallback?: ValueBuilderCallback<ModelQueryBuilder<TTable, TRelations>, TValue>): ModelQueryBuilder<TTable, TRelations>;
+    unless<TValue>(value: TValue, callback: ValueBuilderCallback<ModelQueryBuilder<TTable, TRelations>, TValue>, defaultCallback?: ValueBuilderCallback<ModelQueryBuilder<TTable, TRelations>, TValue>): ModelQueryBuilder<TTable, TRelations>;
+    distinct(): ModelQueryBuilder<TTable, TRelations>;
+    whereColumn(column: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', compareTo: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    whereIn(column: ModelColumnName<TTable>, values: readonly unknown[]): ModelQueryBuilder<TTable, TRelations>;
+    whereNotIn(column: ModelColumnName<TTable>, values: readonly unknown[]): ModelQueryBuilder<TTable, TRelations>;
+    whereBetween(column: ModelColumnName<TTable>, range: readonly [unknown, unknown]): ModelQueryBuilder<TTable, TRelations>;
+    whereNotBetween(column: ModelColumnName<TTable>, range: readonly [unknown, unknown]): ModelQueryBuilder<TTable, TRelations>;
+    whereLike(column: ModelColumnName<TTable>, pattern: string): ModelQueryBuilder<TTable, TRelations>;
+    orWhereLike(column: ModelColumnName<TTable>, pattern: string): ModelQueryBuilder<TTable, TRelations>;
+    whereAny(columns: readonly ModelColumnName<TTable>[], operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereAll(columns: readonly ModelColumnName<TTable>[], operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereNone(columns: readonly ModelColumnName<TTable>[], operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    join(table: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    leftJoin(table: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    rightJoin(table: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    crossJoin(table: string): ModelQueryBuilder<TTable, TRelations>;
+    joinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    leftJoinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    rightJoinSub<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string, leftColumn: ModelColumnReference<TTable>, operator: '!=' | '=' | '>' | '>=' | '<' | '<=' | 'like', rightColumn: ModelColumnReference<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    joinLateral<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations>;
+    leftJoinLateral<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>, alias: string): ModelQueryBuilder<TTable, TRelations>;
+    union<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    unionAll<TSubTable extends TableDefinition>(query: SubqueryBuilder<TSubTable>): ModelQueryBuilder<TTable, TRelations>;
+    groupBy(...columns: readonly ModelColumnName<TTable>[]): ModelQueryBuilder<TTable, TRelations>;
+    having(expression: string, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    havingBetween(expression: string, range: readonly [unknown, unknown]): ModelQueryBuilder<TTable, TRelations>;
+    unsafeWhere(sql: string, bindings: readonly unknown[]): ModelQueryBuilder<TTable, TRelations>;
+    orUnsafeWhere(sql: string, bindings: readonly unknown[]): ModelQueryBuilder<TTable, TRelations>;
+    whereDate(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereMonth(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereDay(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereYear(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereTime(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereJson(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    orWhereJson(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereJsonContains(columnPath: ModelJsonColumnPath<TTable>, value: unknown): ModelQueryBuilder<TTable, TRelations>;
+    orWhereJsonContains(columnPath: ModelJsonColumnPath<TTable>, value: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereJsonLength(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    orWhereJsonLength(columnPath: ModelJsonColumnPath<TTable>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereFullText(columns: ModelColumnName<TTable> | readonly ModelColumnName<TTable>[], value: string, options?: {
+        mode?: 'natural' | 'boolean';
+    }): ModelQueryBuilder<TTable, TRelations>;
+    orWhereFullText(columns: ModelColumnName<TTable> | readonly ModelColumnName<TTable>[], value: string, options?: {
+        mode?: 'natural' | 'boolean';
+    }): ModelQueryBuilder<TTable, TRelations>;
+    whereVectorSimilarTo(column: ModelColumnName<TTable>, vector: readonly number[], minSimilarity?: number): ModelQueryBuilder<TTable, TRelations>;
+    orWhereVectorSimilarTo(column: ModelColumnName<TTable>, vector: readonly number[], minSimilarity?: number): ModelQueryBuilder<TTable, TRelations>;
+    latest(column?: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    oldest(column?: ModelColumnName<TTable>): ModelQueryBuilder<TTable, TRelations>;
+    inRandomOrder(): ModelQueryBuilder<TTable, TRelations>;
+    reorder(column?: ModelColumnName<TTable>, direction?: 'asc' | 'desc'): ModelQueryBuilder<TTable, TRelations>;
+    unsafeOrderBy(sql: string, bindings: readonly unknown[]): ModelQueryBuilder<TTable, TRelations>;
+    lock(mode: 'update' | 'share'): ModelQueryBuilder<TTable, TRelations>;
+    lockForUpdate(): ModelQueryBuilder<TTable, TRelations>;
+    sharedLock(): ModelQueryBuilder<TTable, TRelations>;
+    with<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): ModelQueryBuilder<TTable, TRelations, ResolveEagerLoads<TRelations, TPaths>>;
+    with<TPath extends ModelRelationPath<TRelations>>(relation: TPath, constraint: RelationConstraintCallback): ModelQueryBuilder<TTable, TRelations, ResolveEagerLoads<TRelations, readonly [TPath]>>;
+    with<TMap extends Readonly<Partial<Record<ModelRelationPath<TRelations>, RelationConstraintCallback>>>>(relations: TMap): ModelQueryBuilder<TTable, TRelations>;
+    withCount(...relations: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations>;
+    withCount(relations: RelationConstraintMap<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    withExists(...relations: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations>;
+    withExists(relations: RelationConstraintMap<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    withSum<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath | RelationConstraintMap<TRelations>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations>;
+    withAvg<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath | RelationConstraintMap<TRelations>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations>;
+    withMin<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath | RelationConstraintMap<TRelations>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations>;
+    withMax<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath | RelationConstraintMap<TRelations>, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, ...rest: readonly ModelRelationPath<TRelations>[]): ModelQueryBuilder<TTable, TRelations>;
+    has(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    orHas(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    whereHas(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraintCallback): ModelQueryBuilder<TTable, TRelations>;
+    orWhereHas(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraintCallback): ModelQueryBuilder<TTable, TRelations>;
+    doesntHave(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    orDoesntHave(relation: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    whereDoesntHave(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraintCallback): ModelQueryBuilder<TTable, TRelations>;
+    orWhereDoesntHave(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraintCallback): ModelQueryBuilder<TTable, TRelations>;
+    whereRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    orWhereRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations>;
+    whereBelongsTo<TRelated extends TableDefinition>(entity: Entity<TRelated>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    orWhereBelongsTo<TRelated extends TableDefinition>(entity: Entity<TRelated>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations>;
+    whereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations>;
+    orWhereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations>;
+    whereNotMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations>;
+    orWhereNotMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector): ModelQueryBuilder<TTable, TRelations>;
+    withWhereHas<TPath extends ModelRelationPath<TRelations>>(relation: TPath, constraint?: RelationConstraintCallback): ModelQueryBuilder<TTable, TRelations, ResolveEagerLoads<TRelations, readonly [TPath]>>;
+    find(value: unknown): Promise<Entity<TTable, TRelations> | undefined>;
+    findMany(values: readonly unknown[]): Promise<ModelCollection<TTable, TRelations>>;
+    findOrFail(value: unknown): Promise<Entity<TTable, TRelations>>;
+    first(): Promise<Entity<TTable, TRelations> | undefined>;
+    firstOrFail(): Promise<Entity<TTable, TRelations>>;
+    sole(): Promise<Entity<TTable, TRelations>>;
+    firstWhere(column: ModelColumnName<TTable>, operator: unknown, value?: unknown): Promise<Entity<TTable, TRelations> | undefined>;
+    get(): Promise<ModelCollection<TTable, TRelations>>;
+    all(): Promise<ModelCollection<TTable, TRelations>>;
+    paginate(perPage?: number, page?: number, options?: PaginationOptions): Promise<PaginatedResult<Entity<TTable, TRelations>> & {
+        data: ModelCollection<TTable, TRelations>;
+    }>;
+    simplePaginate(perPage?: number, page?: number, options?: PaginationOptions): Promise<SimplePaginatedResult<Entity<TTable, TRelations>> & {
+        data: ModelCollection<TTable, TRelations>;
+    }>;
+    cursorPaginate(perPage?: number, cursor?: string | null, options?: CursorPaginationOptions): Promise<CursorPaginatedResult<Entity<TTable, TRelations>> & {
+        data: ModelCollection<TTable, TRelations>;
+    }>;
+    chunk(size: number, callback: (rows: readonly Entity<TTable, TRelations>[], page: number) => unknown | Promise<unknown>): Promise<void>;
+    chunkById(size: number, callback: (rows: readonly Entity<TTable, TRelations>[], page: number) => unknown | Promise<unknown>, column?: ModelAttributeKey<TTable>): Promise<void>;
+    chunkByIdDesc(size: number, callback: (rows: readonly Entity<TTable, TRelations>[], page: number) => unknown | Promise<unknown>, column?: ModelAttributeKey<TTable>): Promise<void>;
+    lazy(size?: number): AsyncGenerator<Entity<TTable, TRelations>, void, unknown>;
+    cursor(): AsyncGenerator<Entity<TTable, TRelations>, 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>;
+    create(values: Partial<ModelRecord<TTable>>): Promise<Entity<TTable, TRelations>>;
+    create(values: InferInsert<TTable>): Promise<Entity<TTable, TRelations>>;
+    createMany(values: readonly Partial<ModelRecord<TTable>>[]): Promise<ModelCollection<TTable, TRelations>>;
+    createMany(values: readonly InferInsert<TTable>[]): Promise<ModelCollection<TTable, TRelations>>;
+    createQuietly(values: Partial<ModelRecord<TTable>>): Promise<Entity<TTable, TRelations>>;
+    createQuietly(values: InferInsert<TTable>): Promise<Entity<TTable, TRelations>>;
+    createManyQuietly(values: readonly Partial<ModelRecord<TTable>>[]): Promise<ModelCollection<TTable, TRelations>>;
+    createManyQuietly(values: readonly InferInsert<TTable>[]): Promise<ModelCollection<TTable, TRelations>>;
+    update(id: unknown, values: ModelUpdatePayload<TTable>): Promise<Entity<TTable, TRelations>>;
+    prune(): Promise<number>;
+    increment(column: ModelColumnName<TTable>, amount?: number, extraValues?: Partial<ModelRecord<TTable>>): Promise<DriverExecutionResult>;
+    decrement(column: ModelColumnName<TTable>, amount?: number, extraValues?: Partial<ModelRecord<TTable>>): Promise<DriverExecutionResult>;
+    delete(id: unknown): Promise<void>;
+    destroy(ids: readonly unknown[]): Promise<number>;
+    restore(id: unknown): Promise<Entity<TTable, TRelations>>;
+    forceDelete(id: unknown): Promise<void>;
+    withTrashed(): ModelQueryBuilder<TTable, TRelations>;
+    onlyTrashed(): ModelQueryBuilder<TTable, TRelations>;
+    updateOrCreate(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable, TRelations>>;
+    upsert(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable, TRelations>>;
+    firstOrNew(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable, TRelations>>;
+    firstOrCreate(match: Partial<ModelRecord<TTable>>, values?: Partial<ModelRecord<TTable>>): Promise<Entity<TTable, TRelations>>;
+    saveMany(entities: readonly Entity<TTable, TRelations>[]): Promise<ModelCollection<TTable, TRelations>>;
+    resolveRelationUsing(name: string, resolver: DynamicRelationResolver): StaticModelApi<TTable, TScopes, TRelations>;
+    make(values?: Partial<ModelRecord<TTable>>): Entity<TTable, TRelations>;
+    getRepository(): ModelRepository<TTable>;
+    getConnectionName(): string | undefined;
+    getTableName(): string;
+};
+declare function defineModel<TTable extends TableDefinition, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap>(table: TTable, options?: DefineModelOptions<TTable, TScopes, TRelations>): StaticModelApi<TTable, TScopes, TRelations>;
+declare function defineModel<TName extends string, TColumns extends ColumnShapeInput, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap>(tableName: TName, builder: (table: TableDefinitionBuilder<TName, EmptyColumnShape>) => ModelTableBuilderResult<TName, TColumns>, options?: DefineModelOptions<BoundTableDefinition<TName, TColumns>, TScopes, TRelations>): StaticModelApi<BoundTableDefinition<TName, TColumns>, TScopes, TRelations>;
+declare function defineModel<TName extends string, TScopes extends ModelScopesDefinition = EmptyScopeMap, TRelations extends RelationMap = RelationMap>(tableName: TName, options?: DefineModelOptions<GeneratedSchemaTable<TName>, TScopes, TRelations>): StaticModelApi<GeneratedSchemaTable<TName>, TScopes, TRelations>;
+
+declare function resolveMorphModel(type: string): ModelDefinitionLike | undefined;
+declare function resetMorphRegistry(): void;
+
+declare function belongsTo<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, foreignKeyOrOptions: string | {
+    foreignKey: string;
+    ownerKey?: string;
+}, ownerKey?: string): BelongsToRelationDefinition<TRelated>;
+declare function hasMany<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, foreignKeyOrOptions: string | {
+    foreignKey: string;
+    localKey?: string;
+}, localKey?: string): HasManyRelationDefinition<TRelated>;
+declare function hasOne<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, foreignKeyOrOptions: string | {
+    foreignKey: string;
+    localKey?: string;
+}, localKey?: string): HasOneRelationDefinition<TRelated>;
+declare function morphOne<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, name: string, type?: string, id?: string, localKey?: string): MorphOneRelationDefinition<TRelated>;
+declare function morphMany<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, name: string, type?: string, id?: string, localKey?: string): MorphManyRelationDefinition<TRelated>;
+declare function morphOfMany<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, name: string, aggregateColumn: string, aggregate?: 'min' | 'max', type?: string, id?: string, localKey?: string): MorphOneOfManyRelationDefinition<TRelated>;
+declare function latestMorphOne<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, name: string, column?: string, type?: string, id?: string, localKey?: string): MorphOneOfManyRelationDefinition<TRelated>;
+declare function oldestMorphOne<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, name: string, column?: string, type?: string, id?: string, localKey?: string): MorphOneOfManyRelationDefinition<TRelated>;
+declare function morphTo(name: string, type?: string, id?: string): MorphToRelationDefinition;
+declare function ofMany<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, foreignKey: string, aggregateColumn: string, aggregate?: 'min' | 'max', localKey?: string): HasOneOfManyRelationDefinition<TRelated>;
+declare function latestOfMany<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, foreignKey: string, localKey?: string, column?: string): HasOneOfManyRelationDefinition<TRelated>;
+declare function oldestOfMany<TRelated extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, foreignKey: string, localKey?: string, column?: string): HasOneOfManyRelationDefinition<TRelated>;
+declare function belongsToMany<TRelated extends ModelDefinitionLike<TableDefinition>, TPivotTable extends string | TableDefinition>(related: () => TRelated, pivotTableOrOptions: TPivotTable | {
+    pivotTable: TPivotTable;
+    foreignPivotKey: string;
+    relatedPivotKey: string;
+    parentKey?: string;
+    relatedKey?: string;
+}, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToManyRelationDefinition<TRelated, TPivotTable> & PivotRelationMethods<BelongsToManyRelationDefinition<TRelated, TPivotTable>, TPivotTable>;
+declare function morphToMany<TRelated extends ModelDefinitionLike<TableDefinition>, TPivotTable extends string | TableDefinition>(related: () => TRelated, name: string, pivotTable: TPivotTable, foreignPivotKey: string, parentKey?: string, relatedKey?: string, type?: string, id?: string): MorphToManyRelationDefinition<TRelated, TPivotTable> & PivotRelationMethods<MorphToManyRelationDefinition<TRelated, TPivotTable>, TPivotTable>;
+declare function morphedByMany<TRelated extends ModelDefinitionLike<TableDefinition>, TPivotTable extends string | TableDefinition>(related: () => TRelated, name: string, pivotTable: TPivotTable, foreignPivotKey: string, parentKey?: string, relatedKey?: string, type?: string, id?: string): MorphedByManyRelationDefinition<TRelated, TPivotTable> & PivotRelationMethods<MorphedByManyRelationDefinition<TRelated, TPivotTable>, TPivotTable>;
+declare function scopeRelation<TRelation extends RelationDefinition>(relation: TRelation, constraint: RelationConstraintDefinition): TRelation;
+declare function hasOneThrough<TRelated extends ModelDefinitionLike<TableDefinition>, TThrough extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, through: () => TThrough, firstKey: string, secondKey: string, localKey?: string, secondLocalKey?: string): HasOneThroughRelationDefinition<TRelated, TThrough>;
+declare function hasManyThrough<TRelated extends ModelDefinitionLike<TableDefinition>, TThrough extends ModelDefinitionLike<TableDefinition>>(related: () => TRelated, through: () => TThrough, firstKey: string, secondKey: string, localKey?: string, secondLocalKey?: string): HasManyThroughRelationDefinition<TRelated, TThrough>;
+
+interface UniqueIdTraitOptions<TTable extends TableDefinition = TableDefinition> {
+    columns?: readonly ModelAttributeKey<TTable>[];
+    generator?: () => string;
+}
+declare function generateUuidV7(): string;
+declare function generateUlid(): string;
+declare function generateSnowflake(): string;
+declare function HasUniqueIds<TTable extends TableDefinition = TableDefinition>(options?: UniqueIdTraitOptions<TTable>): UniqueIdTrait<TTable>;
+declare function HasUuids<TTable extends TableDefinition = TableDefinition>(options?: Omit<UniqueIdTraitOptions<TTable>, 'generator'>): UniqueIdTrait<TTable>;
+declare function HasUlids<TTable extends TableDefinition = TableDefinition>(options?: Omit<UniqueIdTraitOptions<TTable>, 'generator'>): UniqueIdTrait<TTable>;
+declare function HasSnowflakes<TTable extends TableDefinition = TableDefinition>(options?: Omit<UniqueIdTraitOptions<TTable>, 'generator'>): UniqueIdTrait<TTable>;
+
+interface HoloProjectPaths {
+    models: string;
+    migrations: string;
+    generatedSchema: string;
+    seeders: string;
+    observers: string;
+    factories: string;
+    commands: string;
+    jobs: string;
+    events: string;
+    listeners: string;
+}
+interface HoloProjectConnectionConfig {
+    driver?: SupportedDatabaseDriver;
+    url?: string;
+    host?: string;
+    port?: number | string;
+    username?: string;
+    password?: string;
+    database?: string;
+    filename?: string;
+    schema?: string;
+    ssl?: boolean | Record<string, unknown>;
+    logging?: boolean;
+}
+interface HoloProjectDatabaseConfig {
+    defaultConnection?: string;
+    connections?: Record<string, HoloProjectConnectionConfig | string>;
+}
+interface HoloProjectConfig {
+    paths?: Partial<HoloProjectPaths>;
+    database?: HoloProjectDatabaseConfig;
+    models?: readonly string[];
+    migrations?: readonly string[];
+    seeders?: readonly string[];
+}
+declare const DEFAULT_HOLO_PROJECT_PATHS: Readonly<HoloProjectPaths>;
+interface NormalizedHoloProjectConfig {
+    readonly paths: Readonly<HoloProjectPaths>;
+    readonly database?: HoloProjectDatabaseConfig;
+    readonly models: readonly string[];
+    readonly migrations: readonly string[];
+    readonly seeders: readonly string[];
+}
+declare function normalizeHoloProjectConfig(config?: HoloProjectConfig): NormalizedHoloProjectConfig;
+declare function defineHoloProject<TConfig extends HoloProjectConfig>(config: TConfig): NormalizedHoloProjectConfig & TConfig;
+
+export { type AddColumnOperation, type AlterColumnOperation, type AnyColumnDefinition, AsyncConnectionContext, CapabilityError, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, DB, type DDLOperation, type DDLStatement, DEFAULT_CAPABILITIES, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_SECURITY_POLICY, DIALECT_ID_STRATEGY_MAP, DIALECT_LOGICAL_TYPE_MAP, DIALECT_VECTOR_SUPPORT, type DatabaseCapabilities, DatabaseContext, type DatabaseContextOptions, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DefineModelOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, Entity, type EntityWithLoaded, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, HasSnowflakes, HasUlids, HasUniqueIds, HasUuids, type HoloProjectConfig, type HoloProjectConnectionConfig, type HoloProjectDatabaseConfig, type HoloProjectPaths, HydrationError, type IdGenerationStrategy, type InferInsert, type InferSelect, type InferUpdate, type InsertQueryPlan, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedIndex, type LogicalColumnKind, type MigrateOptions, type MigrationContext, type MigrationDefinition, type MigrationErrorLog, type MigrationExecutionPolicy, MigrationService, type MigrationSquashPlan, type MigrationStartLog, type MigrationStatus, type MigrationSuccessLog, type MigrationTemplateKind, type MigrationTemplateOptions, type ModelAttributeKey, type ModelCollection, type ModelDefinition, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, ModelRepository, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, MySQLQueryCompiler, type MySQLQueryableLike, MySQLSchemaCompiler, type NormalizedHoloProjectConfig, type PaginatedResult, type PaginationMeta, PostgresAdapter, type PostgresAdapterOptions, type PostgresClientLike, type PostgresPoolLike, PostgresQueryCompiler, type PostgresQueryableLike, PostgresSchemaCompiler, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RelationDefinition, RelationError, type RelationMap, type RenameColumnOperation, type RenameIndexOperation, type RenameTableOperation, type ResolveEagerLoadPath, type ResolveEagerLoadUnion, type ResolveEagerLoads, type RollbackOptions, type RuntimeConfigInput, type RuntimeConnectionConfig, type RuntimeDatabaseConfig, type RuntimeHoloConfig, SQLQueryCompiler, SQLSchemaCompiler, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteDatabaseLike, SQLiteQueryCompiler, SQLiteSchemaCompiler, type SQLiteStatementLike, type SchemaColumnMismatch, type SchemaDefaultDialectName, type SchemaDialectName, type SchemaDiff, SchemaError, type SchemaForeignKeyMismatch, type SchemaIndexMismatch, SchemaRegistry, SchemaService, type SchemaSyncPlan, SecurityError, type SecurityPolicy, type SeedOptions, type SeederContext, type SeederDefinition, type SeederErrorLog, SeederService, type SeederStartLog, type SeederSuccessLog, type SelectQueryPlan, SerializationError, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, column, compileDialectDefaultLiteral, configureDB, connectionAsyncContext, createAdapter, createCapabilities, createConnectionManager, createCursorPaginator, createDatabase, createDeleteQueryPlan, createDialect, createFactoryService, createForeignKeyOperation, createIndexOperation, createInsertQueryPlan, createMigrationFileName, createMigrationService, createMigrationTimestamp, createModelCollection, createModelEventService, createModelRegistry, createMySQLAdapter, createPaginator, createPostgresAdapter, createQueryScheduler, createRuntimeConnectionOptions, createRuntimeLogger, createSQLiteAdapter, diffSchema as createSchemaDiff, createSchemaRegistry, createSchemaService, createSecurityPolicy, createSeederService, createSelectQueryPlan, createSimplePaginator, createTableOperation, createTableSource, createUpdateQueryPlan, defineFactory, defineGeneratedTable, defineHoloProject, defineMigration, defineModel, defineSeeder, diffSchema, dropColumnOperation, dropForeignKeyOperation, dropIndexOperation, dropTableOperation, encryptedCast, enumCast, generateMigrationTemplate, generateSnowflake, generateUlid, generateUuidV7, getGeneratedTableDefinition, getModelDefinition, hasMany, hasManyThrough, hasOne, hasOneThrough, inferMigrationTableName, inferMigrationTemplateKind, isSupportedDatabaseDriver, latestMorphOne, latestOfMany, listGeneratedTableDefinitions, morphMany, morphOfMany, morphOne, morphTo, morphToMany, morphedByMany, normalizeDialectReadValue, normalizeDialectWriteValue, normalizeHoloProjectConfig, normalizeMigrationSlug, ofMany, oldestMorphOne, oldestOfMany, parseDatabaseDriver, redactBindings, redactSql, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, resetDB, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };