@holo-js/db 0.2.5 → 0.3.0

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+export { HoloDatabaseConfig, HoloDatabaseConnectionConfig, NormalizedHoloDatabaseConfig, defineDatabaseConfig, holoDatabaseDefaults, normalizeDatabaseConfig } from './config.js';
+import '@holo-js/kernel';
+
 /**
  * Capability flags exposed by a driver+dialect pair.
  *
@@ -242,14 +245,22 @@ declare class QueryScheduler {
     private readonly concurrentState;
     private readonly serializedState;
     private readonly workerState;
+    private activeOperations;
+    private exclusiveActive;
+    private exclusivePending;
+    private readonly operationWaiters;
+    private readonly exclusiveWaiters;
+    private readonly exclusiveScope;
     constructor(options: QuerySchedulerOptions);
     schedule<T>(options: {
         transactional: boolean;
         preferWorkerThreads?: boolean;
+        withinExclusive?: boolean;
     }, callback: (schedulingMode: SchedulingMode) => Promise<T>): Promise<{
         result: T;
         schedulingMode: SchedulingMode;
     }>;
+    exclusive<T>(callback: () => Promise<T>): Promise<T>;
     preview(options: {
         transactional: boolean;
         preferWorkerThreads?: boolean;
@@ -258,6 +269,9 @@ declare class QueryScheduler {
     private resolveState;
     private waitForSlot;
     private wakeNext;
+    private acquireOperation;
+    private releaseOperation;
+    private wakeGate;
 }
 declare function createQueryScheduler(options: QuerySchedulerOptions): QueryScheduler;
 
@@ -334,6 +348,7 @@ interface DriverExecutionResult {
     lastInsertId?: number | string;
 }
 interface DriverAdapter {
+    readonly supportsConcurrentTransactionScopes?: boolean;
     initialize(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
@@ -599,11 +614,13 @@ interface InsertQueryPlan {
     readonly kind: 'insert';
     readonly source: QuerySource;
     readonly ignoreConflicts: boolean;
+    readonly returning?: boolean;
     readonly values: readonly Record<string, unknown>[];
 }
 interface UpsertQueryPlan {
     readonly kind: 'upsert';
     readonly source: QuerySource;
+    readonly returning?: boolean;
     readonly values: readonly Record<string, unknown>[];
     readonly uniqueBy: readonly string[];
     readonly updateColumns: readonly string[];
@@ -612,12 +629,14 @@ interface UpdateQueryPlan {
     readonly kind: 'update';
     readonly source: QuerySource;
     readonly predicates: readonly QueryPredicateNode[];
+    readonly returning?: boolean;
     readonly values: Readonly<Record<string, QueryUpdateValue>>;
 }
 interface DeleteQueryPlan {
     readonly kind: 'delete';
     readonly source: QuerySource;
     readonly predicates: readonly QueryPredicateNode[];
+    readonly returning?: boolean;
 }
 type QueryPlan = SelectQueryPlan | InsertQueryPlan | UpsertQueryPlan | UpdateQueryPlan | DeleteQueryPlan;
 interface QueryJsonUpdateOperation {
@@ -635,9 +654,14 @@ declare function withLimit(plan: SelectQueryPlan, limit?: number): SelectQueryPl
 declare function withOffset(plan: SelectQueryPlan, offset?: number): SelectQueryPlan;
 declare function createInsertQueryPlan(source: QuerySource, values: readonly Record<string, unknown>[], options?: {
     ignoreConflicts?: boolean;
+    returning?: 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;
+declare function createUpdateQueryPlan(source: QuerySource, predicates: readonly QueryPredicateNode[], values: Readonly<Record<string, unknown>>, options?: {
+    readonly returning?: boolean;
+}): UpdateQueryPlan;
+declare function createDeleteQueryPlan(source: QuerySource, predicates: readonly QueryPredicateNode[], options?: {
+    readonly returning?: boolean;
+}): DeleteQueryPlan;
 
 type QueryCacheTtlInput = number | Date;
 type QueryCacheFlexibleTtlInput = readonly [fresh: number, stale: number] | {
@@ -682,9 +706,189 @@ interface DatabaseDependencyCollectionResult<TValue> {
     readonly value: TValue;
     readonly dependencies: readonly string[];
 }
+interface DatabaseQueryPredicateObservation {
+    readonly column: string;
+    readonly operator: QueryOperator;
+    readonly value: unknown;
+}
+interface DatabaseQueryOrderObservation {
+    readonly column: string;
+    readonly direction: 'asc' | 'desc';
+}
+interface DatabaseQueryAggregateObservation {
+    readonly column?: string;
+    readonly count?: number;
+    readonly currentValueCount?: number;
+    readonly kind: 'avg' | 'count' | 'max' | 'min' | 'sum';
+    readonly output?: 'boolean' | 'inverseBoolean';
+    readonly sum?: number;
+    readonly valueCounts?: readonly DatabaseQueryAggregateValueCountObservation[];
+}
+interface DatabaseQueryAggregateValueCountObservation {
+    readonly count: number;
+    readonly value: number;
+}
+interface DatabaseQuerySelectionObservation {
+    readonly column: string;
+    readonly resultKey: string;
+}
+interface DatabaseQueryGroupedAggregateObservation {
+    readonly aggregateColumn?: string;
+    readonly aggregateResultKey: string;
+    readonly aggregateStates?: readonly DatabaseQueryGroupedAggregateStateObservation[];
+    readonly averageStates?: readonly DatabaseQueryGroupedAverageStateObservation[];
+    readonly groupColumn: string;
+    readonly groupResultKey: string;
+    readonly having?: DatabaseQueryGroupedAggregateHavingObservation;
+    readonly kind: 'avg' | 'count' | 'max' | 'min' | 'sum';
+}
+interface DatabaseQueryGroupedAggregateStateObservation {
+    readonly aggregateValue: number;
+    readonly groupValue: unknown;
+    readonly rowCount: number;
+    readonly valueCounts?: readonly DatabaseQueryGroupedAggregateValueCountObservation[];
+}
+interface DatabaseQueryGroupedAggregateValueCountObservation {
+    readonly count: number;
+    readonly value: number;
+}
+interface DatabaseQueryGroupedAverageStateObservation {
+    readonly count: number;
+    readonly groupValue: unknown;
+    readonly rowCount: number;
+    readonly sum: number;
+}
+interface DatabaseQueryGroupedAggregateHavingObservation {
+    readonly operator: Extract<QueryOperator, '<' | '<=' | '=' | '>' | '>='>;
+    readonly value: number;
+}
+type DatabaseQueryPaginationObservation = DatabaseQueryStandardPaginationObservation | DatabaseQuerySimplePaginationObservation | DatabaseQueryCursorPaginationObservation;
+interface DatabaseQueryStandardPaginationObservation {
+    readonly currentPage: number;
+    readonly kind: 'standard';
+    readonly pageName: string;
+    readonly perPage: number;
+    readonly total: number;
+}
+interface DatabaseQuerySimplePaginationObservation {
+    readonly currentPage: number;
+    readonly hasMorePages: boolean;
+    readonly kind: 'simple';
+    readonly pageName: string;
+    readonly perPage: number;
+    readonly rowCount: number;
+}
+interface DatabaseQueryCursorPaginationObservation {
+    readonly cursorName: string;
+    readonly hasMorePages: boolean;
+    readonly kind: 'cursor';
+    readonly nextCursor: string | null;
+    readonly perPage: number;
+    readonly prevCursor: string | null;
+    readonly rows: readonly Readonly<Record<string, unknown>>[];
+    readonly rowCount: number;
+}
+type DatabaseQueryResultPathSegment = string | number;
+interface DatabaseQueryObservation {
+    readonly aggregate?: DatabaseQueryAggregateObservation;
+    readonly belongsToHydrations?: readonly DatabaseQueryBelongsToHydrationObservation[];
+    readonly connectionName: string;
+    readonly cursorRowCount?: number;
+    readonly cursorRows?: readonly Readonly<Record<string, unknown>>[];
+    readonly tableName: string;
+    readonly dependencies: readonly string[];
+    readonly emptyRecordValue?: null;
+    readonly groupedAggregate?: DatabaseQueryGroupedAggregateObservation;
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly orderBy: readonly DatabaseQueryOrderObservation[];
+    readonly patchable: boolean;
+    readonly pagination?: DatabaseQueryPaginationObservation;
+    readonly predicates: readonly DatabaseQueryPredicateObservation[];
+    readonly relation?: DatabaseQueryRelationObservation;
+    readonly result?: unknown;
+    readonly resultPath?: readonly DatabaseQueryResultPathSegment[];
+    readonly scalarColumn?: string;
+    readonly scalarListColumn?: string;
+    readonly scalarListRows?: readonly Readonly<Record<string, unknown>>[];
+    readonly relatedHydrations?: readonly DatabaseQueryRelatedHydrationObservation[];
+    readonly selections: readonly DatabaseQuerySelectionObservation[];
+}
+interface DatabaseQueryBelongsToHydrationObservation {
+    readonly foreignKey: string;
+    readonly ownerKey: string;
+    readonly relationKey: string;
+    readonly relatedConnectionName: string;
+    readonly relatedTableName: string;
+}
+interface DatabaseQueryRelatedHydrationObservation {
+    readonly foreignKey: string;
+    readonly kind: 'hasMany' | 'hasOne';
+    readonly localKey: string;
+    readonly orderBy: readonly DatabaseQueryOrderObservation[];
+    readonly predicates: readonly DatabaseQueryPredicateObservation[];
+    readonly relationKey: string;
+    readonly relatedConnectionName: string;
+    readonly relatedTableName: string;
+}
+type DatabaseQueryRelationObservation = DatabaseQueryBelongsToManyRelationObservation | DatabaseQueryBelongsToParentKeyRelationObservation;
+interface DatabaseQueryBelongsToManyRelationObservation {
+    readonly foreignPivotKey: string;
+    readonly kind: 'belongsToMany';
+    readonly pivotAccessor: string;
+    readonly pivotColumns: readonly string[];
+    readonly pivotOrderBy: readonly DatabaseQueryOrderObservation[];
+    readonly relatedConnectionName: string;
+    readonly relatedKey: string;
+    readonly relatedPivotKey: string;
+    readonly relatedTableName: string;
+}
+interface DatabaseQueryBelongsToParentKeyRelationObservation {
+    readonly foreignKey: string;
+    readonly kind: 'belongsToParentKey';
+    readonly ownerKey: string;
+    readonly relationKey: string;
+    readonly relatedConnectionName: string;
+    readonly relatedTableName: string;
+}
+interface DatabaseMutationEvent {
+    readonly connectionName: string;
+    readonly tableName: string;
+    readonly kind: 'insert' | 'update' | 'delete' | 'upsert';
+    readonly predicates: readonly DatabaseQueryPredicateObservation[];
+    readonly previousRows?: readonly Readonly<Record<string, unknown>>[];
+    readonly rows?: readonly Readonly<Record<string, unknown>>[];
+    readonly values?: Readonly<Record<string, unknown>>;
+}
+type DatabaseDependencyPredicateMetadata = {
+    readonly tableKey: string;
+    readonly columnName: string;
+    readonly encodedValue: string;
+};
+type DatabaseDependencyInvalidationMetadata = {
+    readonly directDependencies: readonly string[];
+    readonly exactPredicates: readonly DatabaseDependencyPredicateMetadata[];
+    readonly hasMutationDependency: boolean;
+    readonly predicates: readonly DatabaseDependencyPredicateMetadata[];
+    readonly tableDependencies: readonly string[];
+};
+type DatabaseDependencyInvalidationEventWithMutations = DatabaseDependencyInvalidationEvent & {
+    readonly mutations?: readonly DatabaseMutationEvent[];
+};
+type DatabaseDependencyInvalidationEventInternal = DatabaseDependencyInvalidationEventWithMutations & {
+    readonly __holoDatabaseDependencyMetadata__?: DatabaseDependencyInvalidationMetadata;
+};
+type DatabaseDependencyInvalidationListenerInternal = (event: DatabaseDependencyInvalidationEventInternal) => void | Promise<void>;
+type DatabaseDependencyCollectionResultInternal<TValue> = DatabaseDependencyCollectionResult<TValue> & {
+    readonly queries: readonly DatabaseQueryObservation[];
+};
+type DatabaseDependencyInvalidationPlan = {
+    readonly dependencies: readonly string[];
+    readonly metadata?: DatabaseDependencyInvalidationMetadata;
+};
 declare function getQueryCacheBridgeState(): {
     bridge?: DatabaseQueryCacheBridge;
-    dependencyInvalidationListeners?: Set<DatabaseDependencyInvalidationListener>;
+    dependencyInvalidationListeners?: Set<DatabaseDependencyInvalidationListenerInternal>;
 };
 declare function configureDatabaseQueryCacheBridge(bridge?: DatabaseQueryCacheBridge): void;
 declare function getDatabaseQueryCacheBridge(): DatabaseQueryCacheBridge | undefined;
@@ -692,27 +896,41 @@ declare function resetDatabaseQueryCacheBridge(): void;
 declare function onDatabaseDependencyInvalidated(listener: DatabaseDependencyInvalidationListener): () => void;
 declare function resetDatabaseDependencyInvalidationListeners(): void;
 declare function collectDatabaseQueryDependencies<TValue>(callback: () => TValue | Promise<TValue>): Promise<DatabaseDependencyCollectionResult<TValue>>;
+declare function collectDatabaseQueryDependenciesInternal<TValue>(callback: () => TValue | Promise<TValue>): Promise<DatabaseDependencyCollectionResultInternal<TValue>>;
 declare function hasActiveDatabaseDependencyCollector(): boolean;
 declare function recordDatabaseQueryDependencies(dependencies: readonly string[] | undefined): void;
+declare function recordDatabaseQueryObservation(observation: DatabaseQueryObservation | undefined): void;
+declare function rebindDatabaseQueryObservationResult(source: unknown, result: unknown): void;
+declare function disableDatabaseQueryObservationPatching(source: unknown): void;
+declare function rebindDatabaseQueryObservationScalar(source: unknown, result: unknown, column: string): void;
+declare function rebindDatabaseQueryObservationScalarList(rows: readonly Readonly<Record<string, unknown>>[], result: readonly unknown[], column: string): void;
 declare function hasDatabaseDependencyInvalidationListeners(): boolean;
-declare function notifyDatabaseDependencyInvalidationListeners(event: DatabaseDependencyInvalidationEvent): Promise<void>;
+declare function notifyDatabaseDependencyInvalidationListeners(event: DatabaseDependencyInvalidationEventInternal): Promise<void>;
 declare function normalizeQueryCacheConfig(input: QueryCacheTtlInput | QueryCacheConfig): NormalizedQueryCacheConfig;
 declare function createDeterministicQueryCacheKey(statement: CompiledStatement, connectionName: string): string;
 declare function resolveQueryCacheKey(statement: CompiledStatement, connectionName: string, config: NormalizedQueryCacheConfig): string;
 declare function createTableCacheDependency(connectionName: string, tableName: string): string;
 declare function createTableRowCacheDependency(connectionName: string, tableName: string, columnName: string, value: unknown): string | undefined;
 declare function createTableRowWildcardCacheDependency(connectionName: string, tableName: string): string;
+declare function createTablePredicateCacheDependency(connectionName: string, tableName: string, columnName: string, value: unknown): string | undefined;
 declare function normalizeQueryCacheDependencies(connectionName: string, dependencies: readonly string[]): readonly string[];
 declare function supportsAutomaticPredicateInvalidation(predicate: QueryPredicateNode): boolean;
+declare function createDatabaseQueryObservation(plan: SelectQueryPlan, connectionName: string, dependencies: readonly string[], result?: unknown, groupedAverageStates?: readonly DatabaseQueryGroupedAverageStateObservation[], groupedAggregateStates?: readonly DatabaseQueryGroupedAggregateStateObservation[]): DatabaseQueryObservation | undefined;
+declare function createDatabaseMutationEvent(kind: DatabaseMutationEvent['kind'], connectionName: string, tableName: string, predicates?: readonly QueryPredicateNode[], values?: Readonly<Record<string, unknown>>, rows?: readonly Readonly<Record<string, unknown>>[], previousRows?: readonly Readonly<Record<string, unknown>>[]): DatabaseMutationEvent;
 declare function supportsAutomaticQueryCacheInvalidation(plan: SelectQueryPlan): boolean;
 declare function inferAutomaticQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string): readonly string[] | undefined;
-declare function inferAutomaticQueryCacheInvalidationDependencies(plan: SelectQueryPlan, connectionName: string): readonly string[];
+declare function inferAutomaticQueryCacheInvalidationDependencies(plan: SelectQueryPlan, connectionName: string, values?: Readonly<Record<string, unknown>>): readonly string[];
+declare function inferAutomaticQueryCacheInvalidationPlan(plan: SelectQueryPlan, connectionName: string, values?: Readonly<Record<string, unknown>>, includeMetadata?: boolean): DatabaseDependencyInvalidationPlan;
 declare function inferAutomaticInsertCacheInvalidationDependencies(connectionName: string, tableName: string, rows: readonly Readonly<Record<string, unknown>>[], lastInsertId?: number | string): readonly string[];
+declare function inferAutomaticInsertCacheInvalidationPlan(connectionName: string, tableName: string, rows: readonly Readonly<Record<string, unknown>>[], lastInsertId?: number | string, includeMetadata?: boolean): DatabaseDependencyInvalidationPlan;
 declare function resolveQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string, explicit?: readonly string[]): readonly string[] | undefined;
 declare const queryCacheInternals: {
-    collectDatabaseQueryDependencies: typeof collectDatabaseQueryDependencies;
+    collectDatabaseQueryDependencies: typeof collectDatabaseQueryDependenciesInternal;
     configureDatabaseQueryCacheBridge: typeof configureDatabaseQueryCacheBridge;
+    createDatabaseMutationEvent: typeof createDatabaseMutationEvent;
+    createDatabaseQueryObservation: typeof createDatabaseQueryObservation;
     createDeterministicQueryCacheKey: typeof createDeterministicQueryCacheKey;
+    createTablePredicateCacheDependency: typeof createTablePredicateCacheDependency;
     createTableCacheDependency: typeof createTableCacheDependency;
     createTableRowCacheDependency: typeof createTableRowCacheDependency;
     createTableRowWildcardCacheDependency: typeof createTableRowWildcardCacheDependency;
@@ -720,13 +938,20 @@ declare const queryCacheInternals: {
     hasActiveDatabaseDependencyCollector: typeof hasActiveDatabaseDependencyCollector;
     hasDatabaseDependencyInvalidationListeners: typeof hasDatabaseDependencyInvalidationListeners;
     inferAutomaticInsertCacheInvalidationDependencies: typeof inferAutomaticInsertCacheInvalidationDependencies;
+    inferAutomaticInsertCacheInvalidationPlan: typeof inferAutomaticInsertCacheInvalidationPlan;
     inferAutomaticQueryCacheDependencies: typeof inferAutomaticQueryCacheDependencies;
     inferAutomaticQueryCacheInvalidationDependencies: typeof inferAutomaticQueryCacheInvalidationDependencies;
+    inferAutomaticQueryCacheInvalidationPlan: typeof inferAutomaticQueryCacheInvalidationPlan;
     normalizeQueryCacheConfig: typeof normalizeQueryCacheConfig;
     normalizeQueryCacheDependencies: typeof normalizeQueryCacheDependencies;
     notifyDatabaseDependencyInvalidationListeners: typeof notifyDatabaseDependencyInvalidationListeners;
+    disableDatabaseQueryObservationPatching: typeof disableDatabaseQueryObservationPatching;
+    rebindDatabaseQueryObservationResult: typeof rebindDatabaseQueryObservationResult;
+    rebindDatabaseQueryObservationScalar: typeof rebindDatabaseQueryObservationScalar;
+    rebindDatabaseQueryObservationScalarList: typeof rebindDatabaseQueryObservationScalarList;
     onDatabaseDependencyInvalidated: typeof onDatabaseDependencyInvalidated;
     recordDatabaseQueryDependencies: typeof recordDatabaseQueryDependencies;
+    recordDatabaseQueryObservation: typeof recordDatabaseQueryObservation;
     resolveQueryCacheDependencies: typeof resolveQueryCacheDependencies;
     resolveQueryCacheKey: typeof resolveQueryCacheKey;
     resetDatabaseDependencyInvalidationListeners: typeof resetDatabaseDependencyInvalidationListeners;
@@ -995,6 +1220,15 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
     dump(): TableQueryBuilder<TTableOrName, TSelectedRow>;
     cache(config: QueryCacheTtlInput | QueryCacheConfig): TableQueryBuilder<TTableOrName, TSelectedRow>;
     get<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow[]>;
+    private recordCollectedQueryObservation;
+    private readGroupedAverageStates;
+    private readGroupedAggregateStates;
+    private readGroupedAggregateValueCounts;
+    private pushGroupedAggregateValueCount;
+    private readGroupedAggregateValueCountsForGroup;
+    private createGroupedAggregateStateValueSelection;
+    private normalizeGroupedAggregateStateValue;
+    private normalizeAggregateMetadataNumber;
     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>>;
@@ -1029,6 +1263,20 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
     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 captureUpdatedMutationRows;
+    private captureDeletedMutationRows;
+    private applyCapturedUpdateValues;
+    private applyCapturedUpdateValue;
+    private applyCapturedJsonUpdateOperation;
+    private isCapturedJsonUpdateOperation;
+    private applyCapturedJsonPathValue;
+    private isJsonRecord;
+    private captureUpsertPreviousRows;
+    private rowsMatchUniqueBy;
+    private shouldUseReturningMutationRows;
+    private queryReturningMutationRows;
+    private freezeMutationRows;
+    private readReturnedLastInsertId;
     private invalidateInsertQueries;
     private invalidateMutationQueries;
     private getCompiler;
@@ -1118,6 +1366,9 @@ declare function getModelDefinition<TTable extends TableDefinition>(reference: M
 declare class ModelRepository<TTable extends TableDefinition = TableDefinition> {
     private readonly connection;
     readonly definition: ModelDefinition<TTable>;
+    private readonly eventDispatcher;
+    private readonly relationAggregateCalculator;
+    private readonly valueTransformer;
     constructor(definition: ModelDefinition<TTable>, connection: DatabaseContext);
     static from<TTable extends TableDefinition>(reference: ModelDefinitionLike | ModelDefinition<TTable> | ModelReference<TTable>, connection?: DatabaseContext): ModelRepository<TTable>;
     getConnection(): DatabaseContext;
@@ -1155,6 +1406,24 @@ declare class ModelRepository<TTable extends TableDefinition = TableDefinition>
     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>;
+    recordRelationAggregateObservations(entities: readonly Entity<TTable>[], aggregates: readonly AggregateLoad$1[], createPath: (index: number, key: string) => readonly DatabaseQueryResultPathSegment[]): void;
+    recordRelationObservations(entities: readonly Entity<TTable>[], relations: readonly (string | EagerLoad$1)[], createPath: (index: number, relationName: string) => readonly DatabaseQueryResultPathSegment[]): void;
+    private recordHasManyRelationObservations;
+    private recordHasOneRelationObservations;
+    private recordBelongsToRelationObservations;
+    private createBelongsToParentKeyRelationObservation;
+    private createNullableSingleRecordRelationObservation;
+    private rememberHasManyRelationObservation;
+    private rememberBelongsToRelationObservation;
+    private getRelationQueryObservation;
+    private createHasManyRelationObservation;
+    private createBelongsToRelationObservation;
+    private recordBelongsToManyRelationObservations;
+    private createBelongsToManyRelatedObservationMetadata;
+    private createRelationAggregateObservation;
+    private setRelationAggregateObservationMetadata;
+    private getRelationAggregateObservationMetadata;
+    private createRelationAggregateObservationTarget;
     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>>;
@@ -1228,10 +1497,7 @@ declare class ModelRepository<TTable extends TableDefinition = TableDefinition>
     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;
@@ -1266,6 +1532,7 @@ declare class ModelRepository<TTable extends TableDefinition = TableDefinition>
     private getMorphToManyEntitiesByParentKey;
     private getMorphedByManyEntitiesByParentKey;
     private createBelongsToManyPivotQuery;
+    private resolvePivotTableName;
     private createMorphToManyPivotQuery;
     private createMorphedByManyPivotQuery;
     private applyPivotQueryConfig;
@@ -1292,33 +1559,17 @@ declare class ModelRepository<TTable extends TableDefinition = TableDefinition>
     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<TBuilder> = (query: TBuilder) => unknown;
@@ -1535,6 +1786,7 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
     dump(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     cache(config: QueryCacheTtlInput | QueryCacheConfig): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     get(): Promise<ModelCollection<TTable, TRelations, EntityWithLoaded<TTable, TRelations, TLoaded>>>;
+    private hydrateRows;
     getJson(): Promise<SerializedEntityWithLoaded<TTable, TLoaded>[]>;
     first(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded> | undefined>;
     firstJson(): Promise<SerializedEntityWithLoaded<TTable, TLoaded> | undefined>;
@@ -1610,6 +1862,23 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
     private resolveBelongsToRelationName;
     private extractNumericValues;
     private getUnpaginatedEntities;
+    private getUnpaginatedRowsAndEntities;
+    private getRowsAndEntities;
+    private recordCollectionRelationAggregateObservations;
+    private recordCollectionRelationObservations;
+    private recordSingleRelationObservations;
+    private recordPaginatedRelationObservations;
+    private recordSingleRelationAggregateObservations;
+    private recordPaginatedRelationAggregateObservations;
+    private canBindRowsToSerializedResultBase;
+    private canBindRowsToSerializedResult;
+    private createPatchableEagerRelationHydrations;
+    private createPatchableRelatedHydrationQuery;
+    private isQueryableModelReference;
+    private rebindRowsToSerializedResult;
+    private rebindRowsToPaginatedResult;
+    private rebindRowsToSimplePaginatedResult;
+    private rebindRowsToCursorPaginatedResult;
     private prepareCursorPaginationQuery;
     private resolveCursorOrders;
     private readCursorColumnValue;
@@ -2997,6 +3266,49 @@ declare class DatabaseContext {
 }
 declare function createDatabase(options: DatabaseContextOptions): DatabaseContext;
 
+type DatabaseDriverConnection = {
+    readonly url?: string;
+    readonly host?: string;
+    readonly port?: number;
+    readonly username?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly ssl?: boolean | Record<string, unknown>;
+};
+type DatabaseDriverFactory = {
+    readonly driver: string;
+    readonly supportsConcurrentTransactionScopes?: boolean;
+    create(connection: DatabaseDriverConnection): DriverAdapter;
+};
+declare function registerDatabaseDriverFactory(factory: DatabaseDriverFactory): void;
+declare function getDatabaseDriverFactory(driver: string): DatabaseDriverFactory | undefined;
+declare function unregisterDatabaseDriverFactory(factory: DatabaseDriverFactory): void;
+declare class DeferredDatabaseDriverAdapter implements DriverAdapter {
+    private readonly driver;
+    private readonly connection;
+    private adapter?;
+    private pending?;
+    constructor(driver: string, connection: DatabaseDriverConnection);
+    get supportsConcurrentTransactionScopes(): boolean;
+    private resolve;
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    ensureDatabaseExists(): Promise<void>;
+    isDatabaseMissingError(error: unknown): 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?: DatabaseTransactionOptions): 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>;
+}
+declare function createDeferredDatabaseDriverAdapter(driver: string, connection: DatabaseDriverConnection): DriverAdapter;
+
 declare function unsafeSql(sql: string, bindings?: readonly unknown[], source?: string): UnsafeStatement;
 
 declare class DatabaseError extends Error {
@@ -3091,137 +3403,6 @@ declare class AsyncConnectionContext {
 }
 declare const connectionAsyncContext: AsyncConnectionContext;
 
-declare abstract class LazyDriverAdapter implements DriverAdapter {
-    private adapter?;
-    private pending?;
-    protected connected: boolean;
-    protected abstract readonly driverLabel: string;
-    protected abstract createConcreteAdapter(): Promise<DriverAdapter>;
-    protected resolveAdapter(): Promise<DriverAdapter>;
-    initialize(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    ensureDatabaseExists(): Promise<void>;
-    isDatabaseMissingError(error: unknown): 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?: DatabaseTransactionOptions): 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 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 extends LazyDriverAdapter {
-    private readonly options;
-    protected readonly driverLabel = "SQLiteAdapter";
-    readonly filename: string;
-    constructor(options?: SQLiteAdapterOptions);
-    protected createConcreteAdapter(): Promise<DriverAdapter>;
-    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-}
-declare function createSQLiteAdapter(options?: SQLiteAdapterOptions): SQLiteAdapter;
-interface PostgresQueryableLike {
-    query(sql: string, bindings?: readonly unknown[]): Promise<{
-        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 PostgresConnectionConfig {
-    connectionString?: string;
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    database?: string;
-    ssl?: boolean | Record<string, unknown>;
-}
-interface PostgresAdapterOptions<TConfig extends PostgresConnectionConfig = PostgresConnectionConfig> {
-    connectionString?: string;
-    config?: TConfig;
-    client?: PostgresClientLike;
-    pool?: PostgresPoolLike;
-    createPool?: (config?: TConfig) => PostgresPoolLike;
-}
-declare class PostgresAdapter<TConfig extends PostgresConnectionConfig = PostgresConnectionConfig> extends LazyDriverAdapter {
-    private readonly options;
-    protected readonly driverLabel = "PostgresAdapter";
-    readonly config?: TConfig;
-    constructor(options?: PostgresAdapterOptions<TConfig>);
-    protected createConcreteAdapter(): Promise<DriverAdapter>;
-    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-}
-declare function createPostgresAdapter<TConfig extends PostgresConnectionConfig = PostgresConnectionConfig>(options?: PostgresAdapterOptions<TConfig>): PostgresAdapter<TConfig>;
-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 MySQLConnectionConfig {
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    database?: string;
-    ssl?: unknown;
-    uri?: string;
-}
-interface MySQLAdapterOptions<TConfig extends MySQLConnectionConfig = MySQLConnectionConfig> {
-    uri?: string;
-    config?: TConfig;
-    client?: MySQLClientLike;
-    pool?: MySQLPoolLike;
-    createPool?: (config: TConfig) => MySQLPoolLike;
-}
-declare class MySQLAdapter<TConfig extends MySQLConnectionConfig = MySQLConnectionConfig> extends LazyDriverAdapter {
-    private readonly options;
-    protected readonly driverLabel = "MySQLAdapter";
-    readonly config: TConfig;
-    constructor(options?: MySQLAdapterOptions<TConfig>);
-    protected createConcreteAdapter(): Promise<DriverAdapter>;
-    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
-}
-declare function createMySQLAdapter<TConfig extends MySQLConnectionConfig = MySQLConnectionConfig>(options?: MySQLAdapterOptions<TConfig>): MySQLAdapter<TConfig>;
-
 type SupportedDatabaseDriver = 'sqlite' | 'postgres' | 'mysql';
 interface RuntimeConnectionConfig {
     driver?: SupportedDatabaseDriver | string;
@@ -3261,7 +3442,7 @@ type RuntimeAdapterConnectionConfig = {
 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<PostgresConnectionConfig> | MySQLAdapter<MySQLConnectionConfig>;
+declare function createAdapter(driver: SupportedDatabaseDriver, connection: string | RuntimeAdapterConnectionConfig): DriverAdapter;
 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;
@@ -3303,6 +3484,7 @@ declare class SQLQueryCompiler {
     protected compileInsertPrefix(_plan: InsertQueryPlan): string;
     protected compileInsertSuffix(_plan: InsertQueryPlan): string;
     protected compileUpsertSuffix(plan: UpsertQueryPlan, _insertColumns: readonly string[]): string;
+    protected compileReturningClause(returning: boolean): string;
     protected compileHavingExpression(expression: string): string;
     protected compileColumnReference(reference: string): string;
     protected compileTableReference(reference: string): string;
@@ -3881,53 +4063,4 @@ declare function HasUuids<TTable extends TableDefinition = TableDefinition>(opti
 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;
-    authorizationPolicies: string;
-    authorizationAbilities: 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, type AnyModelDefinition, AsyncConnectionContext, type BelongsToManyRelationDefinition, type BelongsToManyRelationMethods, type BelongsToRelationDefinition, type BelongsToRelationMethods, type BoundTableDefinition, type BuiltInCastName, type BuiltInCastString, CapabilityError, type CastableDefinition, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, type CursorPaginationOptions, 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 DatabaseDependencyCollectionResult, type DatabaseDependencyInvalidationEvent, type DatabaseDependencyInvalidationListener, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DatabaseQueryCacheBridge, type DatabaseTransactionOptions, type DefineModelOptions, type DefineTableOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, type EmptyScopeMap, Entity, type EntityWithLoaded, type EnumCastDefinition, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, type HasManyRelationDefinition, type HasManyRelationMethods, type HasManyThroughRelationDefinition, type HasOneOfManyRelationDefinition, type HasOneRelationDefinition, type HasOneRelationMethods, type HasOneThroughRelationDefinition, 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 ModelCastDefinition, type ModelCollection, type ModelDefinition, type ModelDefinitionLike, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, type ModelRelationPath, ModelRepository, type ModelRepositoryLike, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, type MorphManyRelationDefinition, type MorphOneOfManyRelationDefinition, type MorphOneRelationDefinition, type MorphToManyRelationDefinition, type MorphToRelationDefinition, type MorphedByManyRelationDefinition, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, MySQLQueryCompiler, type MySQLQueryableLike, MySQLSchemaCompiler, type NormalizedHoloProjectConfig, type PaginatedResult, type PaginationMeta, type PaginationOptions, type PivotRelationMethods, PostgresAdapter, type PostgresAdapterOptions, type PostgresClientLike, type PostgresPoolLike, PostgresQueryCompiler, type PostgresQueryableLike, PostgresSchemaCompiler, type QueryCacheConfig, type QueryCacheFlexibleTtlInput, type QueryCacheTtlInput, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RegisteredModelName, type RegisteredModelReference, type RegisteredModels, type RelatedColumnNameForRelationPath, type RelationConstraintDefinition, 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 SerializeLoaded, type SerializeModels, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type StaticModelApi, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type TransactionMode, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, collectDatabaseQueryDependencies, column, compileDialectDefaultLiteral, configureDB, configureDatabaseQueryCacheBridge, 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, getDatabaseQueryCacheBridge, 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, onDatabaseDependencyInvalidated, parseDatabaseDriver, queryCacheInternals, recordDatabaseQueryDependencies, redactBindings, redactSql, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, renderGeneratedSchemaRuntimeModule, resetDB, resetDatabaseDependencyInvalidationListeners, resetDatabaseQueryCacheBridge, resetGlobalModelRegistry, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, serializeModels, uniqueSlug, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };
+export { type AddColumnOperation, type AlterColumnOperation, type AnyColumnDefinition, type AnyModelDefinition, AsyncConnectionContext, type BelongsToManyRelationDefinition, type BelongsToManyRelationMethods, type BelongsToRelationDefinition, type BelongsToRelationMethods, type BoundTableDefinition, type BuiltInCastName, type BuiltInCastString, CapabilityError, type CastableDefinition, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, type CursorPaginationOptions, DB, type DDLOperation, type DDLStatement, DEFAULT_CAPABILITIES, DEFAULT_SECURITY_POLICY, DIALECT_ID_STRATEGY_MAP, DIALECT_LOGICAL_TYPE_MAP, DIALECT_VECTOR_SUPPORT, type DatabaseCapabilities, DatabaseContext, type DatabaseContextOptions, type DatabaseDependencyCollectionResult, type DatabaseDependencyInvalidationEvent, type DatabaseDependencyInvalidationListener, type DatabaseDriverConnection, type DatabaseDriverFactory, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DatabaseQueryCacheBridge, type DatabaseTransactionOptions, DeferredDatabaseDriverAdapter, type DefineModelOptions, type DefineTableOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, type EmptyScopeMap, Entity, type EntityWithLoaded, type EnumCastDefinition, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, type HasManyRelationDefinition, type HasManyRelationMethods, type HasManyThroughRelationDefinition, type HasOneOfManyRelationDefinition, type HasOneRelationDefinition, type HasOneRelationMethods, type HasOneThroughRelationDefinition, HasSnowflakes, HasUlids, HasUniqueIds, HasUuids, 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 ModelCastDefinition, type ModelCollection, type ModelDefinition, type ModelDefinitionLike, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, type ModelRelationPath, ModelRepository, type ModelRepositoryLike, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, type MorphManyRelationDefinition, type MorphOneOfManyRelationDefinition, type MorphOneRelationDefinition, type MorphToManyRelationDefinition, type MorphToRelationDefinition, type MorphedByManyRelationDefinition, MySQLQueryCompiler, MySQLSchemaCompiler, type PaginatedResult, type PaginationMeta, type PaginationOptions, type PivotRelationMethods, PostgresQueryCompiler, PostgresSchemaCompiler, type QueryCacheConfig, type QueryCacheFlexibleTtlInput, type QueryCacheTtlInput, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RegisteredModelName, type RegisteredModelReference, type RegisteredModels, type RelatedColumnNameForRelationPath, type RelationConstraintDefinition, 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, SQLiteQueryCompiler, SQLiteSchemaCompiler, 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 SerializeLoaded, type SerializeModels, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type StaticModelApi, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type TransactionMode, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, collectDatabaseQueryDependencies, column, compileDialectDefaultLiteral, configureDB, configureDatabaseQueryCacheBridge, connectionAsyncContext, createAdapter, createCapabilities, createConnectionManager, createCursorPaginator, createDatabase, createDeferredDatabaseDriverAdapter, createDeleteQueryPlan, createDialect, createFactoryService, createForeignKeyOperation, createIndexOperation, createInsertQueryPlan, createMigrationFileName, createMigrationService, createMigrationTimestamp, createModelCollection, createModelEventService, createModelRegistry, createPaginator, createQueryScheduler, createRuntimeConnectionOptions, createRuntimeLogger, diffSchema as createSchemaDiff, createSchemaRegistry, createSchemaService, createSecurityPolicy, createSeederService, createSelectQueryPlan, createSimplePaginator, createTableOperation, createTableSource, createUpdateQueryPlan, defineFactory, defineGeneratedTable, defineMigration, defineModel, defineSeeder, diffSchema, dropColumnOperation, dropForeignKeyOperation, dropIndexOperation, dropTableOperation, encryptedCast, enumCast, generateMigrationTemplate, generateSnowflake, generateUlid, generateUuidV7, getDatabaseDriverFactory, getDatabaseQueryCacheBridge, getGeneratedTableDefinition, getModelDefinition, hasMany, hasManyThrough, hasOne, hasOneThrough, inferMigrationTableName, inferMigrationTemplateKind, isSupportedDatabaseDriver, latestMorphOne, latestOfMany, listGeneratedTableDefinitions, morphMany, morphOfMany, morphOne, morphTo, morphToMany, morphedByMany, normalizeDialectReadValue, normalizeDialectWriteValue, normalizeMigrationSlug, ofMany, oldestMorphOne, oldestOfMany, onDatabaseDependencyInvalidated, parseDatabaseDriver, queryCacheInternals, recordDatabaseQueryDependencies, redactBindings, redactSql, registerDatabaseDriverFactory, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, renderGeneratedSchemaRuntimeModule, resetDB, resetDatabaseDependencyInvalidationListeners, resetDatabaseQueryCacheBridge, resetGlobalModelRegistry, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, serializeModels, uniqueSlug, unregisterDatabaseDriverFactory, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };