hysteria-orm 12.2.2 → 12.4.0

package/lib/index.d.ts

@@ -733,12 +733,14 @@ declare class WhereNode extends QueryNode {
     column: string;
     isNegated: boolean;
     operator: BinaryOperatorType$2;
-    value: BaseValues$2 | BaseValues$2[];
+    value: BaseValues$2 | BaseValues$2[] | BaseValues$2[][];
+    /** Set for a row-value `(a, b) in ((1, 2), ...)` predicate, where `value` is a list of tuples. */
+    tupleColumns?: string[];
     chainsWith: "and" | "or";
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(column: string, chainsWith: "and" | "or", isNegated: boolean | undefined, operator: BinaryOperatorType$2, value: BaseValues$2 | BaseValues$2[], isRawValue?: boolean);
+    constructor(column: string, chainsWith: "and" | "or", isNegated: boolean | undefined, operator: BinaryOperatorType$2, value: BaseValues$2 | BaseValues$2[] | BaseValues$2[][], isRawValue?: boolean);
 }
 
 type SubqueryOperatorType = "in" | "not in" | "exists" | "not exists" | "between" | "not between" | ">" | "<" | ">=" | "<=" | (string & {});
@@ -756,10 +758,11 @@ declare class WhereSubqueryNode extends QueryNode {
 declare class WhereGroupNode extends QueryNode {
     nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
     chainsWith: "and" | "or";
+    isNegated: boolean;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[], chainsWith?: "and" | "or");
+    constructor(nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[], chainsWith?: "and" | "or", isNegated?: boolean);
 }
 
 type BaseValues$1 = string | number | boolean | null | SqlFuncNode;
@@ -921,22 +924,26 @@ declare class UnionNode extends QueryNode {
     query: QueryNode | QueryNode[] | string;
     isAll: boolean;
     type: SetOperationType;
+    bindings?: any[];
+    /** Wraps this branch in parentheses, needed when it carries its own ORDER BY or LIMIT. */
+    wrap?: boolean;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(query: QueryNode | QueryNode[] | string, isAll?: boolean, type?: SetOperationType);
+    constructor(query: QueryNode | QueryNode[] | string, isAll?: boolean, type?: SetOperationType, bindings?: any[]);
 }
 
 declare class WithNode extends QueryNode {
     alias: string;
     body: QueryNode | QueryNode[];
     clause: string;
+    columns?: string[];
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(clause: string, alias: string, body: QueryNode | QueryNode[]);
+    constructor(clause: string, alias: string, body: QueryNode | QueryNode[], columns?: string[]);
 }
 
 declare abstract class DataSource {
@@ -1831,6 +1838,8 @@ declare class FromNode extends QueryNode {
     alias?: string;
     /** Schema applied to the table reference (e.g. `public.users`). */
     schema?: string;
+    /** PostgreSQL `FROM ONLY`, which skips rows of inheriting tables. */
+    only?: boolean;
     constructor(table: string | QueryNode | QueryNode[], alias?: string);
 }
 
@@ -1929,6 +1938,18 @@ declare class InterpreterUtils {
      * @description Formats the from node for write operations removing the "from" keyword
      */
     getFromForWriteOperations(dbType: SqlDataSourceType, fromNode: FromNode): string;
+    /**
+     * @description Renders the auxiliary source of a write (`update ... from`,
+     * `delete ... using`). Unlike the main write table it keeps its alias, since the
+     * clause is unreadable without one.
+     */
+    getWriteSource(dbType: SqlDataSourceType, fromNode: FromNode, startIndex: number): ReturnType<typeof AstParser.prototype.parse>;
+    /**
+     * @description Renders CTE nodes as a leading `with ...` clause. Used by writes
+     * whose dialect places the CTE inside the statement body (INSERT) rather than
+     * as a sibling node.
+     */
+    renderWithNodes(dbType: SqlDataSourceType, withNodes: WithNode[] | undefined, startIndex: number): ReturnType<typeof AstParser.prototype.parse>;
 }
 
 /**
@@ -1972,6 +1993,67 @@ declare class WriteOperation<T> implements PromiseLike<T> {
     unWrap(): ReturnType<typeof AstParser.prototype.parse>;
 }
 
+type InsertConflictMode = "update" | "ignore";
+type InsertConflictConfig = {
+    conflictColumns: string[];
+    mode: InsertConflictMode;
+    columnsToUpdate: string[];
+    /** Raw conflict target, e.g. `(lower(email)) where deleted_at is null`. */
+    conflictTargetRaw?: string;
+    /** Named unique constraint to conflict on. */
+    conflictConstraint?: string;
+    /** Builds the `WHERE` of a `do update` clause. */
+    mergeWhere?: (qb: WhereOnlyQueryBuilder<any>) => void;
+};
+/**
+ * @description A WriteOperation for inserts that can be given a conflict action
+ * (`onConflict(...).merge()` or `.ignore()`) before it is awaited.
+ */
+declare class InsertWriteOperation<T, K extends string = string> extends WriteOperation<T> {
+    private conflictState;
+    private conflictColumns;
+    private conflictTargetRaw;
+    private conflictConstraint;
+    private readonly commit;
+    private readonly insertColumns;
+    private readonly caller;
+    constructor(unWrapFn: () => ReturnType<typeof AstParser.prototype.parse>, toSqlFn: () => ReturnType<typeof AstParser.prototype.parse>, toQueryFn: () => string, executor: () => Promise<T>, commit: (config: InsertConflictConfig) => void, insertColumns: readonly string[], caller: string);
+    /**
+     * @description Sets the conflict target: column(s), a raw expression such as an
+     * index predicate, or a named constraint
+     * @description With no arguments the conflict has no explicit target, which is
+     * only valid with `ignore()`
+     * @description Must be followed by `merge()` or `ignore()`
+     */
+    onConflict(): this;
+    onConflict(column: K): this;
+    onConflict(columns: K[]): this;
+    onConflict(target: RawNode): this;
+    onConflict(options: {
+        constraint: string;
+    }): this;
+    /**
+     * @description Updates the inserted columns when the conflict target already exists
+     * @description Without arguments every inserted column except the conflict target is updated
+     * @description Pass `{ where }` to guard the update, PostgreSQL and SQLite only
+     * @throws HysteriaError if nothing is left to update, use `ignore()` instead
+     */
+    merge(): this;
+    merge(column: K): this;
+    merge(columns: K[]): this;
+    merge(options: {
+        columns?: K[];
+        where?: (qb: WhereOnlyQueryBuilder<any>) => void;
+    }): this;
+    /**
+     * @description Leaves the existing row untouched when the conflict target already exists
+     * @description Works with or without an explicit conflict target
+     */
+    ignore(): this;
+    private requireConflictTarget;
+    private commitConflict;
+}
+
 type TransactionIsolationLevel = "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
 type StartTransactionOptions = {
     isolationLevel?: TransactionIsolationLevel;
@@ -2052,6 +2134,8 @@ declare class Transaction {
     rollback(options?: TransactionExecutionOptions): Promise<void>;
     /**
      * @description Release the connection, does nothing if the connection is already released
+     * @param failure The COMMIT/ROLLBACK error, forwarded to the adapter so it can
+     * discard the connection instead of returning an unknown-state session to the pool
      */
     private releaseConnection;
     private getIsolationLevelQuery;
@@ -2076,6 +2160,21 @@ type ModelDataProperties = Pick<Model, ExcludeMethods<Model>>;
  * Includes only data columns from the model, excluding foreign keys and relation accessors.
  */
 type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & ModelDataProperties;
+/**
+ * A JSON mutation helper writes a path rather than a value, so it is accepted only
+ * where the column is JSON: `unknown` from an untyped `col.json()`, or an object
+ * type from a structured `col.jsonb<T>()`.
+ */
+type JsonMutationFor<V> = [unknown] extends [NonNullable<V>] ? JsonMutationNode : [NonNullable<V>] extends [object] ? JsonMutationNode : never;
+/**
+ * Values accepted by a model insert or update: the column's own type, or an
+ * expression node such as `sql.rawStatement("LOWER(email)")`. The JSON mutation
+ * helpers (`sql.jsonSet`, `sql.jsonInsert`, `sql.jsonRemove`) are limited to JSON
+ * columns, since they emit a path write rather than a value.
+ */
+type ModelWriteData<T extends Model> = {
+    [K in keyof ModelWithoutRelations<T>]?: ModelWithoutRelations<T>[K] | RawNode | SqlFuncNode | JsonMutationFor<ModelWithoutRelations<T>[K]>;
+};
 /**
  * Return type for Model query/mutation methods.
  * Represents data-only properties without any business logic.
@@ -2141,6 +2240,10 @@ type RawModelOptions = {
      * Alias for the table
      */
     alias?: string;
+    /**
+     * @description PostgreSQL only. Renders `from only <table>`, skipping rows of tables that inherit from it
+     */
+    only?: boolean;
     /**
      * @description Convert the column casing before making a Database query, by default preserves what is provided
      */
@@ -2197,17 +2300,25 @@ declare class ModelManager<T extends Model> {
      * @throws {HysteriaError} if the model has no primary key
      */
     findOneByPrimaryKey(value: string | number, returning?: ModelKey<T>[]): Promise<ModelWithoutRelations<T> | null>;
+    /**
+     * @description Places the CTEs ahead of the insert, except on MySQL/MariaDB which only
+     * accept them inline after the column list (rendered by the insert interpreter).
+     */
+    private withInsertNodes;
     /**
      * @description Creates a new record in the database
      * @returns WriteOperation that executes when awaited
      */
-    insert(model: Partial<T>, options?: InsertOptions<T>): WriteOperation<ModelWithoutRelations<T>>;
+    insert(model: ModelWriteData<T>, options?: InsertOptions<T>): InsertWriteOperation<ModelWithoutRelations<T>>;
     /**
      * @description Creates multiple records in the database
      * @returns WriteOperation that executes when awaited
      */
-    insertMany(models: Partial<T>[], options?: InsertOptions<T>): WriteOperation<ModelWithoutRelations<T>[]>;
+    insertMany(models: ModelWriteData<T>[], options?: InsertOptions<T>): InsertWriteOperation<ModelWithoutRelations<T>[]>;
+    private insertManyInternal;
     upsertMany(conflictColumns: string[], columnsToUpdate: string[], data: ModelWithoutRelations<T>[], options?: UpsertOptions<T>): WriteOperation<ModelWithoutRelations<T>[]>;
+    private executeInsertConflict;
+    private refetchByConflictColumn;
     /**
      * @description Executes a MERGE statement for MSSQL upsert operations
      */
@@ -2235,7 +2346,36 @@ declare class ModelManager<T extends Model> {
      */
     private handleMysqlInsert;
     private handleWhereCondition;
-    private applyFieldCondition;
+}
+
+declare class JoinNode extends QueryNode {
+    table: string;
+    left: string;
+    right: string;
+    on?: {
+        left?: string;
+        right?: string;
+        operator: string;
+    };
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    type: "inner" | "left" | "right" | "full" | "cross" | "natural";
+    additionalConditions?: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
+    /** When set, renders `using (cols)` instead of an `on` condition. */
+    using?: string[];
+    /** Schema applied to the joined table reference. */
+    schema?: string;
+    /** Values for the `?` placeholders of a raw join fragment. */
+    bindings?: any[];
+    /** When set, `table` holds the derived table's alias and this holds its body. */
+    subquery?: QueryNode[];
+    constructor(table: string, left: string, right: string, type: "inner" | "left" | "right" | "full" | "cross" | "natural" | undefined, on: {
+        left?: string;
+        right?: string;
+        operator: string;
+    }, isRawValue?: boolean, additionalConditions?: (WhereNode | WhereGroupNode | WhereSubqueryNode)[]);
 }
 
 declare class DeleteNode extends QueryNode {
@@ -2244,6 +2384,10 @@ declare class DeleteNode extends QueryNode {
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
+    /** Joins rendered after the table, so MySQL can delete from a join. */
+    joinNodes?: JoinNode[];
+    /** `delete ... using <source>`, rendered by the dialects that accept it. */
+    usingNode?: FromNode;
     constructor(fromNode: FromNode, isRawValue?: boolean);
 }
 
@@ -2290,16 +2434,28 @@ type TableForeignKeyInfo = {
     onUpdate?: string | null;
 };
 
+type InsertNodeOptions = {
+    withNodes?: WithNode[];
+    source?: QueryNode[];
+    targetColumns?: string[];
+    ignoreInto?: boolean;
+    disambiguateSource?: boolean;
+};
 declare class InsertNode extends QueryNode {
     fromNode: FromNode;
     records: Record<string, any>[];
     returning?: string[];
     disableReturning: boolean;
+    withNodes?: WithNode[];
+    source?: QueryNode[];
+    targetColumns?: string[];
+    ignoreInto: boolean;
+    disambiguateSource: boolean;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(fromNode: FromNode, records?: Record<string, any>[], returning?: string[], disableReturning?: boolean, isRawValue?: boolean);
+    constructor(fromNode: FromNode, records?: Record<string, any>[], returning?: string[], disableReturning?: boolean, isRawValue?: boolean, options?: InsertNodeOptions);
 }
 
 declare class OnDuplicateNode extends QueryNode {
@@ -2312,6 +2468,12 @@ declare class OnDuplicateNode extends QueryNode {
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
+    /** Raw conflict target, rendered in place of the column list. */
+    conflictTargetRaw?: string;
+    /** Named unique constraint to conflict on. */
+    conflictConstraint?: string;
+    /** Guards the `do update` clause; PostgreSQL and SQLite only. */
+    whereNodes?: (WhereNode | WhereGroupNode)[];
     constructor(table: string, conflictColumns: string[], columnsToUpdate: string[], mode?: "update" | "ignore", returning?: string[], isRawValue?: boolean);
 }
 
@@ -2333,13 +2495,19 @@ declare class ReturningNode extends QueryNode {
 
 type UnionCallBack<T extends Model> = (queryBuilder: QueryBuilder<T>) => QueryBuilder<T>;
 
+type TruncateOptions = {
+    cascade?: boolean;
+    restartIdentity?: boolean;
+    continueIdentity?: boolean;
+};
 declare class TruncateNode extends QueryNode {
     fromNode: FromNode | string;
+    options?: TruncateOptions;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(fromNode: FromNode | string, isRawValue?: boolean);
+    constructor(fromNode: FromNode | string, isRawValue?: boolean, options?: TruncateOptions);
 }
 
 declare class UpdateNode extends QueryNode {
@@ -2350,9 +2518,51 @@ declare class UpdateNode extends QueryNode {
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
+    /** Joins rendered between the table and SET, so MySQL can update from a join. */
+    joinNodes?: JoinNode[];
+    /** `update ... from <source>`, rendered by the dialects that accept it. */
+    fromSourceNode?: FromNode;
     constructor(fromNode: FromNode, columns?: string[], values?: (any | RawNode | SqlFuncNode)[], isRawValue?: boolean);
 }
 
+type Operation = "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "OTHER";
+interface QueryContext {
+    id: string;
+    sql: string;
+    params: any[];
+    model?: any;
+    operation?: string;
+    timestamp: number;
+    /** Anything else attached by the caller through `.queryContext()` */
+    [key: string]: any;
+}
+/**
+ * Query context extended with execution metadata.
+ * @property duration - Query execution time in milliseconds (ms)
+ */
+type QueryContextWithDuration = QueryContext & {
+    duration: number;
+    result?: any;
+};
+interface QueryObserver {
+    onBeforeQuery?(ctx: QueryContext): Promise<void> | void;
+    onAfterQuery?(ctx: QueryContextWithDuration): Promise<void> | void;
+    onQueryError?(ctx: QueryContext & {
+        error: Error;
+    }): Promise<void> | void;
+}
+declare class ObserverChain {
+    private observers;
+    constructor(observers?: QueryObserver[]);
+    add(observer: QueryObserver): void;
+    notifyBefore(ctx: QueryContext): Promise<void>;
+    notifyAfter(ctx: QueryContextWithDuration, result?: any): Promise<void>;
+    notifyError(ctx: QueryContext & {
+        error: Error;
+    }): Promise<void>;
+}
+declare const deriveOperationFromQuery: (sql: string) => string;
+
 /**
  * PostgreSQL / CockroachDB: `-- line` or `/* block *\/`.
  */
@@ -2907,6 +3117,12 @@ type SoftDeleteOptions<T> = {
 interface SubQueryable {
     extractQueryNodes(): QueryNode[];
 }
+/**
+ * @description Which otherwise-select-only clauses a write operation tolerates.
+ */
+interface WriteClauseAllowances {
+    allowCte?: boolean;
+}
 declare class QueryBuilder<T extends Model = any, S extends Record<string, any> = Record<string, any>, D extends SqlDataSourceType = SqlDataSourceType> extends JsonQueryBuilder<T, S> implements SubQueryable {
     model: typeof Model;
     protected astParser: AstParser;
@@ -2919,9 +3135,13 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
     protected _interpreterUtils: InterpreterUtils | null;
     protected get interpreterUtils(): InterpreterUtils;
     protected insertNode: InsertNode | null;
+    protected insertNodeSource: QueryNode[] | undefined;
     protected onDuplicateNode: OnDuplicateNode | null;
+    protected insertConflictConfig: InsertConflictConfig | null;
     protected updateNode: UpdateNode | null;
+    protected updateFromNode: FromNode | null;
     protected deleteNode: DeleteNode | null;
+    protected deleteUsingNode: FromNode | null;
     protected returningNode: ReturningNode | null;
     protected truncateNode: TruncateNode | null;
     protected replicationMode: ReplicationType | null;
@@ -2930,6 +3150,8 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
         ms: number;
         cancel: boolean;
     };
+    protected queryContextOptions?: Partial<QueryContext>;
+    protected shouldLogQuery?: boolean;
     constructor(model: typeof Model, sqlDataSource: SqlDataSource);
     /**
      * @description Sets the replication mode for the query builder
@@ -3039,6 +3261,11 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * @param key - The column to retrieve from the results, must be a Model Column
      */
     pluck<K extends RawModelKey<T>>(key: K): Promise<PluckReturnType<T, K>>;
+    /**
+     * @description Executes the query and retrieves a single column from the first result, or undefined when there is none.
+     * @param key - A selected column, or any Model column when the query selects everything
+     */
+    value<K extends ValueKey<T, S>>(key: K): Promise<PluckReturnType<T, K & RawModelKey<T>>[number] | undefined>;
     /**
      * @description Executes the query and retrieves a single result.
      */
@@ -3143,6 +3370,16 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
     timeout(ms: number, options?: {
         cancel?: boolean;
     }): this;
+    /**
+     * @description Attaches extra fields to the query context handed to observers.
+     * `sql`, `params`, `id`, `operation` and `timestamp` are always filled in by the runner.
+     */
+    queryContext(ctx: Partial<QueryContext>): this;
+    /**
+     * @description Logs this query regardless of the data source setting, or silences it
+     * with `false`. Without an argument it turns logging on.
+     */
+    debug(enable?: boolean): this;
     /**
      * @description Prepends a native SQL comment to the select statement, in the
      * syntax of the active dialect (e.g. `-- line`, `/* block *\/`; MySQL adds
@@ -3174,27 +3411,32 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * because the driver reads it as a bind placeholder even inside a comment.
      */
     private assertValidSqlComment;
+    private resolveSetOperationOptions;
     /**
      * @description Adds a UNION to the query.
+     * @param options.wrap - Wraps the branch in parentheses
      */
-    union(query: string, bindings?: any[]): this;
-    union(cb: UnionCallBack<T>): this;
+    union(query: string, bindings?: any[], options?: SetOperationOptions): this;
+    union(cb: UnionCallBack<T>, options?: SetOperationOptions): this;
     /**
      * @description Adds a UNION ALL to the query.
+     * @param options.wrap - Wraps the branch in parentheses
      */
-    unionAll(query: string, bindings?: any[]): this;
-    unionAll(cb: UnionCallBack<T>): this;
-    unionAll(queryBuilder: QueryBuilder<any>): this;
+    unionAll(query: string, bindings?: any[], options?: SetOperationOptions): this;
+    unionAll(cb: UnionCallBack<T>, options?: SetOperationOptions): this;
+    unionAll(queryBuilder: QueryBuilder<any>, options?: SetOperationOptions): this;
     /**
      * @description Adds an INTERSECT to the query (keeps only rows present in both queries).
+     * @param options.wrap - Wraps the branch in parentheses
      */
-    intersect(query: string): this;
-    intersect(cb: UnionCallBack<T>): this;
+    intersect(query: string, bindings?: any[], options?: SetOperationOptions): this;
+    intersect(cb: UnionCallBack<T>, options?: SetOperationOptions): this;
     /**
      * @description Adds an EXCEPT to the query (keeps rows from the first query not present in the second).
+     * @param options.wrap - Wraps the branch in parentheses
      */
-    except(query: string): this;
-    except(cb: UnionCallBack<T>): this;
+    except(query: string, bindings?: any[], options?: SetOperationOptions): this;
+    except(cb: UnionCallBack<T>, options?: SetOperationOptions): this;
     private resolveSetOperationNodes;
     /**
      * @description Increments the value of a column by a given amount
@@ -3273,10 +3515,17 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * rewritten to the dialect's placeholders, in order with the rest of the query.
      */
     fromRaw(raw: string, bindings?: any[]): this;
+    /**
+     * @description Renders the FROM clause as `from only <table>`, skipping rows of
+     * tables that inherit from it. PostgreSQL only.
+     */
+    fromOnly(enable?: boolean): this;
     /**
      * @description Adds a CTE to the query using a callback to build the subquery.
+     * @param columns - Optional explicit column list for the CTE (`with t (a, b) as (...)`)
      */
     with(alias: string, cb: (qb: QueryBuilder<T>) => void | SubQueryable): this;
+    with(alias: string, columns: string[], cb: (qb: QueryBuilder<T>) => void | SubQueryable): this;
     /**
      * @description Adds a recursive CTE to the query using a callback to build the subquery.
      * @mssql not supported
@@ -3284,14 +3533,14 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
     withRecursive(alias: string, cb: (qb: QueryBuilder<T>) => void | SubQueryable): this;
     /**
      * @description Adds a materialized CTE to the query using a callback to build the subquery.
-     * @postgres only
-     * @throws HysteriaError if the database type is not postgres or cockroachdb
+     * @postgres/cockroachdb/sqlite only
+     * @throws HysteriaError if the dialect has no `as materialized`
      */
     withMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void | SubQueryable): this;
     /**
      * @description Adds a non-materialized CTE to the query using a callback to build the subquery.
-     * @postgres only
-     * @throws HysteriaError if the database type is not postgres or cockroachdb
+     * @postgres/cockroachdb only
+     * @throws HysteriaError if the dialect has no `as not materialized`
      */
     withNotMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void | SubQueryable): this;
     /**
@@ -3299,15 +3548,27 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
      * @returns WriteOperation that executes when awaited
      */
-    insert(data: Record<string, WriteQueryParam>, returning: string[]): WriteOperation<T>;
-    insert(data: Record<string, WriteQueryParam>): WriteOperation<void>;
+    insert(data: Record<string, WriteQueryParam>, returning: string[]): InsertWriteOperation<T>;
+    insert(data: Record<string, WriteQueryParam>): InsertWriteOperation<void>;
     /**
      * @description Insert multiple records into a table
      * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
      * @returns WriteOperation that executes when awaited
      */
-    insertMany(data: Record<string, WriteQueryParam>[], returning: string[]): WriteOperation<T[]>;
-    insertMany(data: Record<string, WriteQueryParam>[]): WriteOperation<void>;
+    insertMany(data: Record<string, WriteQueryParam>[], returning: string[]): InsertWriteOperation<T[]>;
+    insertMany(data: Record<string, WriteQueryParam>[]): InsertWriteOperation<void>;
+    /**
+     * @description Inserts rows in chunks of `chunkSize`, one statement per chunk, for
+     * when a single `insertMany` would exceed the driver's parameter limit
+     * @description The chunks are not wrapped in a transaction; wrap the call in
+     * `sql.transaction(...)` when the whole batch has to be atomic
+     * @returns The rows read back per chunk, empty without `returning`
+     */
+    batchInsert(data: Record<string, WriteQueryParam>[], options?: {
+        chunkSize?: number;
+        returning?: string[];
+    }): Promise<T[]>;
+    protected resolveBatchSize(chunkSize?: number): number;
     /**
      * @description Updates or creates a new record using upsert functionality
      * @param data The data to insert or update
@@ -3325,18 +3586,52 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * @returns WriteOperation that executes when awaited
      */
     upsertMany<O extends Record<string, any>>(conflictColumns: string[], columnsToUpdate: string[], data: O[], options?: UpsertOptionsRawBuilder): WriteOperation<T[]>;
+    private buildRawUpsert;
+    private buildInsertConflictCommit;
+    /**
+     * @description Inserts the rows produced by a SELECT (or a CTE feeding one) into the table.
+     * @param targetColumns - Optional destination column list; positional when omitted
+     * @param source - A builder (or callback) whose SELECT becomes the insert source
+     * @returns InsertWriteOperation, so `onConflict(...).merge()/.ignore()` chains onto it
+     * @warning Rows come from the database, so no validation, hooks or autoCreate columns run
+     */
+    insertFrom(source: QueryBuilder<any> | ((qb: QueryBuilder<any>) => QueryBuilder<any> | void)): InsertWriteOperation<T[]>;
+    insertFrom<C extends string>(targetColumns: C[], source: QueryBuilder<any> | ((qb: QueryBuilder<any>) => QueryBuilder<any> | void)): InsertWriteOperation<T[]>;
+    protected buildInsertFrom(sourceNodes: QueryNode[], targetColumns?: string[]): InsertWriteOperation<T[]>;
     /**
      * @description Executes a MERGE statement for MSSQL upsert operations (raw query builder)
      */
     private executeMssqlMergeRaw;
+    /**
+     * @description Sets the source of an `update ... from <table>` statement, so the
+     * update can read from another table. Pass a table name, or a callback to build a
+     * subquery with its alias.
+     * @postgres/cockroachdb/mssql only
+     */
+    updateFrom<X extends string>(table: TableFormat<X>, maybeAlias?: string): this;
+    updateFrom(cb: (qb: QueryBuilder<T>) => void | SubQueryable, alias: string): this;
+    /**
+     * @description Sets the source of a `delete ... using <table>` statement, so the
+     * delete can match rows against another table.
+     * @postgres/cockroachdb only
+     */
+    deleteUsing<X extends string>(table: TableFormat<X>, maybeAlias?: string): this;
+    deleteUsing(cb: (qb: QueryBuilder<T>) => void | SubQueryable, alias: string): this;
+    /**
+     * @description Builds a from node outside of the main FROM slot, for the auxiliary
+     * sources a write statement can take (`update ... from`, `delete ... using`).
+     */
+    private buildFromSource;
     /**
      * @description Updates records from a table, you can use raw statements in the data object for literal references to other columns
-     * @param data - Object with column-value pairs to update
+     * @param data - Object with column-value pairs to update, or a single column name
+     * @param value - The value when updating a single column
      * @param returning - Optional array of column names to return from the updated rows.
      *   **Note:** The `returning` parameter is only supported on PostgreSQL, CockroachDB, SQLite, and MSSQL.
      *   For MySQL and MariaDB, do not pass `returning` — the method will return the number of affected rows instead.
      * @returns WriteOperation that resolves to the number of affected rows, or the specified columns if `returning` is provided
      */
+    update(column: string, value: WriteQueryParam, returning?: string[]): WriteOperation<any>;
     update(data: Record<string, WriteQueryParam>, returning?: string[]): WriteOperation<any>;
     /**
      * @description Builds a returning clause for update/delete where the dialect has one.
@@ -3347,10 +3642,11 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
     protected withReturningNode<N>(nodes: N[]): (N | ReturningNode)[];
     /**
      * @description Deletes all records from a table
+     * @param options - `RESTART IDENTITY` / `CONTINUE IDENTITY` / `CASCADE` (PostgreSQL and CockroachDB only)
      * @warning This operation does not trigger any hook
      * @returns WriteOperation that executes when awaited
      */
-    truncate(): WriteOperation<void>;
+    truncate(options?: TruncateOptions): WriteOperation<void>;
     /**
      * @description Deletes records from a table
      * @param returning - Optional array of column names to return from the deleted rows.
@@ -3406,6 +3702,16 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * @description Removes any with query
      */
     clearWithQuery(): this;
+    /**
+     * @description Rejects clause state that would otherwise be silently dropped on a
+     * write. Thrown at call time so the failure points at the builder call.
+     */
+    protected assertWriteClausesSupported(method: string, { allowCte }?: WriteClauseAllowances): void;
+    /**
+     * @description Single source of truth for a write statement's node list. Preview
+     * (`extractQueryNodes`) and execution both go through it so they cannot diverge.
+     */
+    protected extractWriteNodes(): QueryNode[];
     extractQueryNodes(): QueryNode[];
     protected clearForFunctions(): this;
     /**
@@ -3440,42 +3746,6 @@ type SqlLiteOptions<T extends Model> = {
     customConnection?: GetConnectionReturnType<"sqlite">;
 };
 
-type Operation = "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "OTHER";
-interface QueryContext {
-    id: string;
-    sql: string;
-    params: any[];
-    model?: any;
-    operation?: string;
-    timestamp: number;
-}
-/**
- * Query context extended with execution metadata.
- * @property duration - Query execution time in milliseconds (ms)
- */
-type QueryContextWithDuration = QueryContext & {
-    duration: number;
-    result?: any;
-};
-interface QueryObserver {
-    onBeforeQuery?(ctx: QueryContext): Promise<void> | void;
-    onAfterQuery?(ctx: QueryContextWithDuration): Promise<void> | void;
-    onQueryError?(ctx: QueryContext & {
-        error: Error;
-    }): Promise<void> | void;
-}
-declare class ObserverChain {
-    private observers;
-    constructor(observers?: QueryObserver[]);
-    add(observer: QueryObserver): void;
-    notifyBefore(ctx: QueryContext): Promise<void>;
-    notifyAfter(ctx: QueryContextWithDuration, result?: any): Promise<void>;
-    notifyError(ctx: QueryContext & {
-        error: Error;
-    }): Promise<void>;
-}
-declare const deriveOperationFromQuery: (sql: string) => string;
-
 declare const SQL_DATA_SOURCE_SYMBOL: unique symbol;
 /**
  * @description The SqlDataSource class is the main class for interacting with the database, it's used to create connections, execute queries, and manage transactions
@@ -3632,6 +3902,19 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
     private onSlaveServerFailure?;
     private lazyLoad;
     private connecting;
+    /**
+     * @description Clones made from this instance. Used to notice a manual
+     * transaction that is still holding one of their connections, so cache writes
+     * raised on the original can be recognised as happening inside a transaction.
+     */
+    private cloneRegistry;
+    /**
+     * @description Set on a clone to the instance it came from, so it can take itself
+     * out of that instance's clone registry when it disconnects. Clones are short-lived
+     * and a registry that only pruned itself on cache use would retain every clone a
+     * caller that never caches had ever made.
+     */
+    private clonedFrom;
     /**
      * @description Returns the configured slave failure callback
      */
@@ -3696,6 +3979,16 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
      * ```
      */
     connect(): Promise<void>;
+    /**
+     * @description Builds the pool. Shared by `connect()` and `ensureConnected()` so both
+     * go through the same in-flight promise rather than racing each other.
+     */
+    private openConnection;
+    /**
+     * @description Closes this instance's pool if there is one, without letting a hang or a
+     * driver error mask the failure that is already in flight.
+     */
+    private closePoolOnFailure;
     /**
      * @description Returns true if the connection is established
      */
@@ -3716,6 +4009,8 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
     get models(): ModelsProxy<T, D>;
     /**
      * @description Selects a slave from the pool using the configured algorithm
+     * @description Returns null for a data source holding a pinned connection, such
+     * as a transaction clone, which has to read through that connection.
      * @returns A slave SqlDataSource instance or null if no slaves are available
      */
     getSlave(): SqlDataSource<D, T, C, E> | null;
@@ -3724,8 +4019,18 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
      * respecting (in order): explicit global transaction, ALS transaction, then self.
      */
     getTransactionBoundSqlDataSource(): SqlDataSource | null;
+    /**
+     * @description True while this instance has a transaction in flight: the ALS or
+     * global transaction bound to it, or a manual transaction still holding a
+     * connection on one of its clones.
+     */
+    private hasOpenTransaction;
     /**
      * @description Uses the cache adapter to get a value from the cache
+     * @description A miss inside a transaction is not written back: the value was
+     * computed from that transaction's view of the data, which may include rows it
+     * has not committed, so it does not belong in a cache shared with everyone else.
+     * Reads still hit the cache, so a value cached before the transaction is served.
      * @param key The key to get the value from
      * @param args The arguments to pass to the key handler
      */
@@ -3834,9 +4139,10 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
      * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
      * @param options.isolationLevel The isolation level to use for the transaction
      * @sqlite ignores the isolation level
-     * @warning SQLite `:memory:` databases use `file::memory:?cache=shared`
-     * to allow transaction connections to share the same in-memory database.
-     * Without shared cache each connection would see an empty fresh database.
+     * @warning A SQLite `:memory:` database is private to its connection, and a
+     * transaction runs on its own, so it sees an empty database rather than the
+     * tables created on the main connection. Pass `file::memory:?cache=shared`, or
+     * use a file database, when transactions need to read that data.
      */
     transaction(options?: StartTransactionOptions): Promise<Transaction>;
     transaction<T>(cb: (trx: Transaction) => Promise<T>, options?: StartTransactionOptions): Promise<T>;
@@ -4111,32 +4417,6 @@ declare class SelectNode extends QueryNode {
     constructor(column: string | QueryNode | QueryNode[], alias?: string, sqlFunction?: string, isRaw?: boolean, distinct?: boolean);
 }
 
-declare class JoinNode extends QueryNode {
-    table: string;
-    left: string;
-    right: string;
-    on?: {
-        left?: string;
-        right?: string;
-        operator: string;
-    };
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    type: "inner" | "left" | "right" | "full" | "cross" | "natural";
-    additionalConditions?: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
-    /** When set, renders `using (cols)` instead of an `on` condition. */
-    using?: string[];
-    /** Schema applied to the joined table reference. */
-    schema?: string;
-    constructor(table: string, left: string, right: string, type: "inner" | "left" | "right" | "full" | "cross" | "natural" | undefined, on: {
-        left?: string;
-        right?: string;
-        operator: string;
-    }, isRawValue?: boolean, additionalConditions?: (WhereNode | WhereGroupNode | WhereSubqueryNode)[]);
-}
-
 declare class GroupByNode extends QueryNode {
     column: string;
     chainsWith: string;
@@ -4148,6 +4428,8 @@ declare class GroupByNode extends QueryNode {
 
 declare class LimitNode extends QueryNode {
     limit: number;
+    /** Inlines the value instead of binding it, so later parameter indexes do not shift. */
+    skipBinding?: boolean;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
@@ -4157,6 +4439,8 @@ declare class LimitNode extends QueryNode {
 
 declare class OffsetNode extends QueryNode {
     offset: number;
+    /** Inlines the value instead of binding it, so later parameter indexes do not shift. */
+    skipBinding?: boolean;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
@@ -4167,6 +4451,8 @@ declare class OffsetNode extends QueryNode {
 declare class OrderByNode extends QueryNode {
     column: string;
     direction: "asc" | "desc";
+    /** Explicit null placement, emulated by the dialects that cannot spell it out. */
+    nulls?: "first" | "last";
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
@@ -4520,27 +4806,34 @@ declare abstract class FooterQueryBuilder<T extends Model, S extends Record<stri
     /**
      * @description Adds an order by query
      */
-    orderBy(column: ModelKey<T>, order: OrderByChoices): this;
-    orderBy<S extends string>(column: SelectableColumn$1<S>, order: OrderByChoices): this;
+    orderBy(column: ModelKey<T>, order: OrderByClause): this;
+    orderBy<S extends string>(column: SelectableColumn$1<S>, order: OrderByClause): this;
     /**
      * @description Adds a raw order by query, ORDER BY clause is not necessary and will be added automatically
      */
     orderByRaw(query: string): this;
     /**
      * @description Adds a limit query
+     * @param options.skipBinding - Inlines the value in the SQL instead of binding it
      */
-    limit(limit: number): this;
+    limit(limit: number, options?: {
+        skipBinding?: boolean;
+    }): this;
     /**
      * @description Adds an offset query
+     * @param options.skipBinding - Inlines the value in the SQL instead of binding it
      */
-    offset(offset: number): this;
+    offset(offset: number, options?: {
+        skipBinding?: boolean;
+    }): this;
 }
 
 declare class JoinOnQueryBuilder {
+    protected model: typeof Model;
     protected sqlDataSource: SqlDataSource;
     protected whereNodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
     protected isNestedCondition: boolean;
-    constructor(sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
     /**
      * @description Get the where conditions for the join
      */
@@ -4578,6 +4871,34 @@ declare class JoinOnQueryBuilder {
      */
     orWhereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType$2, value: BaseValues$2): this;
     orWhereNot(column: SelectableColumn$1<string>, value: BaseValues$2): this;
+    /**
+     * @description Adds a condition comparing two columns (`on a.x = b.y`).
+     * @description Both sides need the table prefix when either belongs to an aliased or derived
+     * join target, since there is no model to resolve them against.
+     */
+    whereColumn(column: SelectableColumn$1<string>, operatorOrRef: BinaryOperatorType$2 | SelectableColumn$1<string>, referenceColumn?: SelectableColumn$1<string>): this;
+    /**
+     * @description Adds an AND condition comparing two columns.
+     */
+    andWhereColumn(column: SelectableColumn$1<string>, operatorOrRef: BinaryOperatorType$2 | SelectableColumn$1<string>, referenceColumn?: SelectableColumn$1<string>): this;
+    /**
+     * @description Adds an OR condition comparing two columns.
+     */
+    orWhereColumn(column: SelectableColumn$1<string>, operatorOrRef: BinaryOperatorType$2 | SelectableColumn$1<string>, referenceColumn?: SelectableColumn$1<string>): this;
+    /**
+     * @description Adds a negated condition comparing two columns (`a != b`, or `not (a op b)`
+     * when an explicit operator is given).
+     */
+    whereNotColumn(column: SelectableColumn$1<string>, operatorOrRef: BinaryOperatorType$2 | SelectableColumn$1<string>, referenceColumn?: SelectableColumn$1<string>): this;
+    /**
+     * @description Adds a negated AND condition comparing two columns.
+     */
+    andWhereNotColumn(column: SelectableColumn$1<string>, operatorOrRef: BinaryOperatorType$2 | SelectableColumn$1<string>, referenceColumn?: SelectableColumn$1<string>): this;
+    /**
+     * @description Adds a negated OR condition comparing two columns.
+     */
+    orWhereNotColumn(column: SelectableColumn$1<string>, operatorOrRef: BinaryOperatorType$2 | SelectableColumn$1<string>, referenceColumn?: SelectableColumn$1<string>): this;
+    private pushColumnWhere;
     /**
      * @description Adds a WHERE BETWEEN condition to the query.
      */
@@ -4746,12 +5067,160 @@ declare class JoinOnQueryBuilder {
      * @description Adds an OR raw WHERE condition to the query.
      */
     orWhereRaw(sql: string, bindings?: BaseValues$2[]): this;
+    /**
+     * @description Adds an EXISTS condition to the join ON clause. The nested query defaults to the
+     * joined model's table; use `from` inside the callback to point it elsewhere.
+     */
+    whereExists(cbOrQueryBuilder: (qb: QueryBuilder) => void | QueryBuilder): this;
+    /**
+     * @description Adds an AND EXISTS condition to the join ON clause.
+     */
+    andWhereExists(cbOrQueryBuilder: (qb: QueryBuilder) => void | QueryBuilder): this;
+    /**
+     * @description Adds an OR EXISTS condition to the join ON clause.
+     */
+    orWhereExists(cbOrQueryBuilder: (qb: QueryBuilder) => void | QueryBuilder): this;
+    /**
+     * @description Adds a NOT EXISTS condition to the join ON clause.
+     */
+    whereNotExists(cbOrQueryBuilder: (qb: QueryBuilder) => void | QueryBuilder): this;
+    /**
+     * @description Adds an AND NOT EXISTS condition to the join ON clause.
+     */
+    andWhereNotExists(cbOrQueryBuilder: (qb: QueryBuilder) => void | QueryBuilder): this;
+    /**
+     * @description Adds an OR NOT EXISTS condition to the join ON clause.
+     */
+    orWhereNotExists(cbOrQueryBuilder: (qb: QueryBuilder) => void | QueryBuilder): this;
+    private pushExists;
+    /**
+     * @description JSON predicate: the column's document contains the value (superset). Covers the
+     * `whereJsonContains` and `whereJsonSupersetOf` spellings of the where builder.
+     * @mssql Only exact matches work.
+     */
+    whereJson(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document contains the value (AND).
+     */
+    andWhereJson(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document contains the value (OR).
+     */
+    orWhereJson(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document does not contain the value. Covers the
+     * `whereJsonNotContains` and `whereJsonNotSupersetOf` spellings of the where builder.
+     * @mssql Not supported.
+     */
+    whereNotJson(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document does not contain the value (AND).
+     */
+    andWhereNotJson(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document does not contain the value (OR).
+     */
+    orWhereNotJson(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column equals an exact JSON object value.
+     */
+    whereJsonObject(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column equals an exact JSON object value (AND).
+     */
+    andWhereJsonObject(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column equals an exact JSON object value (OR).
+     */
+    orWhereJsonObject(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column does not equal an exact JSON object value.
+     */
+    whereNotJsonObject(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column does not equal an exact JSON object value (AND).
+     */
+    andWhereNotJsonObject(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column does not equal an exact JSON object value (OR).
+     */
+    orWhereNotJsonObject(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: compares the value at a JSON path. This is the ON-clause form of
+     * Knex's `onJsonPathEquals`, and of `whereJsonPath` in the where builder.
+     */
+    whereJsonPath(column: SelectableColumn$1<string>, path: JsonPathInput, operator: BinaryOperatorType$2, value: any): this;
+    /**
+     * @description JSON predicate: compares the value at a JSON path (AND).
+     */
+    andWhereJsonPath(column: SelectableColumn$1<string>, path: JsonPathInput, operator: BinaryOperatorType$2, value: any): this;
+    /**
+     * @description JSON predicate: compares the value at a JSON path (OR).
+     */
+    orWhereJsonPath(column: SelectableColumn$1<string>, path: JsonPathInput, operator: BinaryOperatorType$2, value: any): this;
+    /**
+     * @description JSON predicate: the column's document is a subset of the value.
+     * @postgres/cockroachdb/mysql/mariadb only
+     */
+    whereJsonSubsetOf(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document is a subset of the value (AND).
+     */
+    andWhereJsonSubsetOf(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document is a subset of the value (OR).
+     */
+    orWhereJsonSubsetOf(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document is not a subset of the value.
+     * @postgres/cockroachdb/mysql/mariadb only
+     */
+    whereJsonNotSubsetOf(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document is not a subset of the value (AND).
+     */
+    andWhereJsonNotSubsetOf(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column's document is not a subset of the value (OR).
+     */
+    orWhereJsonNotSubsetOf(column: SelectableColumn$1<string>, value: Record<string, any> | any[]): this;
+    /**
+     * @description JSON predicate: the column has none of the given keys.
+     * @postgres/cockroachdb only
+     */
+    whereJsonHasNone(column: SelectableColumn$1<string>, keys: string[]): this;
+    /**
+     * @description JSON predicate: the column has none of the given keys (AND).
+     */
+    andWhereJsonHasNone(column: SelectableColumn$1<string>, keys: string[]): this;
+    /**
+     * @description JSON predicate: the column has none of the given keys (OR).
+     */
+    orWhereJsonHasNone(column: SelectableColumn$1<string>, keys: string[]): this;
+    /**
+     * @description Adds a raw JSON predicate to the join ON clause.
+     */
+    whereJsonRaw(sql: string, bindings?: BaseValues$2[]): this;
+    /**
+     * @description Adds an AND raw JSON predicate to the join ON clause.
+     */
+    andWhereJsonRaw(sql: string, bindings?: BaseValues$2[]): this;
+    /**
+     * @description Adds an OR raw JSON predicate to the join ON clause.
+     */
+    orWhereJsonRaw(sql: string, bindings?: BaseValues$2[]): this;
+    private pushJson;
 }
 
 /**
  * @description Callback type for join conditions
  */
 type JoinOnCallback = (query: JoinOnQueryBuilder) => void;
+/**
+ * @description Callback building the derived table a join reads from. The joined
+ * alias is required, since every dialect needs one for a derived table.
+ */
+type JoinSubqueryCallback<T extends Model = Model> = (qb: QueryBuilder<T>) => void | SubQueryable;
 declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends FooterQueryBuilder<T, S> {
     protected joinNodes: JoinNode[];
     protected constructor(model: typeof Model, sqlDataSource: SqlDataSource);
@@ -4762,26 +5231,27 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
     /**
      * @description Join a table with the current model, join clause is not necessary and will be added automatically
      */
-    joinRaw(query: string): this;
+    joinRaw(query: string, bindings?: any[]): this;
     /**
      * @description Join a table with the current model, join clause is not necessary and will be added automatically
      */
-    leftJoinRaw(query: string): this;
+    leftJoinRaw(query: string, bindings?: any[]): this;
     /**
      * @description Join a table with the current model, join clause is not necessary and will be added automatically
      */
-    rightJoinRaw(query: string): this;
+    rightJoinRaw(query: string, bindings?: any[]): this;
     /**
      * @description Join a table with the current model, join clause is not necessary and will be added automatically
      */
-    fullJoinRaw(query: string): this;
+    fullJoinRaw(query: string, bindings?: any[]): this;
     /**
      * @description Join a table with the current model, join clause is not necessary and will be added automatically
      */
-    crossJoinRaw(query: string): this;
+    crossJoinRaw(query: string, bindings?: any[]): this;
     /**
      * @description Performs a CROSS JOIN against a table (non-raw).
      */
+    crossJoin(cb: JoinSubqueryCallback<T>, alias: string): this;
     crossJoin(relationTable: string, alias?: string): this;
     crossJoin<R extends AnyModelConstructor>(relationModel: R): this;
     /**
@@ -4793,7 +5263,7 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
     /**
      * @description Join a table with the current model, join clause is not necessary and will be added automatically
      */
-    naturalJoinRaw(query: string): this;
+    naturalJoinRaw(query: string, bindings?: any[]): this;
     /**
      * @alias join
      * @param relationTable - The table to join
@@ -4801,6 +5271,7 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
      * @param primaryColumn - The primary column of the current model, default is caller model primary key if using a Model, if using a Raw Query Builder you must provide the key for the primary table, must be in the format of `table.column`
      * @param operator - The comparison operator to use in the ON clause (default: "=")
      */
+    innerJoin(cb: JoinSubqueryCallback<T>, alias: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     innerJoin(relationTable: string): this;
     innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$2): this;
@@ -4817,6 +5288,7 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
      * @param primaryColumn - The primary column of the current model, default is caller model primary key if using a Model, if using a Raw Query Builder you must provide the key for the primary table, must be in the format of `table.column`
      * @param operator - The comparison operator to use in the ON clause (default: "=")
      */
+    join(cb: JoinSubqueryCallback<T>, alias: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     join(relationTable: string): this;
     join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$2): this;
@@ -4833,6 +5305,7 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
      * @param primaryColumn - The primary column of the current model, default is caller model primary key if using a Model, if using a Raw Query Builder you must provide the key for the primary table, must be in the format of `table.column`
      * @param operator - The comparison operator to use in the ON clause (default: "=")
      */
+    leftJoin(cb: JoinSubqueryCallback<T>, alias: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     leftJoin(relationTable: string): this;
     leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$2): this;
@@ -4849,6 +5322,7 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
      * @param primaryColumn - The primary column of the current model, default is caller model primary key if using A Model, if using a Raw Query Builder you must provide the key for the primary table
      * @param operator - The comparison operator to use in the ON clause (default: "=")
      */
+    rightJoin(cb: JoinSubqueryCallback<T>, alias: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     rightJoin(relationTable: string): this;
     rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$2): this;
@@ -4862,11 +5336,26 @@ declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string
      * @param primaryColumn - The primary column of the current model
      * @param operator - The comparison operator to use in the ON clause (default: "=")
      */
+    fullJoin(cb: JoinSubqueryCallback<T>, alias: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$2): this;
     fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$2): this;
     fullJoin<R extends AnyModelConstructor>(relationTable: string | R, referencingColumnOrPrimaryColumn: ModelKey<InstanceType<R>> | JoinableColumn | ModelKey<T>, primaryColumn?: JoinableColumn | ModelKey<T>, operator?: BinaryOperatorType$2): this;
     fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType$2, callback: JoinOnCallback): this;
     fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
+    /**
+     * @description Adds a join whose source is a derived table built by `cb`. The
+     * join node carries the alias as its table, so an unqualified ON column on either
+     * side still resolves against the derived table and the caller's model.
+     */
+    private derivedJoin;
+    /**
+     * @description Aliases for the three outer joins, spelled the way the SQL standard
+     * writes them. Parameters are widened on purpose: `Parameters<>` on an overloaded
+     * method resolves to its last overload only, which rejects the shorter call shapes.
+     */
+    leftOuterJoin(relationTable: string | AnyModelConstructor | JoinSubqueryCallback<T>, referencingColumn?: string, primaryColumn?: string, operatorOrCallback?: BinaryOperatorType$2 | JoinOnCallback, callback?: JoinOnCallback): this;
+    rightOuterJoin(relationTable: string | AnyModelConstructor | JoinSubqueryCallback<T>, referencingColumn?: string, primaryColumn?: string, operatorOrCallback?: BinaryOperatorType$2 | JoinOnCallback, callback?: JoinOnCallback): this;
+    fullOuterJoin(relationTable: string | AnyModelConstructor | JoinSubqueryCallback<T>, referencingColumn?: string, primaryColumn?: string, operatorOrCallback?: BinaryOperatorType$2 | JoinOnCallback, callback?: JoinOnCallback): this;
 }
 
 declare class SelectQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends JoinQueryBuilder<T, S> {
@@ -5033,6 +5522,14 @@ declare class SelectQueryBuilder<T extends Model, S extends Record<string, any>
     selectJsonRaw<A extends string>(raw: string, alias: A): this;
 }
 
+/**
+ * @description The `{ column: value }` / `{ column: { op, value } }` shorthand, with
+ * `$and` and `$or` keys for grouping. Shared by `find()` and the builder's `where()`.
+ * @description Typed against the model's columns; a raw table builder passes `any`,
+ * which accepts every key and value.
+ */
+type ObjectWhereCondition<T = any> = WhereType<T>;
+
 declare abstract class WhereQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends SelectQueryBuilder<T, S> {
     protected whereNodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
     protected havingNodes: HavingNode[];
@@ -5050,10 +5547,15 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @warning The value is checked for truthiness, so false, 0, "", etc. will be considered falsy. Use strictWhen for null or undefined only cases.
      */
     when(value: any, cb: (query: this) => void): this;
+    /**
+     * @description Applies a reusable query scope, forwarding any extra arguments to it.
+     */
+    modify<A extends any[]>(cb: (query: this, ...args: A) => void, ...args: A): this;
     /**
      * @description Adds a WHERE condition to the query.
      */
     where(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    where(conditions: ObjectWhereCondition<T>): this;
     where(column: string, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     where(column: string, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     where<K extends ModelKey<T>>(column: K, operator: BinaryOperatorType$2, value: WhereColumnValue<T, K>): this;
@@ -5064,6 +5566,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds an AND WHERE condition to the query.
      */
     andWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    andWhere(conditions: ObjectWhereCondition<T>): this;
     andWhere(column: string, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     andWhere(column: string, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     andWhere<K extends ModelKey<T>>(column: K, operator: BinaryOperatorType$2, value: WhereColumnValue<T, K>): this;
@@ -5074,6 +5577,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds an OR WHERE condition to the query.
      */
     orWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    orWhere(conditions: ObjectWhereCondition<T>): this;
     orWhere(column: string, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     orWhere(column: string, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     orWhere<K extends ModelKey<T>>(column: K, operator: BinaryOperatorType$2, value: WhereColumnValue<T, K>): this;
@@ -5126,7 +5630,9 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
     private pushNotColumnWhere;
     /**
      * @description Adds a negated WHERE condition to the query.
+     * @description With a single callback the whole group is negated: `not (a or b)`
      */
+    whereNot(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
     whereNot(column: string, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     whereNot(column: string, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     whereNot<K extends ModelKey<T>>(column: K, operator: BinaryOperatorType$2, value: WhereColumnValue<T, K>): this;
@@ -5245,6 +5751,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds a WHERE IN condition to the query.
      * @warning If the array is empty, it will add an impossible condition.
      */
+    whereIn(columns: string[], values: any[][]): this;
     whereIn(column: string, values: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     whereIn<K extends ModelKey<T>>(column: K, values: T[StripTablePrefix<K & string> & keyof T][]): this;
     whereIn<K extends `${string}.${string}`>(column: K, values: ResolveWhereValue<T, K>[]): this;
@@ -5252,6 +5759,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds an AND WHERE IN condition to the query.
      * @warning If the array is empty, it will add an impossible condition.
      */
+    andWhereIn(columns: string[], values: any[][]): this;
     andWhereIn(column: string, values: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     andWhereIn<K extends ModelKey<T>>(column: K, values: T[StripTablePrefix<K & string> & keyof T][]): this;
     andWhereIn<K extends `${string}.${string}`>(column: K, values: ResolveWhereValue<T, K>[]): this;
@@ -5259,6 +5767,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds an OR WHERE IN condition to the query.
      * @warning If the array is empty, it will add an impossible condition.
      */
+    orWhereIn(columns: string[], values: any[][]): this;
     orWhereIn(column: string, values: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     orWhereIn<K extends ModelKey<T>>(column: K, values: T[StripTablePrefix<K & string> & keyof T][]): this;
     orWhereIn<K extends `${string}.${string}`>(column: K, values: ResolveWhereValue<T, K>[]): this;
@@ -5266,6 +5775,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds a WHERE NOT IN condition to the query.
      * @warning If the array is empty, it will add an obvious condition to make it true.
      */
+    whereNotIn(columns: string[], values: any[][]): this;
     whereNotIn(column: string, values: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     whereNotIn<K extends ModelKey<T>>(column: K, values: T[StripTablePrefix<K & string> & keyof T][]): this;
     whereNotIn<K extends `${string}.${string}`>(column: K, values: ResolveWhereValue<T, K>[]): this;
@@ -5273,6 +5783,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds an OR WHERE NOT IN condition to the query.
      * @warning If the array is empty, it will add an obvious condition to make it true.
      */
+    andWhereNotIn(columns: string[], values: any[][]): this;
     andWhereNotIn(column: string, values: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     andWhereNotIn<K extends ModelKey<T>>(column: K, values: T[StripTablePrefix<K & string> & keyof T][]): this;
     andWhereNotIn<K extends `${string}.${string}`>(column: K, values: ResolveWhereValue<T, K>[]): this;
@@ -5280,6 +5791,7 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
      * @description Adds an OR WHERE NOT IN condition to the query.
      * @warning If the array is empty, it will add an obvious condition to make it true.
      */
+    orWhereNotIn(columns: string[], values: any[][]): this;
     orWhereNotIn(column: string, values: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void | SubQueryable)): this;
     orWhereNotIn<K extends ModelKey<T>>(column: K, values: T[StripTablePrefix<K & string> & keyof T][]): this;
     orWhereNotIn<K extends `${string}.${string}`>(column: K, values: ResolveWhereValue<T, K>[]): this;
@@ -5485,6 +5997,11 @@ declare abstract class WhereQueryBuilder<T extends Model, S extends Record<strin
     private buildSubQuery;
     private andWhereSubQuery;
     private orWhereSubQuery;
+    /**
+     * @description Row-value `in`/`not in`: `(a, b) in ((1, 2), (3, 4))`, which the
+     * dialects that support it evaluate as a tuple comparison.
+     */
+    private pushTupleIn;
     private andWhereGroup;
     private orWhereGroup;
 }
@@ -5640,6 +6157,12 @@ declare class JsonQueryBuilder<T extends Model, S extends Record<string, any> =
 }
 
 type PluckReturnType<T extends Model, K extends RawModelKey<T>> = T[StripTablePrefix<K & string> & keyof T] extends infer U ? U[] : never;
+/**
+ * Key accepted by `value()`. A narrowed selection leaves only its own columns
+ * readable, which is what `select()` already returned as the result shape.
+ * An untyped result falls back to every model column.
+ */
+type ValueKey<T extends Model, S extends Record<string, any>> = string extends keyof S ? RawModelKey<T> : keyof S & string;
 /**
  * Common SQL functions with intellisense support.
  * Provides autocomplete for standard SQL aggregate and scalar functions,
@@ -5757,6 +6280,13 @@ type HasRawStarOrEmpty<Columns extends readonly Selectable[]> = Columns["length"
 type BuildRawSelectType<Columns extends readonly Selectable[]> = HasRawStarOrEmpty<Columns> extends true ? Record<string, any> : UnionToIntersection$1<{
     [K in keyof Columns]: BuildRawSingleSelectType<Columns[K]>;
 }[number]> extends infer Result ? Result extends Record<string, any> ? keyof Result extends never ? Record<string, any> : Result & RawSelectBrand : Record<string, any> : Record<string, any>;
+/**
+ * Options for the set operations (`union`, `unionAll`, `intersect`, `except`).
+ */
+type SetOperationOptions = {
+    /** Parenthesizes that branch, so its own `ORDER BY` or `LIMIT` stays scoped to it. */
+    wrap?: boolean;
+};
 /**
  * Composes a new selection with the existing selection state for raw queries.
  *
@@ -5885,7 +6415,14 @@ interface DriverAdapter<D extends SqlDataSourceType = SqlDataSourceType, M exten
     createPool(): Promise<void> | void;
     closePool(): Promise<void>;
     reserveConnection(): Promise<GetConnectionReturnType<D>> | GetConnectionReturnType<D>;
-    releaseConnection(connection?: GetConnectionReturnType<D>): Promise<void> | void;
+    /**
+     * @description Returns a reserved connection to the pool. When `error` is
+     * given the caller is reporting why the connection is being given up (a failed
+     * COMMIT or ROLLBACK), and the adapter should discard it rather than pool it:
+     * the session state after that failure is unknown, so the next query must not
+     * inherit it. Adapters whose connection cannot be discarded may ignore it.
+     */
+    releaseConnection(connection?: GetConnectionReturnType<D>, error?: unknown): Promise<void> | void;
     beginTransaction(connection: GetConnectionReturnType<D>, options: BeginTransactionOptions<D>): Promise<void>;
     commitTransaction(connection: GetConnectionReturnType<D>, options: EndTransactionOptions<D>): Promise<void>;
     rollbackTransaction(connection: GetConnectionReturnType<D>, options: EndTransactionOptions<D>): Promise<void>;
@@ -6089,6 +6626,15 @@ type SlaveContext = {
     password: string;
     database: string;
 };
+/**
+ * @description Context passed to `onPoolError` describing the pool that reported a failure.
+ */
+type PoolErrorContext = {
+    type: SqlDataSourceType;
+    host: string;
+    port: number;
+    database: string;
+};
 /**
  * @description The input type for the SqlDataSource constructor
  * @description The connectionPolicies object is used to configure the connection policies for the sql data source
@@ -6139,6 +6685,18 @@ type SqlDataSourceInputShape<D extends SqlDataSourceType, T extends Record<strin
      * against strings must switch to a numeric comparison.
      */
     coerceNumericTypes?: boolean;
+    /**
+     * @description Called when a pooled connection fails while it sits idle.
+     * @description The driver has already removed the client from the pool by the
+     * time this fires, so the handler reports the failure; it cannot rescue the
+     * connection. A handler that throws is caught and logged rather than reaching
+     * the process.
+     * @description Only the node `pg` driver (postgres, cockroachdb) surfaces
+     * pool-level errors. The other drivers report connection failures on the
+     * query that hit them, so this is never called there.
+     * @default the error is logged and the pool keeps serving other clients
+     */
+    onPoolError?: (error: Error, context: PoolErrorContext) => void | Promise<void>;
     /**
      * @description The replication configuration for the sql data source, it's used to configure the replication for the sql data source
      */
@@ -6285,6 +6843,7 @@ type UpsertOptions<T extends Model> = {
 };
 type InsertOptions<T extends Model> = {
     returning?: ReturningKey<T>[];
+    withNodes?: WithNode[];
 };
 type ExcludeRelations<T> = {
     [K in keyof T]: K extends "__tableName" ? never : T[K] extends NullableAndUndefinable<Model> | NullableAndUndefinable<Model[]> | ((...args: any[]) => any) ? never : K;
@@ -6423,10 +6982,17 @@ type WhereColumnValue<T extends Model, K extends ModelKey<T>> = T[StripTablePref
 type ResolveWhereValue<T extends Model, K extends string> = K extends ModelKey<T> ? T[StripTablePrefix<K> & keyof T] | null | SqlFuncNode : BaseValues$2;
 type ModelRelation<T extends Model> = OnlyRelations<T>;
 type OrderByChoices = "asc" | "desc";
+/**
+ * @description Either a bare direction, or a direction with an explicit null placement.
+ */
+type OrderByClause = OrderByChoices | {
+    direction: OrderByChoices;
+    nulls?: "first" | "last";
+};
 type OrderByType<T extends Model> = {
-    [K in keyof T as K extends "__tableName" ? never : K]?: OrderByChoices;
+    [K in keyof T as K extends "__tableName" ? never : K]?: OrderByClause;
 } & {
-    [K in string]?: OrderByChoices;
+    [K in string]?: OrderByClause;
 };
 type FindOneType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = {
     select?: S;
@@ -6865,7 +7431,7 @@ type UpdateOptions = {};
 /**
  * @description Due to query limitations some query builder methods may not be available in a RelationQueryBuilder
  */
-type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "paginate" | "pluck" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
+type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "paginate" | "pluck" | "value" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "batchInsert" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
 
 declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> = ModelWithoutRelations<T>, R extends Record<string, any> = {}, D extends SqlDataSourceType = SqlDataSourceType> extends QueryBuilder<T, Record<string, any>, D> {
     relation: Relation;
@@ -6909,17 +7475,37 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     /**
      * @description Inserts a new record into the database.
      */
-    insert<const Ret extends readonly (RawModelKey<T> | "*")[] = never[]>(modelData: Partial<ModelWithoutRelations<T>>, options?: {
+    insert<const Ret extends readonly (RawModelKey<T> | "*")[] = never[]>(modelData: ModelWriteData<T>, options?: {
         returning?: Ret;
         trx?: Transaction;
-    }): WriteOperation<ReturningResult<T, Ret>>;
+    }): InsertWriteOperation<ReturningResult<T, Ret>, Extract<ModelKey<T>, string>>;
     /**
      * @description Inserts multiple records into the database.
      */
-    insertMany<const Ret extends readonly (RawModelKey<T> | "*")[] = never[]>(modelsData: Partial<ModelWithoutRelations<T>>[], options?: {
+    insertMany<const Ret extends readonly (RawModelKey<T> | "*")[] = never[]>(modelsData: ModelWriteData<T>[], options?: {
         returning?: Ret;
         trx?: Transaction;
-    }): WriteOperation<ReturningResultMany<T, Ret>>;
+    }): InsertWriteOperation<ReturningResultMany<T, Ret>, Extract<ModelKey<T>, string>>;
+    /**
+     * @description Inserts rows in chunks of `chunkSize`, one statement per chunk.
+     * @description The chunks are not wrapped in a transaction; wrap the call in
+     * `sql.transaction(...)` when the whole batch has to be atomic.
+     * @returns The returned columns, or the number of inserted rows without `returning`
+     */
+    batchInsert<const Ret extends readonly (RawModelKey<T> | "*")[] = never[]>(modelsData: ModelWriteData<T>[], options?: {
+        chunkSize?: number;
+        returning?: Ret;
+        trx?: Transaction;
+    }): Promise<[Ret] extends [never[]] ? number : ReturningResultMany<T, Ret>>;
+    /**
+     * @description Inserts the rows produced by a SELECT (or a CTE feeding one) into the table.
+     * @param targetColumns - Optional destination model columns; positional when omitted
+     * @param source - A model builder (or callback) whose SELECT becomes the insert source
+     * @returns InsertWriteOperation, so `onConflict(...).merge()/.ignore()` chains onto it
+     * @warning Rows come from the database, so no validation, hooks or autoCreate columns run
+     */
+    insertFrom(source: ModelQueryBuilder<any> | ((qb: ModelQueryBuilder<any>) => ModelQueryBuilder<any> | void)): InsertWriteOperation<T[]>;
+    insertFrom<C extends ModelKey<T>>(targetColumns: C[], source: ModelQueryBuilder<any> | ((qb: ModelQueryBuilder<any>) => ModelQueryBuilder<any> | void)): InsertWriteOperation<T[]>;
     /**
      * @description Upserts a record (insert or update on conflict).
      */
@@ -7017,8 +7603,9 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     }): Promise<void>;
     /**
      * @description Truncates the table by deleting all records.
+     * @param options - `RESTART IDENTITY` / `CONTINUE IDENTITY` / `CASCADE` (PostgreSQL and CockroachDB only)
      */
-    truncate(): WriteOperation<void>;
+    truncate(options?: TruncateOptions): WriteOperation<void>;
     /**
      * @description Updates records matching the current query conditions.
      * @param data - The columns and values to update.
@@ -7026,7 +7613,10 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
      * @param options.returning - Columns to return from updated rows. Only supported on PostgreSQL, CockroachDB, SQLite, and MSSQL. Not available on MySQL or MariaDB.
      * @returns WriteOperation resolving to the number of affected rows, or the returned columns if `returning` is specified (supported databases only).
      */
-    update<const Ret extends ReturningParam<T, D> = never[]>(data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions & {
+    update<const Ret extends ReturningParam<T, D> = never[]>(column: ModelKey<T> & string, value: WriteQueryParam, options?: UpdateOptions & {
+        returning?: Ret;
+    }): WriteOperation<MutationReturningResult<T, Ret>>;
+    update<const Ret extends ReturningParam<T, D> = never[]>(data: ModelWriteData<T>, options?: UpdateOptions & {
         returning?: Ret;
     }): WriteOperation<MutationReturningResult<T, Ret>>;
     softDelete(options?: SoftDeleteOptions<T>): WriteOperation<number>;
@@ -8439,7 +9029,7 @@ declare class InMemoryAdapter implements CacheAdapter {
 }
 
 declare class RedisCacheAdapter implements CacheAdapter {
-    redisInstance: Redis;
+    redisInstance: Redis | undefined;
     private ioRedisOptions;
     constructor(ioRedisOptions: RedisOptions);
     private getClient;
@@ -9036,6 +9626,7 @@ declare class Schema {
     dropIndex(indexName: string, table?: string): void;
     /**
      * @description Adds a primary key to a table
+     * @throws HysteriaError if sqlite database, which cannot add a primary key to an existing table
      */
     addPrimaryKey(table: string, columns: string[]): void;
     /**
@@ -9162,7 +9753,7 @@ declare abstract class BaseSeeder {
     abstract run(): Promise<void>;
 }
 
-type HysteriaErrorCode = "VALIDATION_ERROR" | "CONNECTION_ALREADY_ESTABLISHED" | `UNSUPPORTED_ISOLATION_LEVEL_${string}` | "ROW_NOT_FOUND" | `UNSUPPORTED_DATABASE_TYPE_${string}` | `RELATION_TYPE_NOT_SUPPORTED_${string}` | `NOT_SUPPORTED_IN_${string}` | `RELATION_NOT_FOUND_IN_MODEL_${string}` | `UNKNOWN_RELATION_TYPE_${string}` | `DISTINCT_ON_NOT_SUPPORTED_IN_${string}` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_HAS_ONE_RELATION_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_BELONGS_TO_RELATION_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_HAS_MANY_RELATION_${string}` | `MANY_TO_MANY_RELATION_NOT_FOUND_FOR_RELATED_MODEL_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_MANY_TO_MANY_RELATION_${string}` | `RELATED_MODEL_DOES_NOT_HAVE_A_PRIMARY_KEY_${string}` | `FOR_SHARE_NOT_SUPPORTED_IN_${string}` | `SKIP_LOCKED_NOT_SUPPORTED_IN_${string}` | `LOCK_STRENGTH_NOT_SUPPORTED_IN_${string}` | "QUERY_TIMEOUT" | `LOCK_FOR_UPDATE_NOT_SUPPORTED_${string}` | `KEY_${string}_HAS_NO_HANDLER_IN_CACHE_KEYS_CONFIG` | `CACHE_ADAPTER_NOT_CONFIGURED` | `SQLITE_NOT_SUPPORTED` | `COCKROACHDB_NOT_SUPPORTED` | `RELATION_NOT_FOUND` | `POSTGRES_TABLE_REQUIRED` | `MODEL_HAS_NO_PRIMARY_KEY_VALUE` | `RELATION_NOT_MANY_TO_MANY` | "MATERIALIZED_CTE_NOT_SUPPORTED" | "NOT_MATERIALIZED_CTE_NOT_SUPPORTED" | "USING_REQUIRES_JOIN" | "USING_NOT_SUPPORTED_IN_MSSQL" | "DUPLICATE_MODEL_KEYS_WHILE_INSTANTIATING_MODELS" | "INVALID_ONE_PARAMETER_WHERE_CONDITION" | "INVALID_PAGINATION_PARAMETERS" | "MISSING_ALIAS_FOR_SUBQUERY" | "MODEL_HAS_NO_PRIMARY_KEY" | "PRIMARY_KEY_NOT_FOUND" | "ORDER_BY_REQUIRED" | "ORDER_BY_RAW_NOT_SUPPORTED" | "INVALID_SQL_COMMENT" | "SQLITE_ONLY_SUPPORTS_SERIALIZABLE_ISOLATION_LEVEL" | "MUST_CALL_BUILD_CTE_AT_LEAST_ONCE" | "REGEXP_NOT_SUPPORTED_IN_SQLITE" | "MANY_TO_MANY_RELATION_MUST_HAVE_A_THROUGH_MODEL" | "INSERT_FAILED" | "MULTIPLE_PRIMARY_KEYS_NOT_ALLOWED" | "FILE_NOT_A_SQL_OR_TXT_FILE" | "CONNECTION_NOT_ESTABLISHED" | "TRANSACTION_NOT_ACTIVE" | "DEVELOPMENT_ERROR" | "MIGRATION_MODULE_NOT_FOUND" | "DRIVER_NOT_FOUND" | "FILE_NOT_FOUND_OR_NOT_ACCESSIBLE" | "ENV_NOT_SET" | "REQUIRED_VALUE_NOT_SET" | "SET_FAILED" | "GET_FAILED" | "REFERENCES_OPTION_REQUIRED" | "DELETE_FAILED" | "INVALID_DEFAULT_VALUE" | "DISCONNECT_FAILED" | "FLUSH_FAILED" | "LEFT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "RIGHT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "MODEL_HAS_NO_PRIMARY_KEY" | "GLOBAL_TRANSACTION_ALREADY_STARTED" | "GLOBAL_TRANSACTION_NOT_STARTED" | "MYSQL_REQUIRES_TABLE_NAME_FOR_INDEX_DROP" | "INVALID_DATE_OBJECT" | "INVALID_DATE_STRING" | "FAILED_TO_PARSE_DATE" | "MIGRATION_MODULE_REQUIRES_TS_NODE" | "FAILED_TO_ENCRYPT_SYMMETRICALLY" | "FAILED_TO_DECRYPT_SYMMETRICALLY" | "FAILED_TO_ENCRYPT_ASYMMETRICALLY" | "FAILED_TO_DECRYPT_ASYMMETRICALLY" | "UNSUPPORTED_RELATION_TYPE" | "LPUSH_FAILED" | "RPUSH_FAILED" | "LPOP_FAILED" | "RPOP_FAILED" | "LRANGE_FAILED" | "LLEN_FAILED" | "HSET_FAILED" | "HMSET_FAILED" | "HGET_FAILED" | "HGETALL_FAILED" | "HMGET_FAILED" | "HDEL_FAILED" | "HEXISTS_FAILED" | "HKEYS_FAILED" | "HLEN_FAILED" | "SADD_FAILED" | "SMEMBERS_FAILED" | "SREM_FAILED" | "SISMEMBER_FAILED" | "SCARD_FAILED" | "SINTER_FAILED" | "SUNION_FAILED" | "SDIFF_FAILED" | "ZADD_FAILED" | "ZRANGE_FAILED" | "ZREVRANGE_FAILED" | "ZREM_FAILED" | "ZSCORE_FAILED" | "ZCARD_FAILED" | "SUBSCRIBE_FAILED" | "UNSUBSCRIBE_FAILED" | "PUBLISH_FAILED" | "PSUBSCRIBE_FAILED" | "PUNSUBSCRIBE_FAILED" | "EXISTS_FAILED" | "EXPIRE_FAILED" | "EXPIREAT_FAILED" | "PEXPIRE_FAILED" | "TTL_FAILED" | "PTTL_FAILED" | "PERSIST_FAILED" | "KEYS_FAILED" | "RENAME_FAILED" | "TYPE_FAILED" | "SCAN_FAILED" | "ADMINJS_NOT_ENABLED" | "ADMINJS_INITIALIZATION_FAILED" | "ADMINJS_NO_MODELS_PROVIDED" | `BETTER_AUTH_MISSING_ID_${string}` | `BETTER_AUTH_INVALID_INCREMENT_${string}` | "ZOD_ENGINE_NOT_LOADED" | "ATOMIC_DATASOURCE_RESOLUTION_FAILED" | "ATOMIC_INVALID_METHOD" | "ATOMIC_CLS_DISABLED" | `SCOPE_NOT_FOUND_${string}`;
+type HysteriaErrorCode = "VALIDATION_ERROR" | "CONNECTION_ALREADY_ESTABLISHED" | `UNSUPPORTED_ISOLATION_LEVEL_${string}` | "ROW_NOT_FOUND" | `UNSUPPORTED_DATABASE_TYPE_${string}` | `RELATION_TYPE_NOT_SUPPORTED_${string}` | `NOT_SUPPORTED_IN_${string}` | `RELATION_NOT_FOUND_IN_MODEL_${string}` | `UNKNOWN_RELATION_TYPE_${string}` | `DISTINCT_ON_NOT_SUPPORTED_IN_${string}` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_HAS_ONE_RELATION_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_BELONGS_TO_RELATION_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_HAS_MANY_RELATION_${string}` | `MANY_TO_MANY_RELATION_NOT_FOUND_FOR_RELATED_MODEL_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_MANY_TO_MANY_RELATION_${string}` | `RELATED_MODEL_DOES_NOT_HAVE_A_PRIMARY_KEY_${string}` | `FOR_SHARE_NOT_SUPPORTED_IN_${string}` | `SKIP_LOCKED_NOT_SUPPORTED_IN_${string}` | `LOCK_STRENGTH_NOT_SUPPORTED_IN_${string}` | "QUERY_TIMEOUT" | `LOCK_FOR_UPDATE_NOT_SUPPORTED_${string}` | `KEY_${string}_HAS_NO_HANDLER_IN_CACHE_KEYS_CONFIG` | `CACHE_ADAPTER_NOT_CONFIGURED` | `SQLITE_NOT_SUPPORTED` | `COCKROACHDB_NOT_SUPPORTED` | `RELATION_NOT_FOUND` | `POSTGRES_TABLE_REQUIRED` | `MODEL_HAS_NO_PRIMARY_KEY_VALUE` | `RELATION_NOT_MANY_TO_MANY` | "MATERIALIZED_CTE_NOT_SUPPORTED" | "NOT_MATERIALIZED_CTE_NOT_SUPPORTED" | "ONLY_NOT_SUPPORTED" | "USING_REQUIRES_JOIN" | "USING_CONFLICTS_WITH_ON_CONDITIONS" | "USING_NOT_SUPPORTED_IN_MSSQL" | "DUPLICATE_MODEL_KEYS_WHILE_INSTANTIATING_MODELS" | "INVALID_ONE_PARAMETER_WHERE_CONDITION" | "INVALID_PAGINATION_PARAMETERS" | "MISSING_ALIAS_FOR_SUBQUERY" | "MODEL_HAS_NO_PRIMARY_KEY" | "PRIMARY_KEY_NOT_FOUND" | "ORDER_BY_REQUIRED" | "ORDER_BY_RAW_NOT_SUPPORTED" | "INVALID_SQL_COMMENT" | "SQLITE_ONLY_SUPPORTS_SERIALIZABLE_ISOLATION_LEVEL" | "MUST_CALL_BUILD_CTE_AT_LEAST_ONCE" | "REGEXP_NOT_SUPPORTED_IN_SQLITE" | "MANY_TO_MANY_RELATION_MUST_HAVE_A_THROUGH_MODEL" | "INSERT_FAILED" | "MULTIPLE_PRIMARY_KEYS_NOT_ALLOWED" | "FILE_NOT_A_SQL_OR_TXT_FILE" | "CONNECTION_NOT_ESTABLISHED" | "TRANSACTION_NOT_ACTIVE" | "DEVELOPMENT_ERROR" | "MIGRATION_MODULE_NOT_FOUND" | "DRIVER_NOT_FOUND" | "FILE_NOT_FOUND_OR_NOT_ACCESSIBLE" | "ENV_NOT_SET" | "REQUIRED_VALUE_NOT_SET" | "SET_FAILED" | "GET_FAILED" | "REFERENCES_OPTION_REQUIRED" | "DELETE_FAILED" | "INVALID_DEFAULT_VALUE" | "DISCONNECT_FAILED" | "FLUSH_FAILED" | "LEFT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "RIGHT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "MODEL_HAS_NO_PRIMARY_KEY" | "GLOBAL_TRANSACTION_ALREADY_STARTED" | "GLOBAL_TRANSACTION_NOT_STARTED" | "MYSQL_REQUIRES_TABLE_NAME_FOR_INDEX_DROP" | "INVALID_DATE_OBJECT" | "INVALID_DATE_STRING" | "FAILED_TO_PARSE_DATE" | "MIGRATION_MODULE_REQUIRES_TS_NODE" | "FAILED_TO_ENCRYPT_SYMMETRICALLY" | "FAILED_TO_DECRYPT_SYMMETRICALLY" | "FAILED_TO_ENCRYPT_ASYMMETRICALLY" | "FAILED_TO_DECRYPT_ASYMMETRICALLY" | "UNSUPPORTED_RELATION_TYPE" | "LPUSH_FAILED" | "RPUSH_FAILED" | "LPOP_FAILED" | "RPOP_FAILED" | "LRANGE_FAILED" | "LLEN_FAILED" | "HSET_FAILED" | "HMSET_FAILED" | "HGET_FAILED" | "HGETALL_FAILED" | "HMGET_FAILED" | "HDEL_FAILED" | "HEXISTS_FAILED" | "HKEYS_FAILED" | "HLEN_FAILED" | "SADD_FAILED" | "SMEMBERS_FAILED" | "SREM_FAILED" | "SISMEMBER_FAILED" | "SCARD_FAILED" | "SINTER_FAILED" | "SUNION_FAILED" | "SDIFF_FAILED" | "ZADD_FAILED" | "ZRANGE_FAILED" | "ZREVRANGE_FAILED" | "ZREM_FAILED" | "ZSCORE_FAILED" | "ZCARD_FAILED" | "SUBSCRIBE_FAILED" | "UNSUBSCRIBE_FAILED" | "PUBLISH_FAILED" | "PSUBSCRIBE_FAILED" | "PUNSUBSCRIBE_FAILED" | "EXISTS_FAILED" | "EXPIRE_FAILED" | "EXPIREAT_FAILED" | "PEXPIRE_FAILED" | "TTL_FAILED" | "PTTL_FAILED" | "PERSIST_FAILED" | "KEYS_FAILED" | "RENAME_FAILED" | "TYPE_FAILED" | "SCAN_FAILED" | "ADMINJS_NOT_ENABLED" | "ADMINJS_INITIALIZATION_FAILED" | "ADMINJS_NO_MODELS_PROVIDED" | `BETTER_AUTH_MISSING_ID_${string}` | `BETTER_AUTH_INVALID_INCREMENT_${string}` | "ZOD_ENGINE_NOT_LOADED" | "ATOMIC_DATASOURCE_RESOLUTION_FAILED" | "ATOMIC_INVALID_METHOD" | "ATOMIC_CLS_DISABLED" | `SCOPE_NOT_FOUND_${string}` | "ON_CONFLICT_REQUIRES_MERGE_OR_IGNORE" | "MERGE_REQUIRES_ON_CONFLICT" | "MERGE_REQUIRES_COLUMNS" | "ON_CONFLICT_COLUMNS_REQUIRED" | "JOIN_NOT_SUPPORTED_ON_WRITE" | "ORDER_BY_LIMIT_NOT_SUPPORTED_ON_WRITE" | "SELECT_ONLY_CLAUSE_ON_WRITE" | "CTE_NOT_SUPPORTED_ON_INSERT" | "CTE_NOT_SUPPORTED_ON_TRUNCATE" | "CTE_NOT_SUPPORTED_ON_WRITE" | "TRUNCATE_OPTION_NOT_SUPPORTED" | "UPDATE_REQUIRES_COLUMNS" | "UPDATE_FROM_NOT_SUPPORTED" | "DELETE_USING_NOT_SUPPORTED" | "MERGE_WHERE_NOT_SUPPORTED" | "INVALID_BATCH_SIZE" | "ORDER_BY_NULLS_WITH_CURSOR_NOT_SUPPORTED" | "WHERE_TUPLE_COLUMNS_REQUIRED";
 
 declare class HysteriaError extends Error {
     code: HysteriaErrorCode;
@@ -9325,4 +9916,4 @@ type BetterAuthAdapterConfig = Partial<Pick<AdapterFactoryConfig, "usePlural" |
  */
 declare function betterAuthAdapter(sql: SqlDataSource, config?: BetterAuthAdapterConfig): (options: BetterAuthOptions) => DBAdapter;
 
-export { type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AllowedDrivers, type AnyModelConstructor, type AnySqlDataSourceInput, type AtomicOptions, type BaseModelMethodOptions, BaseSeeder, type BeginTransactionOptions, type BetterAuthAdapterConfig, type BuildSelectType, type BuildSingleSelectType, type BuiltinDriverName, type CacheAdapter, type CacheKeys, ClientMigrator, type ColCharOptions, type ColComputedOptions, type ColJsonbOptions, type ColMediumIntOptions, type ColSmallIntOptions, type ColTinyIntOptions, type ColVarbinaryOptions, Collection, type CollectionDefinition, type ColumnDef, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ComputedColumnDef, type ConnectionPolicies, type CreateSchemaResult, type CustomLogger, type DataSourceInput, type DataSourceType, type DateAutoHook, type DefinedCollection, type DefinedModel, type DefinedView, type DriverAdapter, type DriverAdapterFactory, type DriverAdapterFactoryContext, type EndTransactionOptions, type ExcludeMethods, type ExecuteOptions, type ExtractColumnName, type ExtractSourceColumn, type FindReturnType, type GetColumnType, type GetConnectionReturnType, HysteriaError, type HysteriaErrorCode, InMemoryAdapter, type InferPK, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedSchema, type IntrospectedTable, type JsEnvironmentValue, type JsonPathInput, type JsonPaths, type LoadOptions, type LoggerConfig, Migration, type MigrationConfig, type MigrationConfigBase, type MigrationLockConfig, type ModelColumns, type ModelDataProperties, type ModelInstanceType, type ModelKey, ModelQueryBuilder, type ModelQueryResult, type ModelRelation, type ModelSelectTuple, type ModelSelectableInput, type ModelStream, type ModelWithoutRelations, type ModelsProxy, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlComment, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MutationReturningResult, type MySqlComment, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NullableColumn, type NumberModelKey, ObserverChain, ObserverChainWrapper, type Operation, type PgComment, type PgPoolClientInstance, type PingResult, type PlatformAdapter, type PlatformFs, type PlatformPath, PlatformUnsupportedError, type PostgresSqlDataSourceInput, type PrimaryColumnDef, type PropNamespace, type PropertyDef, QueryBuilder, type QueryContext, type QueryContextWithDuration, type QueryObserver, type RawModelKey, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationDef, type RelationDefinitions, type RelationHelpers, type RelationLoadStrategy, type RelationQueryBuilderType, type ReplicationType, type ResolveColumnType, type ResolveJsonPathType, type ResolvedJsEnvironment, type ReturningColumns, type ReturningKey, type ReturningParam, type ReturningResult, type ReturningResultMany, type ReturningSupported, Schema, SchemaBuilder, type SchemaLookup, type SchemaRelDef, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, type SqlComment, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, SqlFuncNode, type SqlFuncRenderer, type SqlHint, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteComment, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type StripTablePrefix, type SubQueryable, type TableFormat, Transaction, type TransactionExecutionOptions, type TypedDefault, type TypedJsonPathInput, type TypedPrepare, type TypedSerialize, type UseCacheReturnType, type UseConnectionInput, type ValidationContext, ValidationError, type ValidationResult, type Validator, type ViewDefinition, WriteOperation, type WriteReturnType, atomic, betterAuthAdapter, col, createSchema, defineCollection, defineMigrator, defineModel, defineModelFactory, defineRelations, defineView, deriveOperationFromQuery, email, enumValidator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, type getPoolReturnType, loadPlatform, HysteriaLogger as logger, max, maxLength, min, minLength, pattern, prop, RedisDataSource as redis, registerDriverAdapter, registerSqlFuncRenderer, required, sqlFunc, url };
+export { type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AllowedDrivers, type AnyModelConstructor, type AnySqlDataSourceInput, type AtomicOptions, type BaseModelMethodOptions, BaseSeeder, type BeginTransactionOptions, type BetterAuthAdapterConfig, type BuildSelectType, type BuildSingleSelectType, type BuiltinDriverName, type CacheAdapter, type CacheKeys, ClientMigrator, type ColCharOptions, type ColComputedOptions, type ColJsonbOptions, type ColMediumIntOptions, type ColSmallIntOptions, type ColTinyIntOptions, type ColVarbinaryOptions, Collection, type CollectionDefinition, type ColumnDef, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ComputedColumnDef, type ConnectionPolicies, type CreateSchemaResult, type CustomLogger, type DataSourceInput, type DataSourceType, type DateAutoHook, type DefinedCollection, type DefinedModel, type DefinedView, type DriverAdapter, type DriverAdapterFactory, type DriverAdapterFactoryContext, type EndTransactionOptions, type ExcludeMethods, type ExecuteOptions, type ExtractColumnName, type ExtractSourceColumn, type FindReturnType, type GetColumnType, type GetConnectionReturnType, HysteriaError, type HysteriaErrorCode, InMemoryAdapter, type InferPK, type InsertConflictConfig, type InsertConflictMode, InsertWriteOperation, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedSchema, type IntrospectedTable, type JsEnvironmentValue, type JsonMutationFor, type JsonPathInput, type JsonPaths, type LoadOptions, type LoggerConfig, Migration, type MigrationConfig, type MigrationConfigBase, type MigrationLockConfig, type ModelColumns, type ModelDataProperties, type ModelInstanceType, type ModelKey, ModelQueryBuilder, type ModelQueryResult, type ModelRelation, type ModelSelectTuple, type ModelSelectableInput, type ModelStream, type ModelWithoutRelations, type ModelWriteData, type ModelsProxy, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlComment, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MutationReturningResult, type MySqlComment, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NullableColumn, type NumberModelKey, ObserverChain, ObserverChainWrapper, type Operation, type PgComment, type PgPoolClientInstance, type PingResult, type PlatformAdapter, type PlatformFs, type PlatformPath, PlatformUnsupportedError, type PoolErrorContext, type PostgresSqlDataSourceInput, type PrimaryColumnDef, type PropNamespace, type PropertyDef, QueryBuilder, type QueryContext, type QueryContextWithDuration, type QueryObserver, type RawModelKey, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationDef, type RelationDefinitions, type RelationHelpers, type RelationLoadStrategy, type RelationQueryBuilderType, type ReplicationType, type ResolveColumnType, type ResolveJsonPathType, type ResolvedJsEnvironment, type ReturningColumns, type ReturningKey, type ReturningParam, type ReturningResult, type ReturningResultMany, type ReturningSupported, Schema, SchemaBuilder, type SchemaLookup, type SchemaRelDef, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, type SqlComment, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, SqlFuncNode, type SqlFuncRenderer, type SqlHint, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteComment, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type StripTablePrefix, type SubQueryable, type TableFormat, Transaction, type TransactionExecutionOptions, type TypedDefault, type TypedJsonPathInput, type TypedPrepare, type TypedSerialize, type UseCacheReturnType, type UseConnectionInput, type ValidationContext, ValidationError, type ValidationResult, type Validator, type ViewDefinition, WriteOperation, type WriteReturnType, atomic, betterAuthAdapter, col, createSchema, defineCollection, defineMigrator, defineModel, defineModelFactory, defineRelations, defineView, deriveOperationFromQuery, email, enumValidator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, type getPoolReturnType, loadPlatform, HysteriaLogger as logger, max, maxLength, min, minLength, pattern, prop, RedisDataSource as redis, registerDriverAdapter, registerSqlFuncRenderer, required, sqlFunc, url };