@holo-js/db 0.2.4 → 0.2.6

package/dist/index.d.ts

@@ -599,11 +599,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 +614,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 +639,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 +691,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,29 +881,62 @@ 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 notifyDatabaseDependencyInvalidationListeners(event: DatabaseDependencyInvalidationEvent): Promise<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: 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, 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;
     getQueryCacheBridgeState: typeof getQueryCacheBridgeState;
+    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;
@@ -983,6 +1205,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>>;
@@ -1017,7 +1248,23 @@ 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 invalidateSourceTableQueries;
+    private captureUpdatedMutationRows;
+    private captureDeletedMutationRows;
+    private applyCapturedUpdateValues;
+    private applyCapturedUpdateValue;
+    private applyCapturedJsonUpdateOperation;
+    private isCapturedJsonUpdateOperation;
+    private applyCapturedJsonPathValue;
+    private isJsonRecord;
+    private captureUpsertPreviousRows;
+    private hasUniqueByValues;
+    private rowsMatchUniqueBy;
+    private shouldUseReturningMutationRows;
+    private queryReturningMutationRows;
+    private freezeMutationRows;
+    private readReturnedLastInsertId;
+    private invalidateInsertQueries;
+    private invalidateMutationQueries;
     private getCompiler;
     private getUnpaginatedRows;
     private resolvePrimaryKeyColumn;
@@ -1142,6 +1389,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>>;
@@ -1218,6 +1483,7 @@ declare class ModelRepository<TTable extends TableDefinition = TableDefinition>
     private getAggregateAttributeKey;
     private getRelationAggregateValues;
     private computeAggregateValue;
+    private computeExtremeAggregateValue;
     private assertNumericAggregateValue;
     private getRelatedEntitiesByParentKey;
     attachCollection(entities: readonly Entity<TTable>[]): readonly Entity<TTable>[];
@@ -1253,6 +1519,7 @@ declare class ModelRepository<TTable extends TableDefinition = TableDefinition>
     private getMorphToManyEntitiesByParentKey;
     private getMorphedByManyEntitiesByParentKey;
     private createBelongsToManyPivotQuery;
+    private resolvePivotTableName;
     private createMorphToManyPivotQuery;
     private createMorphedByManyPivotQuery;
     private applyPivotQueryConfig;
@@ -1522,6 +1789,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>;
@@ -1597,6 +1865,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;
@@ -3290,6 +3575,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;