hysteria-orm 10.5.4 → 10.5.5

package/lib/index.d.ts

@@ -2152,71 +2152,38 @@ declare class InterpreterUtils {
     getFromForWriteOperations(dbType: SqlDataSourceType, fromNode: FromNode): string;
 }
 
-type DeleteOptions = {
-    ignoreBeforeDeleteHook?: boolean;
-};
-type SoftDeleteOptions<T> = {
-    column?: MongoCollectionKey<T>;
-    value?: string | number | boolean;
-    ignoreBeforeUpdateHook?: boolean;
-};
-
-type JsonPathInput = string | (string | number)[];
-
-declare class DeleteNode extends QueryNode {
-    fromNode: FromNode;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode, isRawValue?: boolean);
-}
-
-declare class InsertNode extends QueryNode {
-    fromNode: FromNode;
-    records: Record<string, any>[];
-    returning?: string[];
-    disableReturning: boolean;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode, records?: Record<string, any>[], returning?: string[], disableReturning?: boolean, isRawValue?: boolean);
-}
-
-declare class OnDuplicateNode extends QueryNode {
-    table: string;
-    conflictColumns: string[];
-    columnsToUpdate: string[];
-    returning?: string[];
-    mode: "update" | "ignore";
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(table: string, conflictColumns: string[], columnsToUpdate: string[], mode?: "update" | "ignore", returning?: string[], isRawValue?: boolean);
-}
-
-type UnionCallBack<T extends Model> = (queryBuilder: QueryBuilder<T>) => QueryBuilder<T>;
-
-declare class TruncateNode extends QueryNode {
-    fromNode: FromNode | string;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode | string, isRawValue?: boolean);
-}
-
-declare class UpdateNode extends QueryNode {
-    fromNode: FromNode;
-    columns: string[];
-    values: (any | RawNode)[];
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode, columns?: string[], values?: (any | RawNode)[], isRawValue?: boolean);
+/**
+ * A PromiseLike wrapper for write operations that allows SQL inspection without execution.
+ * The operation is only executed when awaited (via `then()`).
+ *
+ * @example
+ * ```ts
+ * // Get SQL without executing
+ * const sql = sql.query("users").insert({ name: "John" }).toQuery();
+ *
+ * // Execute the operation
+ * const result = await sql.query("users").insert({ name: "John" });
+ * ```
+ */
+declare class WriteOperation<T> implements PromiseLike<T> {
+    private unWrapFn;
+    private toQueryFn;
+    private executor;
+    readonly [Symbol.toStringTag] = "WriteOperation";
+    constructor(unWrapFn: () => ReturnType<typeof AstParser.prototype.parse>, toQueryFn: () => string, executor: () => Promise<T>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    /**
+     * @description Returns the query with the parameters bound to the query
+     * @warning Does not apply any hook from the model
+     */
+    toQuery(): string;
+    /**
+     * @description Returns the query with database driver placeholders and the params
+     * @warning Does not apply any hook from the model
+     */
+    unWrap(): ReturnType<typeof AstParser.prototype.parse>;
 }
 
 type BaseValues$1 = string | number | boolean | null;
@@ -2268,1717 +2235,1732 @@ declare class WhereGroupNode extends QueryNode {
     constructor(nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[], chainsWith?: "and" | "or");
 }
 
-declare class DistinctNode extends QueryNode {
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor();
-}
+type JsonPathInput = string | (string | number)[];
 
-declare class DistinctOnNode extends QueryNode {
-    columns: string[];
+declare class DeleteNode extends QueryNode {
+    fromNode: FromNode;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(columns: string[]);
+    constructor(fromNode: FromNode, isRawValue?: boolean);
 }
 
-declare class SelectNode extends QueryNode {
-    column: string | QueryNode | QueryNode[];
-    alias?: string;
-    sqlFunction?: string;
+declare class InsertNode extends QueryNode {
+    fromNode: FromNode;
+    records: Record<string, any>[];
+    returning?: string[];
+    disableReturning: boolean;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(column: string | QueryNode | QueryNode[], alias?: string, sqlFunction?: string, isRaw?: boolean);
+    constructor(fromNode: FromNode, records?: Record<string, any>[], returning?: string[], disableReturning?: boolean, isRawValue?: boolean);
 }
 
-declare class JoinNode extends QueryNode {
+declare class OnDuplicateNode 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)[];
-    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;
+    conflictColumns: string[];
+    columnsToUpdate: string[];
+    returning?: string[];
+    mode: "update" | "ignore";
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(column: string, isRawValue?: boolean);
+    constructor(table: string, conflictColumns: string[], columnsToUpdate: string[], mode?: "update" | "ignore", returning?: string[], isRawValue?: boolean);
 }
 
-declare class LimitNode extends QueryNode {
-    limit: number;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(limit: number);
-}
+type UnionCallBack<T extends Model> = (queryBuilder: QueryBuilder<T>) => QueryBuilder<T>;
 
-declare class OffsetNode extends QueryNode {
-    offset: number;
+declare class TruncateNode extends QueryNode {
+    fromNode: FromNode | string;
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(offset: number);
+    constructor(fromNode: FromNode | string, isRawValue?: boolean);
 }
 
-declare class OrderByNode extends QueryNode {
-    column: string;
-    direction: "asc" | "desc";
+declare class UpdateNode extends QueryNode {
+    fromNode: FromNode;
+    columns: string[];
+    values: (any | RawNode)[];
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
     folder: string;
     file: string;
-    constructor(column: string, direction?: "asc" | "desc", isRawValue?: boolean);
-}
-
-type DateFormat = "ISO" | "TIMESTAMP" | "DATE_ONLY" | "TIME_ONLY";
-type Timezone = "UTC" | "LOCAL";
-
-/**
- * @description Options for the relation
- * @property {string} softDeleteColumn - The column name for the soft delete column, if set, the relation will only return rows that have not been soft deleted
- * @property {string} softDeleteType - The type of the soft delete column
- */
-declare enum RelationEnum {
-    hasOne = "hasOne",// One to One without foreign key
-    belongsTo = "belongsTo",// One to One with foreign key
-    hasMany = "hasMany",
-    manyToMany = "manyToMany"
-}
-/**
- * Main Relation Class
- */
-declare abstract class Relation {
-    abstract type: RelationEnum;
-    model: typeof Model;
-    columnName: string;
-    foreignKey?: string;
-    relatedModel: string;
-    protected constructor(model: typeof Model, columnName: string);
+    constructor(fromNode: FromNode, columns?: string[], values?: (any | RawNode)[], isRawValue?: boolean);
 }
 
-type ColumnDataType = Exclude<keyof CreateTableBuilder, "enum" | "rawColumn" | "custom"> | readonly string[];
-type ColumnDataTypeOptionWithLength = {
-    type?: "char" | "varchar" | "string" | "uuid" | "ulid" | "varbinary" | "integer" | "tinyint" | "smallint" | "mediumint" | "bigint" | "increment" | "bigIncrement";
-    length?: number;
-};
-type ColumnDataTypeOptionWithEnum = {
-    type?: readonly string[];
-};
-type ColumnDataTypeOptionWithPrecision = {
-    type?: "float" | "double" | "real";
-    precision?: number;
-};
-type ColumnDataTypeOptionWithScaleAndPrecision = {
-    type?: "decimal" | "numeric";
-    precision?: number;
-    scale?: number;
-};
-type ColumnDataTypeOptionWithText = {
-    type?: "text" | "longtext" | "mediumtext" | "tinytext";
-};
-type ColumnDataTypeOptionWithBinary = {
-    type?: "binary" | "blob" | "tinyblob" | "mediumblob" | "longblob";
-};
-type ColumnDataTypeOptionWithDatePrecision = {
-    type?: "date" | "time" | "datetime" | "timestamp";
-    precision?: number;
-    withTimezone?: boolean;
+type DeleteOptions = {
+    ignoreBeforeDeleteHook?: boolean;
 };
-type ColumnDataTypeOptionSimple = {
-    type?: "year" | "boolean" | "json" | "jsonb";
+type SoftDeleteOptions<T> = {
+    column?: MongoCollectionKey<T>;
+    value?: string | number | boolean;
+    ignoreBeforeUpdateHook?: boolean;
 };
-type ColumnDataTypeOption = ColumnDataTypeOptionWithLength | ColumnDataTypeOptionWithPrecision | ColumnDataTypeOptionWithScaleAndPrecision | ColumnDataTypeOptionWithText | ColumnDataTypeOptionWithBinary | ColumnDataTypeOptionWithDatePrecision | ColumnDataTypeOptionWithEnum | ColumnDataTypeOptionSimple;
-type LazyRelationType = {
-    type?: RelationEnum;
-    columnName: string;
-    model: () => typeof Model;
-    foreignKey: string | (() => string);
-    constraintName: string | (() => string);
-    onDelete?: OnUpdateOrDelete;
-    onUpdate?: OnUpdateOrDelete;
+
+declare class QueryBuilder<T extends Model = any, S extends Record<string, any> = Record<string, any>> extends JsonQueryBuilder<T, S> {
+    model: typeof Model;
+    protected astParser: AstParser;
+    protected unionNodes: UnionNode[];
+    protected withNodes: WithNode[];
+    protected lockQueryNodes: LockNode[];
+    protected isNestedCondition: boolean;
+    protected interpreterUtils: InterpreterUtils;
+    protected insertNode: InsertNode | null;
+    protected onDuplicateNode: OnDuplicateNode | null;
+    protected updateNode: UpdateNode | null;
+    protected deleteNode: DeleteNode | null;
+    protected truncateNode: TruncateNode | null;
+    protected replicationMode: ReplicationType | null;
     /**
-     * @description Only for many to many relations
+     * @description Performance methods that return the time that took to execute the query with the result
      */
-    manyToManyOptions?: {
-        primaryModel: string;
-        throughModel: string | (() => string);
-        leftForeignKey: string | (() => string);
-        rightForeignKey: string | (() => string);
-        wasModelProvided: boolean;
-    };
-};
-type DateColumnOptions = {
-    /**
-     * @description The format to store dates in ('ISO' or 'TIMESTAMP')
-     * @default "ISO"
+    performance: {
+        many: (returnType?: "millis" | "seconds") => Promise<{
+            data: S[];
+            time: number;
+        }>;
+        one: (returnType?: "millis" | "seconds") => Promise<{
+            data: S | null;
+            time: number;
+        }>;
+        oneOrFail: (returnType?: "millis" | "seconds") => Promise<{
+            data: S;
+            time: number;
+        }>;
+        paginate: (page: number, perPage: number, returnType?: "millis" | "seconds") => Promise<{
+            data: RawPaginatedData<S>;
+            time: number;
+        }>;
+        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
+            data: [RawCursorPaginatedData<S>, Cursor<T, ModelKey<T>>];
+            time: number;
+        }>;
+        exists: (returnType?: "millis" | "seconds") => Promise<{
+            data: boolean;
+            time: number;
+        }>;
+        truncate: (returnType?: "millis" | "seconds") => Promise<{
+            data: void;
+            time: number;
+        }>;
+        delete: (returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        insert: (data: Record<string, any>, returnType?: "millis" | "seconds") => Promise<{
+            data: T;
+            time: number;
+        }>;
+        insertMany: (data: Record<string, any>[], returnType?: "millis" | "seconds") => Promise<{
+            data: T[];
+            time: number;
+        }>;
+        update: (data: Record<string, any>, returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        softDelete: (options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">, returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        pluck: (key: ModelKey<T>, returnType?: "millis" | "seconds") => Promise<{
+            data: PluckReturnType<T, ModelKey<T>>;
+            time: number;
+        }>;
+    };
+    constructor(model: typeof Model, sqlDataSource?: SqlDataSource);
+    /**
+     * @description Sets the replication mode for the query builder
+     * @param replicationMode - The replication mode to use for the query builder
+     * @description If not specified, read operations will use slave (if available) else master, and write operations will always use master
+     * @description If set to "master", all operations will use master
+     * @description If set to "slave", read operations will use slave and write operations will use master
      */
-    format?: DateFormat;
+    setReplicationMode(replicationMode: ReplicationType): this;
     /**
-     * @description The timezone to use ('UTC' or 'LOCAL')
-     * @default "UTC"
+     * @description Adds a SELECT condition to the query with type safety.
+     * @description Can be stacked multiple times
+     * @description Supports: "column", "table.column", "*", "table.*", or [column, alias] tuples
+     * @example
+     * ```ts
+     * const user = await sql.query("users").select("name", "age").one();
+     * // user type: { name: any, age: any } | null
+     *
+     * const user = await sql.query("users").select(["name", "userName"]).one();
+     * // user type: { userName: any } | null
+     * ```
      */
-    timezone?: Timezone;
+    select<const Columns extends readonly Selectable[]>(...columns: Columns): QueryBuilder<T, ComposeBuildRawSelect<S, Columns>>;
     /**
-     * @description Whether to automatically update the timestamp on record updates, uses timezone and format from the dateColumn options
-     * @default false
+     * @description Adds a raw SELECT statement to the query with type safety.
+     * @description Use the generic parameter to specify the type of the selected columns.
+     * @example
+     * ```ts
+     * const result = await sql.query("users")
+     *   .selectRaw<{ total: number }>("count(*) as total")
+     *   .one();
+     * // result type: { total: number } | null
+     * ```
      */
-    autoUpdate?: boolean;
+    selectRaw<Added extends Record<string, any> = Record<string, any>>(statement: string): QueryBuilder<T, ComposeRawSelect<S, Added>>;
     /**
-     * @description Whether to automatically set the timestamp on record creation, uses timezone and format from the dateColumn options
-     * @default false
+     * @description Clears the SELECT clause and resets type to default
      */
-    autoCreate?: boolean;
-} & ColumnOptions;
-type SymmetricEncryptionOptions = {
+    clearSelect(): QueryBuilder<T, Record<string, any>>;
     /**
-     * @description The key to use for the symmetric encryption
+     * @description Selects a SQL function applied to a column with a typed alias.
+     * @description Provides intellisense for common SQL functions while accepting any custom function.
+     * @description Return type is auto-inferred based on function name (number for count/sum/avg, string for upper/lower/trim, etc.)
+     * @param sqlFunc The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
+     * @param column The column to apply the function to (use "*" for count(*))
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await sql.query("users")
+     *   .selectFunc("count", "*", "total")
+     *   .one();
+     * // result type: { total: number } | null - auto-inferred!
+     * ```
      */
-    key: string;
-} & ColumnOptions;
-type AsymmetricEncryptionOptions = {
+    selectFunc<F extends SqlFunction, Alias extends string>(sqlFunc: F, column: string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: SqlFunctionReturnType<F>;
+    }>>;
     /**
-     * @description The public key to use for the asymmetric encryption
+     * @description Selects a subquery, subquery must return a single column
      */
-    publicKey: string;
+    selectSubQuery<ValueType = any, Alias extends string = string>(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectJson<ValueType = any, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectJsonText<ValueType = string, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectJsonArrayLength<Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectJsonKeys<Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: string[];
+    }>>;
+    selectJsonRaw<ValueType = any, Alias extends string = string>(raw: string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
     /**
-     * @description The private key to use for the asymmetric encryption
+     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
      */
-    privateKey: string;
-} & ColumnOptions;
-/**
- * columns
- * @description Options for the column decorator
- */
-type ColumnOptions = {
+    exists(): Promise<boolean>;
     /**
-     * @description Whether the column is the primary key, composite primary keys are not supported
-     * @warning Only one primary key is allowed per model
-     * @throws {HysteriaError} if more than one primary key is defined
-     * @default false
+     * @description Executes the query and retrieves multiple results.
      */
-    primaryKey?: boolean;
+    many(): Promise<S[]>;
     /**
-     * @description The name of the primary key constraint in the database for automatic migrations
+     * @description Executes the query and retrieves a single column from the results.
+     * @param key - The column to retrieve from the results, must be a Model Column
      */
-    primaryKeyConstraintName?: string;
+    pluck<K extends ModelKey<T>>(key: K): Promise<PluckReturnType<T, K>>;
     /**
-     * @description Called on the value returned from the database before it is returned from the model
+     * @description Executes the query and retrieves a single result.
      */
-    serialize?: (value: any) => any;
+    one(): Promise<S | null>;
     /**
-     * @description Called on the value before it is inserted or updated in the database
-     * @warning This will not be called on massive update operations since it's not possible to know which values are being updated, so you must pass the value you want to update in the payload
+     * @description Executes the query and retrieves the first result. Fail if no result is found.
      */
-    prepare?: (value: any) => any;
+    oneOrFail(): Promise<S>;
     /**
-     * @description Whether the column is returned in the serialization output, this column will always be undefined
-     * @default false
+     * @description Executes the query and returns a node readable stream.
+     * @description If used by a model query builder, it will serialize the models and apply the hooks and relations.
+     * @postgres needs the pg-query-stream package in order to work
+     * @throws If using postgres and the `pg-query-stream` package is not installed
      */
-    hidden?: boolean;
+    stream<M = S>(options?: StreamOptions): Promise<PassThrough & AsyncGenerator<M>>;
     /**
-     * @description If true, the prepare function will always be called on update regardless of whether the value has been provided in the update payload
-     * @default false
+     * @description Chunks the query into smaller queries, it returns a generator of the chunks
+     * @description It will continue to yield chunks until the query returns no results
+     * @description Useful for large queries that need to be processed in chunks
+     * @warning overrides limit and offset set before in the query builder
+     * @param chunkSize - The size of the chunk
+     * @returns a generator of the chunks
+     * @example
+     * const chunks = await queryBuilder.chunk(100);
+     * // first chunk
+     * const firstChunk = await chunks.next();
+     * console.log(firstChunk.value);
+     * // second chunk
+     * const secondChunk = await chunks.next();
+     * console.log(secondChunk.value);
+     * // third chunk
+     * const thirdChunk = await chunks.next();
+     * console.log(thirdChunk.value);
+     *
+     * @example
+     * const chunkSize = 3;
+     * const chunks = [];
+     * const query = sql.query("users").orderBy("name", "asc");
+     * for await (const chunk of sql.chunk(chunkSize)) {
+     *   chunks.push(chunk);
+     * }
+     *
+     * console.log(chunks);
      */
-    autoUpdate?: boolean;
+    chunk(chunkSize: number): AsyncGenerator<S[], void, unknown>;
     /**
-     * @description The name of the column in the database, can be used to specify the column name in the database
-     * @default The name of the property following the model case convention
+     * @description Executes the query and retrieves multiple paginated results.
+     * @description Overrides the limit and offset clauses in order to paginate the results.
+     * @description Allows to avoid offset clause that can be inefficient for large datasets
+     * @description If using a model query builder, primary key is used as discriminator by default
+     * @param options - The options for the paginate with cursor
+     * @param options.discriminator - The discriminator to use for the paginate with Cursor pagination
+     * @param options.operator - The operator to use for the paginate with Cursor pagination
+     * @param options.orderBy - The order by to use for the paginate with Cursor pagination
+     * @param cursor - The cursor to use for the paginate with Cursor pagination
+     * @warning If no order by clause is present in the query, the query will add an order by clause to the query `orderBy(discriminator, "asc")`
+     * @returns the pagination metadata and the cursor for the next page
      */
-    databaseName?: string;
+    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[RawCursorPaginatedData<S>, Cursor<T, K>]>;
     /**
-     * @description Custom OpenAPI schema for the column, if omitted, the column type will be inferred from the other options in best effort
+     * @description Locks the table for update
+     * @param skipLocked - If true, the query will skip locked rows
+     * @sqlite does not support skipping locked rows, it will be ignored
      */
-    openApi?: OpenApiModelPropertyType & {
-        required?: boolean;
-    };
+    lockForUpdate(options?: {
+        skipLocked?: boolean;
+        noWait?: boolean;
+    }): this;
     /**
-     * @description Whether the column can be null in the database
-     * @migration Only affects auto-generated migrations
+     * @description Locks the table for share
+     * @param skipLocked - If true, the query will skip locked rows
+     * @sqlite does not support skipping locked rows, it will be ignored
      */
-    nullable?: boolean;
+    forShare(options?: {
+        skipLocked?: boolean;
+        noWait?: boolean;
+    }): this;
     /**
-     * @description The default value for the column in the database
-     * @migration Only affects auto-generated migrations
+     * @description Adds a UNION to the query.
      */
-    default?: string | number | null | boolean;
-} & 
-/**
- * @description The data type of the column
- * @migration Only affects auto-generated migrations
- */
-ColumnDataTypeOption;
-type ColumnType = {
-    columnName: string;
-    databaseName: string;
-    serialize?: (value: any) => any | Promise<any>;
-    prepare?: (value: any) => any | Promise<any>;
-    hidden?: boolean;
-    autoUpdate?: boolean;
-    isPrimary: boolean;
-    openApi?: OpenApiModelPropertyType & {
-        required?: boolean;
-    };
-    /** Database specific data for migrations, must be provided or it'll be ignored for auto-generated migrations */
-    primaryKeyConstraintName?: string;
-    type?: ColumnDataType;
-    length?: number;
-    precision?: number;
-    scale?: number;
-    withTimezone?: boolean;
-    constraints?: {
-        nullable?: boolean;
-        default?: string | number | null | boolean;
-    };
-};
-type ThroughModelCallback<T extends typeof Model> = () => T;
-type ThroughModelString = string;
-type ThroughModel<T extends typeof Model> = ThroughModelCallback<T> | ThroughModelString;
-type ExtractModelFromTM<TM extends ThroughModel<any>> = TM extends ThroughModelCallback<infer T> ? T : never;
-type ManyToManyOptions<T extends typeof Model, TM extends ThroughModel<T>> = {
+    union(query: string, bindings?: any[]): this;
+    union(cb: UnionCallBack<T>): this;
     /**
-     * @description The foreign key of current model on the Pivot table
-     * @example If the current model is User and the through model is UserAddress, the leftForeignKey will be "userId"
+     * @description Adds a UNION ALL to the query.
      */
-    leftForeignKey?: TM extends ThroughModelString ? string : ModelKey<InstanceType<ExtractModelFromTM<TM>>>;
+    unionAll(query: string, bindings?: any[]): this;
+    unionAll(cb: UnionCallBack<T>): this;
+    unionAll(queryBuilder: QueryBuilder<any>): this;
     /**
-     * @description The foreign key of the related model on the Pivot table
-     * @example If the current model is User and the through model is UserAddress, the rightForeignKey will be "addressId"
+     * @description Increments the value of a column by a given amount
+     * @typeSafe - In typescript, only numeric columns of the model will be accepted if using a Model
+     * @default value + 1
+     * @returns WriteOperation that resolves to the number of affected rows
      */
-    rightForeignKey?: TM extends ThroughModelString ? string : ModelKey<InstanceType<ExtractModelFromTM<TM>>>;
-};
-type ManyToManyStringOptions = {
-    leftForeignKey?: string;
-    rightForeignKey?: string;
-};
-type IndexType = {
-    columns: string[];
-    name: string;
-};
-type UniqueType = {
-    columns: string[];
-    name: string;
-};
-
-declare abstract class FooterQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> {
-    protected sqlDataSource: SqlDataSource;
-    protected model: typeof Model;
-    protected groupByNodes: GroupByNode[];
-    protected orderByNodes: OrderByNode[];
-    protected limitNode: LimitNode | null;
-    protected offsetNode: OffsetNode | null;
-    protected modelColumns: ColumnType[];
-    protected modelColumnsMap: Map<string, ColumnType>;
-    protected logs: boolean;
-    protected constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    increment(column: string, value: number): WriteOperation<number>;
+    increment(column: NumberModelKey<T>, value: number): WriteOperation<number>;
     /**
-     * @description Clears the group by query
+     * @description Decrements the value of a column by a given amount
+     * @typeSafe - In typescript, only numeric columns of the model will be accepted if using a Model
+     * @default value - 1
+     * @returns WriteOperation that resolves to the number of affected rows
      */
-    clearGroupBy(): this;
+    decrement(column: string, value: number): WriteOperation<number>;
+    decrement(column: NumberModelKey<T>, value: number): WriteOperation<number>;
     /**
-     * @description Clears the order by query
+     * @description Executes the query and retrieves the count of results, it ignores all select, group by, order by, limit and offset clauses if they are present.
      */
-    clearOrderBy(): this;
+    getCount(column?: string): Promise<number>;
     /**
-     * @description Clears the limit query
+     * @description Executes the query and retrieves the maximum value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
      */
-    clearLimit(): this;
+    getMax(column: string): Promise<number>;
     /**
-     * @description Clears the offset query
+     * @description Executes the query and retrieves the minimum value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
      */
-    clearOffset(): this;
+    getMin(column: string): Promise<number>;
     /**
-     * @description Adds a group by query
+     * @description Executes the query and retrieves the average value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
      */
-    groupBy(...columns: ModelKey<T>[]): this;
-    groupBy<S extends string>(...columns: SelectableColumn$1<S>[]): this;
+    getAvg(column: string): Promise<number>;
     /**
-     * @description Adds a raw group by query, GROUP BY clause is not necessary and will be added automatically
+     * @description Executes the query and retrieves the sum of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
      */
-    groupByRaw(query: string): this;
+    getSum(column: string): Promise<number>;
     /**
-     * @description Adds an order by query
+     * @description Executes the query and retrieves multiple paginated results.
+     * @description Overrides the limit and offset clauses in order to paginate the results.
      */
-    orderBy(column: ModelKey<T>, order: OrderByChoices): this;
-    orderBy<S extends string>(column: SelectableColumn$1<S>, order: OrderByChoices): this;
+    paginate(page: number, perPage: number): Promise<RawPaginatedData<S>>;
     /**
-     * @description Adds a raw order by query, ORDER BY clause is not necessary and will be added automatically
+     * @description Overrides the from clause in the query.
      */
-    orderByRaw(query: string): this;
+    from<S extends string>(table: TableFormat<S>, alias?: string): this;
+    from(cb: (qb: QueryBuilder<T>) => void, alias: string): this;
     /**
-     * @description Adds a limit query
+     * @description Adds a CTE to the query using a callback to build the subquery.
      */
-    limit(limit: number): this;
+    with(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
     /**
-     * @description Adds an offset query
+     * @description Adds a recursive CTE to the query using a callback to build the subquery.
+     * @mssql not supported
      */
-    offset(offset: number): this;
-}
-
-declare class JoinOnQueryBuilder {
-    protected sqlDataSource: SqlDataSource;
-    protected whereNodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
-    protected isNestedCondition: boolean;
-    constructor(sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
+    withRecursive(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
     /**
-     * @description Get the where conditions for the join
+     * @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
      */
-    getConditions(): (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
+    withMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
     /**
-     * @description Adds a WHERE condition to the query.
+     * @description Insert record into a table, you can use raw statements in the data object for literal references to other columns
+     * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
+     * @returns WriteOperation that executes when awaited
      */
-    where(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    where(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
-    where(column: SelectableColumn$1<string>, value: BaseValues): this;
+    insert(data: Record<string, WriteQueryParam>, returning?: string[]): WriteOperation<T>;
     /**
-     * @description Adds an AND WHERE condition to the query.
+     * @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
+     * @oracledb may do multiple inserts with auto-generated identity columns
      */
-    andWhere(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhere(column: SelectableColumn$1<string>, value: BaseValues): this;
-    andWhere(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
+    insertMany(data: Record<string, WriteQueryParam>[], returning?: string[]): WriteOperation<T[]>;
     /**
-     * @description Adds an OR WHERE condition to the query.
+     * @description Updates or creates a new record using upsert functionality
+     * @param data The data to insert or update
+     * @param searchCriteria The criteria to search for existing records
+     * @param options Upsert options including updateOnConflict and returning columns
+     * @returns WriteOperation that executes when awaited
      */
-    orWhere(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhere(column: SelectableColumn$1<string>, value: BaseValues): this;
-    orWhere(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
+    upsert<O extends Record<string, any>>(data: O, searchCriteria: Partial<O>, options?: UpsertOptionsRawBuilder): WriteOperation<T[]>;
     /**
-     * @description Adds a negated WHERE condition to the query.
+     * @description Updates or creates multiple records using upsert functionality
+     * @param conflictColumns The columns to check for conflicts
+     * @param columnsToUpdate The columns to update on conflict
+     * @param data Array of data objects to insert or update
+     * @param options Upsert options including updateOnConflict and returning columns
+     * @returns WriteOperation that executes when awaited
      */
-    whereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    whereNot(column: SelectableColumn$1<string>, value: BaseValues): this;
+    upsertMany<O extends Record<string, any>>(conflictColumns: string[], columnsToUpdate: string[], data: O[], options?: UpsertOptionsRawBuilder): WriteOperation<T[]>;
     /**
-     * @description Adds a negated AND WHERE condition to the query.
+     * @description Executes a MERGE statement for MSSQL upsert operations (raw query builder)
      */
-    andWhereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhereNot(column: SelectableColumn$1<string>, value: BaseValues): this;
+    private executeMssqlMergeRaw;
     /**
-     * @description Adds a negated OR WHERE condition to the query.
+     * @description Updates records from a table, you can use raw statements in the data object for literal references to other columns
+     * @returns WriteOperation that resolves to the number of affected rows
      */
-    orWhereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhereNot(column: SelectableColumn$1<string>, value: BaseValues): this;
+    update(data: Record<string, WriteQueryParam>): WriteOperation<number>;
     /**
-     * @description Adds a WHERE BETWEEN condition to the query.
+     * @description Deletes all records from a table
+     * @warning This operation does not trigger any hook
+     * @returns WriteOperation that executes when awaited
      */
-    whereBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
+    truncate(): WriteOperation<void>;
     /**
-     * @description Adds an AND WHERE BETWEEN condition to the query.
+     * @description Deletes records from a table
+     * @returns WriteOperation that resolves to the number of affected rows
      */
-    andWhereBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
+    delete(): WriteOperation<number>;
     /**
-     * @description Adds an OR WHERE BETWEEN condition to the query.
+     * @description Soft deletes records from a table
+     * @default column - 'deletedAt'
+     * @default value - The current date and time in UTC timezone in the format "YYYY-MM-DD HH:mm:ss"
+     * @returns WriteOperation that resolves to the number of affected rows
      */
-    orWhereBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
+    softDelete(options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">): WriteOperation<number>;
     /**
-     * @description Adds a WHERE NOT BETWEEN condition to the query.
+     * @description Returns the query with the parameters bound to the query
+     * @warning Does not apply any hook from the model
      */
-    whereNotBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
+    toQuery(): string;
     /**
-     * @description Adds an AND WHERE NOT BETWEEN condition to the query.
+     * @description Returns the query with database driver placeholders and the params
+     * @warning Does not apply any hook from the model
      */
-    andWhereNotBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
+    unWrap(): ReturnType<typeof AstParser.prototype.parse>;
     /**
-     * @description Adds an OR WHERE NOT BETWEEN condition to the query.
+     * @description Returns a deep clone of the query builder instance.
      */
-    orWhereNotBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
+    clone(): QueryBuilder<T, S>;
     /**
-     * @description Adds a WHERE LIKE condition to the query.
+     * @description Gives a fresh instance of the query builder
      */
-    whereLike(column: SelectableColumn$1<string>, value: string): this;
+    clear(): QueryBuilder<T, Record<string, any>>;
     /**
-     * @description Adds an AND WHERE LIKE condition to the query.
+     * @description Removes the lock query
      */
-    andWhereLike(column: SelectableColumn$1<string>, value: string): this;
+    clearLockQuery(): this;
     /**
-     * @description Adds an OR WHERE LIKE condition to the query.
+     * @description Removes any union query
      */
-    orWhereLike(column: SelectableColumn$1<string>, value: string): this;
+    clearUnionQuery(): this;
     /**
-     * @description Adds a WHERE ILIKE condition to the query.
+     * @description Removes any with query
      */
-    whereILike(column: SelectableColumn$1<string>, value: string): this;
+    clearWithQuery(): this;
+    extractQueryNodes(): QueryNode[];
+    protected clearForFunctions(): this;
     /**
-     * @description Adds an AND WHERE ILIKE condition to the query.
+     * @description Makes a many query and returns the time that took to execute that query
      */
-    andWhereILike(column: SelectableColumn$1<string>, value: string): this;
+    private manyWithPerformance;
     /**
-     * @description Adds an OR WHERE ILIKE condition to the query.
+     * @description Makes a one query and returns the time that took to execute that query
      */
-    orWhereILike(column: SelectableColumn$1<string>, value: string): this;
+    private oneWithPerformance;
     /**
-     * @description Adds a WHERE NOT LIKE condition to the query.
+     * @alias oneOrFailWithPerformance
      */
-    whereNotLike(column: SelectableColumn$1<string>, value: string): this;
+    private firstOrFailWithPerformance;
+    private paginateWithPerformance;
+    private paginateWithCursorWithPerformance;
     /**
-     * @description Adds an AND WHERE NOT LIKE condition to the query.
+     * @description Makes a one or fail query and returns the time that took to execute that query
      */
-    andWhereNotLike(column: SelectableColumn$1<string>, value: string): this;
+    private oneOrFailWithPerformance;
     /**
-     * @description Adds an OR WHERE NOT LIKE condition to the query.
+     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
+     * @description Returns the time that took to execute the query
      */
-    orWhereNotLike(column: SelectableColumn$1<string>, value: string): this;
+    private existsWithPerformance;
+    private pluckWithPerformance;
+    private updateWithPerformance;
+    private insertWithPerformance;
+    private insertManyWithPerformance;
+    private softDeleteWithPerformance;
+    private deleteWithPerformance;
+    private truncateWithPerformance;
     /**
-     * @description Adds a WHERE NOT ILIKE condition to the query.
+     * @description Checks if the current context is an MSSQL transaction
+     * @description MSSQL transactions can only handle one request at a time
      */
-    whereNotILike(column: SelectableColumn$1<string>, value: string): this;
+    protected isMssqlTransaction(): boolean;
     /**
-     * @description Adds an AND WHERE NOT ILIKE condition to the query.
+     * @description Executes pagination queries, serializing them for MSSQL transactions
      */
-    andWhereNotILike(column: SelectableColumn$1<string>, value: string): this;
+    protected executePaginateQueries<M, C>(modelsQuery: () => Promise<M>, countQuery: () => Promise<C>): Promise<[M, C]>;
+    protected getSqlDataSource(mode: "read" | "write"): Promise<SqlDataSource>;
     /**
-     * @description Adds an OR WHERE NOT ILIKE condition to the query.
+     * @description Executes SQL with slave failure handling
+     * @param mode The operation mode (read or write)
+     * @param operation The execSql operation to perform
+     * @returns The result of the operation
      */
-    orWhereNotILike(column: SelectableColumn$1<string>, value: string): this;
-    /**
-     * @description Adds a WHERE IN condition to the query.
-     */
-    whereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
-    /**
-     * @description Adds an AND WHERE IN condition to the query.
-     */
-    andWhereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
-    /**
-     * @description Adds an OR WHERE IN condition to the query.
-     */
-    orWhereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
-    /**
-     * @description Adds a WHERE NOT IN condition to the query.
-     */
-    whereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
-    /**
-     * @description Adds an AND WHERE NOT IN condition to the query.
-     */
-    andWhereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
-    /**
-     * @description Adds an OR WHERE NOT IN condition to the query.
-     */
-    orWhereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
-    /**
-     * @description Adds a WHERE NULL condition to the query.
-     */
-    whereNull(column: SelectableColumn$1<string>): this;
-    /**
-     * @description Adds an AND WHERE NULL condition to the query.
-     */
-    andWhereNull(column: SelectableColumn$1<string>): this;
-    /**
-     * @description Adds an OR WHERE NULL condition to the query.
-     */
-    orWhereNull(column: SelectableColumn$1<string>): this;
-    /**
-     * @description Adds a WHERE NOT NULL condition to the query.
-     */
-    whereNotNull(column: SelectableColumn$1<string>): this;
-    /**
-     * @description Adds an AND WHERE NOT NULL condition to the query.
-     */
-    andWhereNotNull(column: SelectableColumn$1<string>): this;
-    /**
-     * @description Adds an OR WHERE NOT NULL condition to the query.
-     */
-    orWhereNotNull(column: SelectableColumn$1<string>): this;
-    /**
-     * @description Adds a WHERE REGEXP condition to the query.
-     */
-    whereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
-    /**
-     * @description Adds an AND WHERE REGEXP condition to the query.
-     */
-    andWhereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
-    /**
-     * @description Adds an OR WHERE REGEXP condition to the query.
-     */
-    orWhereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
-    /**
-     * @description Adds a WHERE NOT REGEXP condition to the query.
-     */
-    whereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
+    protected execSqlWithSlaveHandling<R>(mode: "read" | "write", operation: (dataSource: SqlDataSource) => Promise<R>): Promise<R>;
+}
+
+declare class DistinctNode extends QueryNode {
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor();
+}
+
+declare class DistinctOnNode extends QueryNode {
+    columns: string[];
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(columns: string[]);
+}
+
+declare class SelectNode extends QueryNode {
+    column: string | QueryNode | QueryNode[];
+    alias?: string;
+    sqlFunction?: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string | QueryNode | QueryNode[], alias?: string, sqlFunction?: string, isRaw?: 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)[];
+    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;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, isRawValue?: boolean);
+}
+
+declare class LimitNode extends QueryNode {
+    limit: number;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(limit: number);
+}
+
+declare class OffsetNode extends QueryNode {
+    offset: number;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(offset: number);
+}
+
+declare class OrderByNode extends QueryNode {
+    column: string;
+    direction: "asc" | "desc";
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, direction?: "asc" | "desc", isRawValue?: boolean);
+}
+
+type DateFormat = "ISO" | "TIMESTAMP" | "DATE_ONLY" | "TIME_ONLY";
+type Timezone = "UTC" | "LOCAL";
+
+/**
+ * @description Options for the relation
+ * @property {string} softDeleteColumn - The column name for the soft delete column, if set, the relation will only return rows that have not been soft deleted
+ * @property {string} softDeleteType - The type of the soft delete column
+ */
+declare enum RelationEnum {
+    hasOne = "hasOne",// One to One without foreign key
+    belongsTo = "belongsTo",// One to One with foreign key
+    hasMany = "hasMany",
+    manyToMany = "manyToMany"
+}
+/**
+ * Main Relation Class
+ */
+declare abstract class Relation {
+    abstract type: RelationEnum;
+    model: typeof Model;
+    columnName: string;
+    foreignKey?: string;
+    relatedModel: string;
+    protected constructor(model: typeof Model, columnName: string);
+}
+
+type ColumnDataType = Exclude<keyof CreateTableBuilder, "enum" | "rawColumn" | "custom"> | readonly string[];
+type ColumnDataTypeOptionWithLength = {
+    type?: "char" | "varchar" | "string" | "uuid" | "ulid" | "varbinary" | "integer" | "tinyint" | "smallint" | "mediumint" | "bigint" | "increment" | "bigIncrement";
+    length?: number;
+};
+type ColumnDataTypeOptionWithEnum = {
+    type?: readonly string[];
+};
+type ColumnDataTypeOptionWithPrecision = {
+    type?: "float" | "double" | "real";
+    precision?: number;
+};
+type ColumnDataTypeOptionWithScaleAndPrecision = {
+    type?: "decimal" | "numeric";
+    precision?: number;
+    scale?: number;
+};
+type ColumnDataTypeOptionWithText = {
+    type?: "text" | "longtext" | "mediumtext" | "tinytext";
+};
+type ColumnDataTypeOptionWithBinary = {
+    type?: "binary" | "blob" | "tinyblob" | "mediumblob" | "longblob";
+};
+type ColumnDataTypeOptionWithDatePrecision = {
+    type?: "date" | "time" | "datetime" | "timestamp";
+    precision?: number;
+    withTimezone?: boolean;
+};
+type ColumnDataTypeOptionSimple = {
+    type?: "year" | "boolean" | "json" | "jsonb";
+};
+type ColumnDataTypeOption = ColumnDataTypeOptionWithLength | ColumnDataTypeOptionWithPrecision | ColumnDataTypeOptionWithScaleAndPrecision | ColumnDataTypeOptionWithText | ColumnDataTypeOptionWithBinary | ColumnDataTypeOptionWithDatePrecision | ColumnDataTypeOptionWithEnum | ColumnDataTypeOptionSimple;
+type LazyRelationType = {
+    type?: RelationEnum;
+    columnName: string;
+    model: () => typeof Model;
+    foreignKey: string | (() => string);
+    constraintName: string | (() => string);
+    onDelete?: OnUpdateOrDelete;
+    onUpdate?: OnUpdateOrDelete;
     /**
-     * @description Adds an AND WHERE NOT REGEXP condition to the query.
+     * @description Only for many to many relations
      */
-    andWhereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
+    manyToManyOptions?: {
+        primaryModel: string;
+        throughModel: string | (() => string);
+        leftForeignKey: string | (() => string);
+        rightForeignKey: string | (() => string);
+        wasModelProvided: boolean;
+    };
+};
+type DateColumnOptions = {
     /**
-     * @description Adds an OR WHERE NOT REGEXP condition to the query.
+     * @description The format to store dates in ('ISO' or 'TIMESTAMP')
+     * @default "ISO"
      */
-    orWhereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
+    format?: DateFormat;
     /**
-     * @description Adds a WHERE group condition with AND.
+     * @description The timezone to use ('UTC' or 'LOCAL')
+     * @default "UTC"
      */
-    whereGroup(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
+    timezone?: Timezone;
     /**
-     * @description Adds a WHERE group condition with AND.
+     * @description Whether to automatically update the timestamp on record updates, uses timezone and format from the dateColumn options
+     * @default false
      */
-    andWhereGroup(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
+    autoUpdate?: boolean;
     /**
-     * @description Adds a WHERE group condition with OR.
+     * @description Whether to automatically set the timestamp on record creation, uses timezone and format from the dateColumn options
+     * @default false
      */
-    orWhereGroup(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
+    autoCreate?: boolean;
+} & ColumnOptions;
+type SymmetricEncryptionOptions = {
     /**
-     * @description Adds a raw WHERE condition to the query.
+     * @description The key to use for the symmetric encryption
      */
-    whereRaw(sql: string, bindings?: BaseValues[]): this;
+    key: string;
+} & ColumnOptions;
+type AsymmetricEncryptionOptions = {
     /**
-     * @description Adds an AND raw WHERE condition to the query.
+     * @description The public key to use for the asymmetric encryption
      */
-    andWhereRaw(sql: string, bindings?: BaseValues[]): this;
+    publicKey: string;
     /**
-     * @description Adds an OR raw WHERE condition to the query.
+     * @description The private key to use for the asymmetric encryption
      */
-    orWhereRaw(sql: string, bindings?: BaseValues[]): this;
-}
-
+    privateKey: string;
+} & ColumnOptions;
 /**
- * @description Callback type for join conditions
+ * columns
+ * @description Options for the column decorator
  */
-type JoinOnCallback = (query: JoinOnQueryBuilder) => void;
-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);
-    /**
-     * @description Clear the join query
-     */
-    clearJoin(): this;
-    /**
-     * @description Join a table with the current model, join clause is not necessary and will be added automatically
-     */
-    joinRaw(query: string): this;
-    /**
-     * @description Join a table with the current model, join clause is not necessary and will be added automatically
-     */
-    leftJoinRaw(query: string): this;
-    /**
-     * @description Join a table with the current model, join clause is not necessary and will be added automatically
-     */
-    rightJoinRaw(query: string): this;
-    /**
-     * @description Join a table with the current model, join clause is not necessary and will be added automatically
-     */
-    fullJoinRaw(query: string): this;
-    /**
-     * @description Join a table with the current model, join clause is not necessary and will be added automatically
-     */
-    crossJoinRaw(query: string): this;
+type ColumnOptions = {
     /**
-     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     * @description Whether the column is the primary key, composite primary keys are not supported
+     * @warning Only one primary key is allowed per model
+     * @throws {HysteriaError} if more than one primary key is defined
+     * @default false
      */
-    naturalJoinRaw(query: string): this;
+    primaryKey?: boolean;
     /**
-     * @alias join
-     * @param relationTable - The table to join
-     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
-     * @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: "=")
+     * @description The name of the primary key constraint in the database for automatic migrations
      */
-    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
-    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
-    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType): this;
-    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType): this;
-    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
-    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, callback: JoinOnCallback): this;
+    primaryKeyConstraintName?: string;
     /**
-     * @description Join a table with the current model
-     * @param relationTable - The table to join
-     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
-     * @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: "=")
+     * @description Called on the value returned from the database before it is returned from the model
      */
-    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
-    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
-    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType): this;
-    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType): this;
-    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
-    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, callback: JoinOnCallback): this;
+    serialize?: (value: any) => any;
     /**
-     * @description Join a table with the current model
-     * @param relationTable - The table to join
-     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
-     * @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: "=")
+     * @description Called on the value before it is inserted or updated in the database
+     * @warning This will not be called on massive update operations since it's not possible to know which values are being updated, so you must pass the value you want to update in the payload
      */
-    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
-    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
-    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType): this;
-    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType): this;
-    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
-    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, callback: JoinOnCallback): this;
+    prepare?: (value: any) => any;
     /**
-     * @description Join a table with the current model
-     * @param relationTable - The table to join
-     * @param referencingColumn - The column to reference from the relation table
-     * @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: "=")
+     * @description Whether the column is returned in the serialization output, this column will always be undefined
+     * @default false
      */
-    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
-    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
-    rightJoin<R extends typeof Model>(relationTable: string | R, referencingColumnOrPrimaryColumn: ModelKey<InstanceType<R>> | JoinableColumn | ModelKey<T>, primaryColumn?: JoinableColumn | ModelKey<T>, operator?: BinaryOperatorType): this;
-    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
-    /**
-     * @description Perform a FULL OUTER JOIN with another table
-     * @param relationTable - The table to join
-     * @param referencingColumn - The column to reference from the relation table
-     * @param primaryColumn - The primary column of the current model
-     * @param operator - The comparison operator to use in the ON clause (default: "=")
+    hidden?: boolean;
+    /**
+     * @description If true, the prepare function will always be called on update regardless of whether the value has been provided in the update payload
+     * @default false
      */
-    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
-    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
-    fullJoin<R extends typeof Model>(relationTable: string | R, referencingColumnOrPrimaryColumn: ModelKey<InstanceType<R>> | JoinableColumn | ModelKey<T>, primaryColumn?: JoinableColumn | ModelKey<T>, operator?: BinaryOperatorType): this;
-    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
-    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
-}
-
-declare class SelectQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends JoinQueryBuilder<T, S> {
-    protected dbType: SqlDataSourceType;
-    protected modelSelectedColumns: string[];
-    protected withQuery?: string;
-    protected fromNode: FromNode;
-    protected distinctNode: DistinctNode | null;
-    protected distinctOnNode: DistinctOnNode | null;
-    protected selectNodes: SelectNode[];
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    autoUpdate?: boolean;
     /**
-     * @description Adds a SELECT condition to the query.
-     * @description Can be stacked multiple times
-     * @description Supports: "column", "table.column", "*", "table.*", or [column, alias] tuples
-     * @example
-     * .select("id", "name")                           // Simple columns
-     * .select(["id", "userId"], ["name", "userName"]) // Columns with aliases
-     * .select("id", ["name", "userName"])             // Mixed
+     * @description The name of the column in the database, can be used to specify the column name in the database
+     * @default The name of the property following the model case convention
      */
-    select<C extends string>(...columns: (SelectableColumn$1<C> | Selectable)[]): this;
-    select(...columns: (ModelKey<T> | "*" | Selectable)[]): this;
+    databaseName?: string;
     /**
-     * @description Adds a raw SELECT statement to the query
+     * @description Custom OpenAPI schema for the column, if omitted, the column type will be inferred from the other options in best effort
      */
-    selectRaw(statement: string): this;
+    openApi?: OpenApiModelPropertyType & {
+        required?: boolean;
+    };
     /**
-     * @description Selects a SQL function applied to a column with a typed alias.
-     * @description Provides intellisense for common SQL functions while accepting any custom function.
-     * @param func The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
-     * @param column The column to apply the function to (use "*" for count(*))
-     * @param alias The alias for the result
-     * @example
-     * .selectFunc("count", "*", "total")
-     * .selectFunc("upper", "name", "upperName")
-     * .selectFunc("custom_fn", "column", "result")
+     * @description Whether the column can be null in the database
+     * @migration Only affects auto-generated migrations
      */
-    selectFunc<A extends string>(sqlFunc: SqlFunction, column: string, alias: A): this;
+    nullable?: boolean;
     /**
-     * @description Clears the SELECT clause
+     * @description The default value for the column in the database
+     * @migration Only affects auto-generated migrations
      */
-    clearSelect(): this;
+    default?: string | number | null | boolean;
+} & 
+/**
+ * @description The data type of the column
+ * @migration Only affects auto-generated migrations
+ */
+ColumnDataTypeOption;
+type ColumnType = {
+    columnName: string;
+    databaseName: string;
+    serialize?: (value: any) => any | Promise<any>;
+    prepare?: (value: any) => any | Promise<any>;
+    hidden?: boolean;
+    autoUpdate?: boolean;
+    isPrimary: boolean;
+    openApi?: OpenApiModelPropertyType & {
+        required?: boolean;
+    };
+    /** Database specific data for migrations, must be provided or it'll be ignored for auto-generated migrations */
+    primaryKeyConstraintName?: string;
+    type?: ColumnDataType;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    withTimezone?: boolean;
+    constraints?: {
+        nullable?: boolean;
+        default?: string | number | null | boolean;
+    };
+};
+type ThroughModelCallback<T extends typeof Model> = () => T;
+type ThroughModelString = string;
+type ThroughModel<T extends typeof Model> = ThroughModelCallback<T> | ThroughModelString;
+type ExtractModelFromTM<TM extends ThroughModel<any>> = TM extends ThroughModelCallback<infer T> ? T : never;
+type ManyToManyOptions<T extends typeof Model, TM extends ThroughModel<T>> = {
     /**
-     * @description Clears the FROM clause
+     * @description The foreign key of current model on the Pivot table
+     * @example If the current model is User and the through model is UserAddress, the leftForeignKey will be "userId"
      */
-    clearFrom(): this;
+    leftForeignKey?: TM extends ThroughModelString ? string : ModelKey<InstanceType<ExtractModelFromTM<TM>>>;
     /**
-     * @description Clears the DISTINCT clause
+     * @description The foreign key of the related model on the Pivot table
+     * @example If the current model is User and the through model is UserAddress, the rightForeignKey will be "addressId"
      */
-    clearDistinct(): this;
+    rightForeignKey?: TM extends ThroughModelString ? string : ModelKey<InstanceType<ExtractModelFromTM<TM>>>;
+};
+type ManyToManyStringOptions = {
+    leftForeignKey?: string;
+    rightForeignKey?: string;
+};
+type IndexType = {
+    columns: string[];
+    name: string;
+};
+type UniqueType = {
+    columns: string[];
+    name: string;
+};
+
+declare abstract class FooterQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> {
+    protected sqlDataSource: SqlDataSource;
+    protected model: typeof Model;
+    protected groupByNodes: GroupByNode[];
+    protected orderByNodes: OrderByNode[];
+    protected limitNode: LimitNode | null;
+    protected offsetNode: OffsetNode | null;
+    protected modelColumns: ColumnType[];
+    protected modelColumnsMap: Map<string, ColumnType>;
+    protected logs: boolean;
+    protected constructor(model: typeof Model, sqlDataSource: SqlDataSource);
     /**
-     * @description Clears the DISTINCT ON clause
+     * @description Clears the group by query
      */
-    clearDistinctOn(): this;
+    clearGroupBy(): this;
     /**
-     * @description Sets the table to select from, by default is the table defined in the Model
+     * @description Clears the order by query
      */
-    from<F extends string>(table: TableFormat<F>): this;
+    clearOrderBy(): this;
     /**
-     * @description Sets the table to select from, by default is the table defined in the Model
-     * @alias from
+     * @description Clears the limit query
      */
-    table(table: string): this;
+    clearLimit(): this;
     /**
-     * @description Adds a DISTINCT clause to the query
+     * @description Clears the offset query
      */
-    distinct(): this;
+    clearOffset(): this;
     /**
-     * @description Adds a DISTINCT ON clause to the query
-     * @postgresql Only usable with PostgreSQL
+     * @description Adds a group by query
      */
-    distinctOn(...columns: ModelKey<T>[]): this;
-    distinctOn<C extends string>(...columns: SelectableColumn$1<C>[]): this;
+    groupBy(...columns: ModelKey<T>[]): this;
+    groupBy<S extends string>(...columns: SelectableColumn$1<S>[]): this;
     /**
-     * @description Selects a JSON value at the specified path and returns it as JSON
+     * @description Adds a raw group by query, GROUP BY clause is not necessary and will be added automatically
      */
-    selectJson<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
-    selectJson<A extends string>(column: string, path: JsonPathInput, alias: A): this;
+    groupByRaw(query: string): this;
     /**
-     * @description Selects a JSON value at the specified path and returns it as text
+     * @description Adds an order by query
      */
-    selectJsonText<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
-    selectJsonText<A extends string>(column: string, path: JsonPathInput, alias: A): this;
+    orderBy(column: ModelKey<T>, order: OrderByChoices): this;
+    orderBy<S extends string>(column: SelectableColumn$1<S>, order: OrderByChoices): this;
     /**
-     * @description Selects the length of a JSON array
+     * @description Adds a raw order by query, ORDER BY clause is not necessary and will be added automatically
      */
-    selectJsonArrayLength<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
-    selectJsonArrayLength<A extends string>(column: string, path: JsonPathInput, alias: A): this;
+    orderByRaw(query: string): this;
     /**
-     * @description Selects the keys of a JSON object
+     * @description Adds a limit query
      */
-    selectJsonKeys<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
-    selectJsonKeys<A extends string>(column: string, path: JsonPathInput, alias: A): this;
+    limit(limit: number): this;
     /**
-     * @description Adds a raw JSON select expression
+     * @description Adds an offset query
      */
-    selectJsonRaw<A extends string>(raw: string, alias: A): this;
+    offset(offset: number): this;
 }
 
-declare abstract class WhereQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends SelectQueryBuilder<T, S> {
+declare class JoinOnQueryBuilder {
+    protected sqlDataSource: SqlDataSource;
     protected whereNodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
-    protected havingNodes: HavingNode[];
     protected isNestedCondition: boolean;
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
-    clearWhere(): this;
-    clearHaving(): this;
-    /**
-     * @description Accepts a value and executes a callback only of the value is not null or undefined.
-     * @warning The value is not checked for truthiness but existence, it is only checked for undefined or null. So false, 0, "", etc. will be considered truthy.
-     */
-    strictWhen(value: any, cb: (query: this) => void): this;
+    constructor(sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
     /**
-     * @description Accepts a value and executes a callback only of the value is not falsy.
-     * @warning The value is checked for truthiness, so false, 0, "", etc. will be considered falsy. Use strictWhen for null or undefined only cases.
+     * @description Get the where conditions for the join
      */
-    when(value: any, cb: (query: this) => void): this;
+    getConditions(): (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
     /**
      * @description Adds a WHERE condition to the query.
      */
-    where(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    where<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    where(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
-    where(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    where(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    where(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
+    where(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    where(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
+    where(column: SelectableColumn$1<string>, value: BaseValues): this;
     /**
      * @description Adds an AND WHERE condition to the query.
      */
-    andWhere(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
     andWhere(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhere(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
-    andWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
-    andWhere(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    andWhere(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    andWhere(column: SelectableColumn$1<string>, value: BaseValues): this;
+    andWhere(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
     /**
      * @description Adds an OR WHERE condition to the query.
      */
-    orWhere(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhere<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhere<S extends string>(column: ModelKey<T> | SelectableColumn$1<S>, value: BaseValues): this;
-    orWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
-    orWhere(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    orWhere(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    orWhere(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    orWhere(column: SelectableColumn$1<string>, value: BaseValues): this;
+    orWhere(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
     /**
      * @description Adds a negated WHERE condition to the query.
      */
-    whereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    whereNot<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    whereNot(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
-    whereNot(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    whereNot(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    whereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    whereNot(column: SelectableColumn$1<string>, value: BaseValues): this;
     /**
      * @description Adds a negated AND WHERE condition to the query.
      */
-    andWhereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhereNot<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
-    andWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    andWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    andWhereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    andWhereNot(column: SelectableColumn$1<string>, value: BaseValues): this;
     /**
      * @description Adds a negated OR WHERE condition to the query.
      */
-    orWhereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhereNot<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
-    orWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    orWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    orWhereNot(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    orWhereNot(column: SelectableColumn$1<string>, value: BaseValues): this;
     /**
      * @description Adds a WHERE BETWEEN condition to the query.
      */
-    whereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    whereBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
+    whereBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
     /**
      * @description Adds an AND WHERE BETWEEN condition to the query.
      */
-    andWhereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    andWhereBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
+    andWhereBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
     /**
      * @description Adds an OR WHERE BETWEEN condition to the query.
      */
-    orWhereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    orWhereBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
+    orWhereBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
     /**
      * @description Adds a WHERE NOT BETWEEN condition to the query.
      */
-    whereNotBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    whereNotBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
+    whereNotBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
     /**
      * @description Adds an AND WHERE NOT BETWEEN condition to the query.
      */
-    andWhereNotBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    andWhereNotBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
+    andWhereNotBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
     /**
      * @description Adds an OR WHERE NOT BETWEEN condition to the query.
-     */
-    orWhereNotBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    orWhereNotBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
+     */
+    orWhereNotBetween(column: SelectableColumn$1<string>, min: BaseValues, max: BaseValues): this;
     /**
      * @description Adds a WHERE LIKE condition to the query.
      */
-    whereLike(column: ModelKey<T>, value: string): this;
-    whereLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    whereLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE LIKE condition to the query.
      */
-    andWhereLike(column: ModelKey<T>, value: string): this;
-    andWhereLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    andWhereLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE LIKE condition to the query.
      */
-    orWhereLike(column: ModelKey<T>, value: string): this;
-    orWhereLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    orWhereLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE ILIKE condition to the query.
      */
-    whereILike(column: ModelKey<T>, value: string): this;
-    whereILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    whereILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE ILIKE condition to the query.
      */
-    andWhereILike(column: ModelKey<T>, value: string): this;
-    andWhereILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    andWhereILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE ILIKE condition to the query.
      */
-    orWhereILike(column: ModelKey<T>, value: string): this;
-    orWhereILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    orWhereILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE NOT LIKE condition to the query.
      */
-    whereNotLike(column: ModelKey<T>, value: string): this;
-    whereNotLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    whereNotLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE NOT LIKE condition to the query.
      */
-    andWhereNotLike(column: ModelKey<T>, value: string): this;
-    andWhereNotLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    andWhereNotLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE NOT LIKE condition to the query.
      */
-    orWhereNotLike(column: ModelKey<T>, value: string): this;
-    orWhereNotLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    orWhereNotLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE NOT ILIKE condition to the query.
      */
-    whereNotILike(column: ModelKey<T>, value: string): this;
-    whereNotILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    whereNotILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE NOT ILIKE condition to the query.
      */
-    andWhereNotILike(column: ModelKey<T>, value: string): this;
-    andWhereNotILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    andWhereNotILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE NOT ILIKE condition to the query.
      */
-    orWhereNotILike(column: ModelKey<T>, value: string): this;
-    orWhereNotILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
+    orWhereNotILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE IN condition to the query.
-     * @warning If the array is empty, it will add an impossible condition.
      */
-    whereIn(column: ModelKey<T>, values: BaseValues[]): this;
-    whereIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    whereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds an AND WHERE IN condition to the query.
-     * @warning If the array is empty, it will add an impossible condition.
      */
-    andWhereIn(column: ModelKey<T>, values: BaseValues[]): this;
-    andWhereIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    andWhereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds an OR WHERE IN condition to the query.
-     * @warning If the array is empty, it will add an impossible condition.
      */
-    orWhereIn(column: ModelKey<T>, values: BaseValues[]): this;
-    orWhereIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    orWhereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @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(column: ModelKey<T>, values: BaseValues[]): this;
-    whereNotIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    whereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
-     * @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.
+     * @description Adds an AND WHERE NOT IN condition to the query.
      */
-    andWhereNotIn(column: ModelKey<T>, values: BaseValues[]): this;
-    andWhereNotIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    andWhereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @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(column: ModelKey<T>, values: BaseValues[]): this;
-    orWhereNotIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    orWhereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds a WHERE NULL condition to the query.
      */
-    whereNull(column: ModelKey<T>): this;
-    whereNull<S extends string>(column: SelectableColumn$1<S>): this;
+    whereNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an AND WHERE NULL condition to the query.
      */
-    andWhereNull(column: ModelKey<T>): this;
-    andWhereNull<S extends string>(column: SelectableColumn$1<S>): this;
+    andWhereNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an OR WHERE NULL condition to the query.
      */
-    orWhereNull(column: ModelKey<T>): this;
-    orWhereNull<S extends string>(column: SelectableColumn$1<S>): this;
+    orWhereNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds a WHERE NOT NULL condition to the query.
      */
-    whereNotNull(column: ModelKey<T>): this;
-    whereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
+    whereNotNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an AND WHERE NOT NULL condition to the query.
      */
-    andWhereNotNull(column: ModelKey<T>): this;
-    andWhereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
+    andWhereNotNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an OR WHERE NOT NULL condition to the query.
      */
-    orWhereNotNull(column: ModelKey<T>): this;
-    orWhereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
+    orWhereNotNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds a WHERE REGEXP condition to the query.
-     * @mssql doesn't support REGEXP syntax
-     * @sqlite doesn't support REGEXP syntax
      */
-    whereRegexp(column: ModelKey<T>, regexp: RegExp): this;
-    whereRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
+    whereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an AND WHERE REGEXP condition to the query.
-     * @mssql doesn't support REGEXP syntax
-     * @sqlite doesn't support REGEXP syntax
      */
-    andWhereRegexp(column: ModelKey<T>, regexp: RegExp): this;
-    andWhereRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
+    andWhereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an OR WHERE REGEXP condition to the query.
-     * @mssql doesn't support REGEXP syntax
-     * @sqlite doesn't support REGEXP syntax
      */
-    orWhereRegexp(column: ModelKey<T>, regexp: RegExp): this;
-    orWhereRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
+    orWhereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds a WHERE NOT REGEXP condition to the query.
-     * @mssql doesn't support REGEXP syntax
-     * @sqlite doesn't support REGEXP syntax
      */
-    whereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
-    whereNotRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
+    whereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an AND WHERE NOT REGEXP condition to the query.
-     * @mssql doesn't support REGEXP syntax
-     * @sqlite doesn't support REGEXP syntax
      */
-    andWhereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
-    andWhereNotRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
+    andWhereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an OR WHERE NOT REGEXP condition to the query.
-     * @mssql doesn't support REGEXP syntax
-     * @sqlite doesn't support REGEXP syntax
      */
-    orWhereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
-    orWhereNotRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
+    orWhereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
-     * @description Adds a AND WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     * @description Adds a WHERE group condition with AND.
      */
-    whereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    whereGroup(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
     /**
-     * @description Adds a AND WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     * @description Adds a WHERE group condition with AND.
      */
-    andWhereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    andWhereGroup(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
     /**
-     * @description Adds a OR WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     * @description Adds a WHERE group condition with OR.
      */
-    orWhereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    orWhereGroup(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
     /**
-     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     * @description Adds a raw WHERE condition to the query.
      */
-    whereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    whereRaw(sql: string, bindings?: BaseValues[]): this;
     /**
-     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     * @description Adds an AND raw WHERE condition to the query.
      */
-    andWhereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    andWhereRaw(sql: string, bindings?: BaseValues[]): this;
     /**
-     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     * @description Adds an OR raw WHERE condition to the query.
      */
-    orWhereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    orWhereRaw(sql: string, bindings?: BaseValues[]): this;
+}
+
+/**
+ * @description Callback type for join conditions
+ */
+type JoinOnCallback = (query: JoinOnQueryBuilder) => void;
+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);
     /**
-     * @description Adds a raw WHERE condition to the query.
+     * @description Clear the join query
      */
-    whereRaw(query: string, queryParams?: any[]): this;
+    clearJoin(): this;
     /**
-     * @description Adds a raw AND WHERE condition to the query.
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    joinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    leftJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    rightJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    fullJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    crossJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    naturalJoinRaw(query: string): this;
+    /**
+     * @alias join
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
+     * @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(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
+    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
+    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType): this;
+    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType): this;
+    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
+    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, callback: JoinOnCallback): this;
+    /**
+     * @description Join a table with the current model
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
+     * @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(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
+    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
+    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType): this;
+    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType): this;
+    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
+    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, callback: JoinOnCallback): this;
+    /**
+     * @description Join a table with the current model
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
+     * @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(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
+    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
+    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType): this;
+    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType): this;
+    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
+    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, callback: JoinOnCallback): this;
+    /**
+     * @description Join a table with the current model
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table
+     * @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(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
+    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
+    rightJoin<R extends typeof Model>(relationTable: string | R, referencingColumnOrPrimaryColumn: ModelKey<InstanceType<R>> | JoinableColumn | ModelKey<T>, primaryColumn?: JoinableColumn | ModelKey<T>, operator?: BinaryOperatorType): this;
+    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
+    /**
+     * @description Perform a FULL OUTER JOIN with another table
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table
+     * @param primaryColumn - The primary column of the current model
+     * @param operator - The comparison operator to use in the ON clause (default: "=")
+     */
+    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType): this;
+    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType): this;
+    fullJoin<R extends typeof Model>(relationTable: string | R, referencingColumnOrPrimaryColumn: ModelKey<InstanceType<R>> | JoinableColumn | ModelKey<T>, primaryColumn?: JoinableColumn | ModelKey<T>, operator?: BinaryOperatorType): this;
+    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator: BinaryOperatorType, callback: JoinOnCallback): this;
+    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
+}
+
+declare class SelectQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends JoinQueryBuilder<T, S> {
+    protected dbType: SqlDataSourceType;
+    protected modelSelectedColumns: string[];
+    protected withQuery?: string;
+    protected fromNode: FromNode;
+    protected distinctNode: DistinctNode | null;
+    protected distinctOnNode: DistinctOnNode | null;
+    protected selectNodes: SelectNode[];
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Adds a SELECT condition to the query.
+     * @description Can be stacked multiple times
+     * @description Supports: "column", "table.column", "*", "table.*", or [column, alias] tuples
+     * @example
+     * .select("id", "name")                           // Simple columns
+     * .select(["id", "userId"], ["name", "userName"]) // Columns with aliases
+     * .select("id", ["name", "userName"])             // Mixed
      */
-    andWhereRaw(query: string, queryParams?: any[]): this;
+    select<C extends string>(...columns: (SelectableColumn$1<C> | Selectable)[]): this;
+    select(...columns: (ModelKey<T> | "*" | Selectable)[]): this;
     /**
-     * @description Adds a raw OR WHERE condition to the query.
+     * @description Adds a raw SELECT statement to the query
      */
-    orWhereRaw(query: string, queryParams?: any[]): this;
+    selectRaw(statement: string): this;
     /**
-     * @description Adds a HAVING condition to the query.
+     * @description Selects a SQL function applied to a column with a typed alias.
+     * @description Provides intellisense for common SQL functions while accepting any custom function.
+     * @param func The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
+     * @param column The column to apply the function to (use "*" for count(*))
+     * @param alias The alias for the result
+     * @example
+     * .selectFunc("count", "*", "total")
+     * .selectFunc("upper", "name", "upperName")
+     * .selectFunc("custom_fn", "column", "result")
      */
-    having<S extends string>(column: SelectableColumn$1<S>, value: any): this;
-    having(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
+    selectFunc<A extends string>(sqlFunc: SqlFunction, column: string, alias: A): this;
     /**
-     * @description Adds an AND HAVING condition to the query.
+     * @description Clears the SELECT clause
      */
-    andHaving<S extends string>(column: SelectableColumn$1<S>, value: any): this;
-    andHaving(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
+    clearSelect(): this;
     /**
-     * @description Adds an OR HAVING condition to the query.
+     * @description Clears the FROM clause
      */
-    orHaving<S extends string>(column: SelectableColumn$1<S>, value: any): this;
-    orHaving(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
+    clearFrom(): this;
     /**
-     * @description Adds a raw HAVING condition to the query.
+     * @description Clears the DISTINCT clause
      */
-    havingRaw(query: string): this;
+    clearDistinct(): this;
     /**
-     * @description Adds a raw OR HAVING condition to the query.
+     * @description Clears the DISTINCT ON clause
      */
-    andHavingRaw(query: string): this;
+    clearDistinctOn(): this;
     /**
-     * @description Adds a raw OR HAVING condition to the query.
+     * @description Sets the table to select from, by default is the table defined in the Model
      */
-    orHavingRaw(query: string): this;
-    private buildSubQuery;
-    private andWhereSubQuery;
-    private orWhereSubQuery;
-    private andWhereGroup;
-    private orWhereGroup;
-}
-
-type JsonParam = Record<string, unknown> | any[];
-declare class JsonQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends WhereQueryBuilder<T, S> {
+    from<F extends string>(table: TableFormat<F>): this;
     /**
-     * @description Filters records matching exact JSON value.
+     * @description Sets the table to select from, by default is the table defined in the Model
+     * @alias from
      */
-    whereJson(column: ModelKey<T>, value: JsonParam): this;
-    whereJson(column: string, value: JsonParam): this;
+    table(table: string): this;
     /**
-     * @description Filters records matching the given JSON value.
-     * @mssql Partial JSON matching not supported - only exact matches work
+     * @description Adds a DISTINCT clause to the query
      */
-    andWhereJson(column: ModelKey<T>, value: JsonParam): this;
-    andWhereJson(column: string, value: JsonParam): this;
+    distinct(): this;
     /**
-     * @description Filters records matching the given JSON value.
-     * @mssql Partial JSON matching not supported - only exact matches work
+     * @description Adds a DISTINCT ON clause to the query
+     * @postgresql Only usable with PostgreSQL
      */
-    orWhereJson(column: ModelKey<T>, value: JsonParam): this;
-    orWhereJson(column: string, value: JsonParam): this;
+    distinctOn(...columns: ModelKey<T>[]): this;
+    distinctOn<C extends string>(...columns: SelectableColumn$1<C>[]): this;
     /**
-     * @description Filters records where JSON column does NOT contain the given value.
-     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
-     * @mssql not supported - CHARINDEX cannot do partial JSON containment
+     * @description Selects a JSON value at the specified path and returns it as JSON
      */
-    whereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
-    whereJsonNotContains(column: string, value: JsonParam): this;
+    selectJson<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
+    selectJson<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
-     * @description Filters records where JSON column does NOT contain the given value (AND).
-     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
-     * @mssql not supported - CHARINDEX cannot do partial JSON containment
+     * @description Selects a JSON value at the specified path and returns it as text
      */
-    andWhereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
-    andWhereJsonNotContains(column: string, value: JsonParam): this;
+    selectJsonText<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
+    selectJsonText<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
-     * @description Filters records where JSON column does NOT contain the given value (OR).
-     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
-     * @mssql not supported - CHARINDEX cannot do partial JSON containment
+     * @description Selects the length of a JSON array
      */
-    orWhereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
-    orWhereJsonNotContains(column: string, value: JsonParam): this;
+    selectJsonArrayLength<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
+    selectJsonArrayLength<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
-     * @description Filters records where JSON column contains the given value.
-     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
-     * @mssql not supported - CHARINDEX cannot do partial JSON containment
+     * @description Selects the keys of a JSON object
      */
-    whereJsonContains(column: ModelKey<T>, value: JsonParam): this;
-    whereJsonContains(column: string, value: JsonParam): this;
+    selectJsonKeys<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
+    selectJsonKeys<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
-     * @description Filters records where JSON column contains the given value (AND).
-     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
-     * @mssql not supported - CHARINDEX cannot do partial JSON containment
+     * @description Adds a raw JSON select expression
      */
-    andWhereJsonContains(column: ModelKey<T>, value: JsonParam): this;
-    andWhereJsonContains(column: string, value: JsonParam): this;
+    selectJsonRaw<A extends string>(raw: string, alias: A): this;
+}
+
+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[];
+    protected isNestedCondition: boolean;
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
+    clearWhere(): this;
+    clearHaving(): this;
     /**
-     * @description Filters records where JSON column contains the given value (OR).
-     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
-     * @mssql not supported - CHARINDEX cannot do partial JSON containment
+     * @description Accepts a value and executes a callback only of the value is not null or undefined.
+     * @warning The value is not checked for truthiness but existence, it is only checked for undefined or null. So false, 0, "", etc. will be considered truthy.
      */
-    orWhereJsonContains(column: ModelKey<T>, value: JsonParam): this;
-    orWhereJsonContains(column: string, value: JsonParam): this;
+    strictWhen(value: any, cb: (query: this) => void): this;
     /**
-     * @description Filters records where JSON column does NOT match the given value.
+     * @description Accepts a value and executes a callback only of the value is not falsy.
+     * @warning The value is checked for truthiness, so false, 0, "", etc. will be considered falsy. Use strictWhen for null or undefined only cases.
      */
-    whereNotJson(column: ModelKey<T>, value: JsonParam): this;
-    whereNotJson(column: string, value: JsonParam): this;
+    when(value: any, cb: (query: this) => void): this;
     /**
-     * @description Filters records where JSON column does NOT match the given value (AND).
+     * @description Adds a WHERE condition to the query.
      */
-    andWhereNotJson(column: ModelKey<T>, value: JsonParam): this;
-    andWhereNotJson(column: string, value: JsonParam): this;
+    where(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
+    where<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
+    where(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    where(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    where(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    where(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
     /**
-     * @description Filters records where JSON column does NOT match the given value (OR).
+     * @description Adds an AND WHERE condition to the query.
      */
-    orWhereNotJson(column: ModelKey<T>, value: JsonParam): this;
-    orWhereNotJson(column: string, value: JsonParam): this;
+    andWhere(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
+    andWhere(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    andWhere(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
+    andWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    andWhere(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    andWhere(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
     /**
-     * @description Add a raw JSON filter expression.
+     * @description Adds an OR WHERE condition to the query.
      */
-    whereJsonRaw(raw: string, params?: any[]): this;
+    orWhere(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
+    orWhere<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
+    orWhere<S extends string>(column: ModelKey<T> | SelectableColumn$1<S>, value: BaseValues): this;
+    orWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    orWhere(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    orWhere(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
     /**
-     * @description Add a raw JSON filter expression (AND).
+     * @description Adds a negated WHERE condition to the query.
      */
-    andWhereJsonRaw(raw: string, params?: any[]): this;
+    whereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
+    whereNot<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
+    whereNot(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
+    whereNot(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    whereNot(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
     /**
-     * @description Add a raw JSON filter expression (OR).
+     * @description Adds a negated AND WHERE condition to the query.
      */
-    orWhereJsonRaw(raw: string, params?: any[]): this;
-}
-
-declare class QueryBuilder<T extends Model = any, S extends Record<string, any> = Record<string, any>> extends JsonQueryBuilder<T, S> {
-    model: typeof Model;
-    protected astParser: AstParser;
-    protected unionNodes: UnionNode[];
-    protected withNodes: WithNode[];
-    protected lockQueryNodes: LockNode[];
-    protected isNestedCondition: boolean;
-    protected interpreterUtils: InterpreterUtils;
-    protected insertNode: InsertNode | null;
-    protected onDuplicateNode: OnDuplicateNode | null;
-    protected updateNode: UpdateNode | null;
-    protected deleteNode: DeleteNode | null;
-    protected truncateNode: TruncateNode | null;
-    protected replicationMode: ReplicationType | null;
+    andWhereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
+    andWhereNot<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
+    andWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
+    andWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    andWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
     /**
-     * @description Performance methods that return the time that took to execute the query with the result
-     */
-    performance: {
-        many: (returnType?: "millis" | "seconds") => Promise<{
-            data: S[];
-            time: number;
-        }>;
-        one: (returnType?: "millis" | "seconds") => Promise<{
-            data: S | null;
-            time: number;
-        }>;
-        oneOrFail: (returnType?: "millis" | "seconds") => Promise<{
-            data: S;
-            time: number;
-        }>;
-        paginate: (page: number, perPage: number, returnType?: "millis" | "seconds") => Promise<{
-            data: RawPaginatedData<S>;
-            time: number;
-        }>;
-        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
-            data: [RawCursorPaginatedData<S>, Cursor<T, ModelKey<T>>];
-            time: number;
-        }>;
-        exists: (returnType?: "millis" | "seconds") => Promise<{
-            data: boolean;
-            time: number;
-        }>;
-        truncate: (returnType?: "millis" | "seconds") => Promise<{
-            data: void;
-            time: number;
-        }>;
-        delete: (returnType?: "millis" | "seconds") => Promise<{
-            data: number;
-            time: number;
-        }>;
-        insert: (data: Record<string, any>, returnType?: "millis" | "seconds") => Promise<{
-            data: T;
-            time: number;
-        }>;
-        insertMany: (data: Record<string, any>[], returnType?: "millis" | "seconds") => Promise<{
-            data: T[];
-            time: number;
-        }>;
-        update: (data: Record<string, any>, returnType?: "millis" | "seconds") => Promise<{
-            data: number;
-            time: number;
-        }>;
-        softDelete: (options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">, returnType?: "millis" | "seconds") => Promise<{
-            data: number;
-            time: number;
-        }>;
-        pluck: (key: ModelKey<T>, returnType?: "millis" | "seconds") => Promise<{
-            data: PluckReturnType<T, ModelKey<T>>;
-            time: number;
-        }>;
-    };
-    constructor(model: typeof Model, sqlDataSource?: SqlDataSource);
+     * @description Adds a negated OR WHERE condition to the query.
+     */
+    orWhereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
+    orWhereNot<S extends string>(column: SelectableColumn$1<S>, operator: BinaryOperatorType, value: BaseValues): this;
+    orWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, value: BaseValues): this;
+    orWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    orWhereNot(column: ModelKey<T> | SelectableColumn$1<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
     /**
-     * @description Sets the replication mode for the query builder
-     * @param replicationMode - The replication mode to use for the query builder
-     * @description If not specified, read operations will use slave (if available) else master, and write operations will always use master
-     * @description If set to "master", all operations will use master
-     * @description If set to "slave", read operations will use slave and write operations will use master
+     * @description Adds a WHERE BETWEEN condition to the query.
      */
-    setReplicationMode(replicationMode: ReplicationType): this;
+    whereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
+    whereBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
     /**
-     * @description Adds a SELECT condition to the query with type safety.
-     * @description Can be stacked multiple times
-     * @description Supports: "column", "table.column", "*", "table.*", or [column, alias] tuples
-     * @example
-     * ```ts
-     * const user = await sql.query("users").select("name", "age").one();
-     * // user type: { name: any, age: any } | null
-     *
-     * const user = await sql.query("users").select(["name", "userName"]).one();
-     * // user type: { userName: any } | null
-     * ```
+     * @description Adds an AND WHERE BETWEEN condition to the query.
      */
-    select<const Columns extends readonly Selectable[]>(...columns: Columns): QueryBuilder<T, ComposeBuildRawSelect<S, Columns>>;
+    andWhereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
+    andWhereBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
     /**
-     * @description Adds a raw SELECT statement to the query with type safety.
-     * @description Use the generic parameter to specify the type of the selected columns.
-     * @example
-     * ```ts
-     * const result = await sql.query("users")
-     *   .selectRaw<{ total: number }>("count(*) as total")
-     *   .one();
-     * // result type: { total: number } | null
-     * ```
+     * @description Adds an OR WHERE BETWEEN condition to the query.
      */
-    selectRaw<Added extends Record<string, any> = Record<string, any>>(statement: string): QueryBuilder<T, ComposeRawSelect<S, Added>>;
+    orWhereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
+    orWhereBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
     /**
-     * @description Clears the SELECT clause and resets type to default
+     * @description Adds a WHERE NOT BETWEEN condition to the query.
      */
-    clearSelect(): QueryBuilder<T, Record<string, any>>;
+    whereNotBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
+    whereNotBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
     /**
-     * @description Selects a SQL function applied to a column with a typed alias.
-     * @description Provides intellisense for common SQL functions while accepting any custom function.
-     * @description Return type is auto-inferred based on function name (number for count/sum/avg, string for upper/lower/trim, etc.)
-     * @param sqlFunc The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
-     * @param column The column to apply the function to (use "*" for count(*))
-     * @param alias The alias for the result
-     * @example
-     * ```ts
-     * const result = await sql.query("users")
-     *   .selectFunc("count", "*", "total")
-     *   .one();
-     * // result type: { total: number } | null - auto-inferred!
-     * ```
+     * @description Adds an AND WHERE NOT BETWEEN condition to the query.
      */
-    selectFunc<F extends SqlFunction, Alias extends string>(sqlFunc: F, column: string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: SqlFunctionReturnType<F>;
-    }>>;
+    andWhereNotBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
+    andWhereNotBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
     /**
-     * @description Selects a subquery, subquery must return a single column
+     * @description Adds an OR WHERE NOT BETWEEN condition to the query.
      */
-    selectSubQuery<ValueType = any, Alias extends string = string>(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: ValueType;
-    }>>;
-    selectJson<ValueType = any, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: ValueType;
-    }>>;
-    selectJsonText<ValueType = string, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: ValueType;
-    }>>;
-    selectJsonArrayLength<Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: number;
-    }>>;
-    selectJsonKeys<Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: string[];
-    }>>;
-    selectJsonRaw<ValueType = any, Alias extends string = string>(raw: string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
-        [K in Alias]: ValueType;
-    }>>;
+    orWhereNotBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
+    orWhereNotBetween<S extends string>(column: SelectableColumn$1<S>, min: BaseValues, max: BaseValues): this;
     /**
-     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
+     * @description Adds a WHERE LIKE condition to the query.
      */
-    exists(): Promise<boolean>;
+    whereLike(column: ModelKey<T>, value: string): this;
+    whereLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Executes the query and retrieves multiple results.
+     * @description Adds an AND WHERE LIKE condition to the query.
      */
-    many(): Promise<S[]>;
+    andWhereLike(column: ModelKey<T>, value: string): this;
+    andWhereLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Executes the query and retrieves a single column from the results.
-     * @param key - The column to retrieve from the results, must be a Model Column
+     * @description Adds an OR WHERE LIKE condition to the query.
      */
-    pluck<K extends ModelKey<T>>(key: K): Promise<PluckReturnType<T, K>>;
+    orWhereLike(column: ModelKey<T>, value: string): this;
+    orWhereLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Executes the query and retrieves a single result.
+     * @description Adds a WHERE ILIKE condition to the query.
      */
-    one(): Promise<S | null>;
+    whereILike(column: ModelKey<T>, value: string): this;
+    whereILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Executes the query and retrieves the first result. Fail if no result is found.
+     * @description Adds an AND WHERE ILIKE condition to the query.
      */
-    oneOrFail(): Promise<S>;
+    andWhereILike(column: ModelKey<T>, value: string): this;
+    andWhereILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Executes the query and returns a node readable stream.
-     * @description If used by a model query builder, it will serialize the models and apply the hooks and relations.
-     * @postgres needs the pg-query-stream package in order to work
-     * @throws If using postgres and the `pg-query-stream` package is not installed
+     * @description Adds an OR WHERE ILIKE condition to the query.
      */
-    stream<M = S>(options?: StreamOptions): Promise<PassThrough & AsyncGenerator<M>>;
+    orWhereILike(column: ModelKey<T>, value: string): this;
+    orWhereILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Chunks the query into smaller queries, it returns a generator of the chunks
-     * @description It will continue to yield chunks until the query returns no results
-     * @description Useful for large queries that need to be processed in chunks
-     * @warning overrides limit and offset set before in the query builder
-     * @param chunkSize - The size of the chunk
-     * @returns a generator of the chunks
-     * @example
-     * const chunks = await queryBuilder.chunk(100);
-     * // first chunk
-     * const firstChunk = await chunks.next();
-     * console.log(firstChunk.value);
-     * // second chunk
-     * const secondChunk = await chunks.next();
-     * console.log(secondChunk.value);
-     * // third chunk
-     * const thirdChunk = await chunks.next();
-     * console.log(thirdChunk.value);
-     *
-     * @example
-     * const chunkSize = 3;
-     * const chunks = [];
-     * const query = sql.query("users").orderBy("name", "asc");
-     * for await (const chunk of sql.chunk(chunkSize)) {
-     *   chunks.push(chunk);
-     * }
-     *
-     * console.log(chunks);
+     * @description Adds a WHERE NOT LIKE condition to the query.
      */
-    chunk(chunkSize: number): AsyncGenerator<S[], void, unknown>;
+    whereNotLike(column: ModelKey<T>, value: string): this;
+    whereNotLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Executes the query and retrieves multiple paginated results.
-     * @description Overrides the limit and offset clauses in order to paginate the results.
-     * @description Allows to avoid offset clause that can be inefficient for large datasets
-     * @description If using a model query builder, primary key is used as discriminator by default
-     * @param options - The options for the paginate with cursor
-     * @param options.discriminator - The discriminator to use for the paginate with Cursor pagination
-     * @param options.operator - The operator to use for the paginate with Cursor pagination
-     * @param options.orderBy - The order by to use for the paginate with Cursor pagination
-     * @param cursor - The cursor to use for the paginate with Cursor pagination
-     * @warning If no order by clause is present in the query, the query will add an order by clause to the query `orderBy(discriminator, "asc")`
-     * @returns the pagination metadata and the cursor for the next page
+     * @description Adds an AND WHERE NOT LIKE condition to the query.
      */
-    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[RawCursorPaginatedData<S>, Cursor<T, K>]>;
+    andWhereNotLike(column: ModelKey<T>, value: string): this;
+    andWhereNotLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Locks the table for update
-     * @param skipLocked - If true, the query will skip locked rows
-     * @sqlite does not support skipping locked rows, it will be ignored
+     * @description Adds an OR WHERE NOT LIKE condition to the query.
      */
-    lockForUpdate(options?: {
-        skipLocked?: boolean;
-        noWait?: boolean;
-    }): this;
+    orWhereNotLike(column: ModelKey<T>, value: string): this;
+    orWhereNotLike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Locks the table for share
-     * @param skipLocked - If true, the query will skip locked rows
-     * @sqlite does not support skipping locked rows, it will be ignored
+     * @description Adds a WHERE NOT ILIKE condition to the query.
      */
-    forShare(options?: {
-        skipLocked?: boolean;
-        noWait?: boolean;
-    }): this;
+    whereNotILike(column: ModelKey<T>, value: string): this;
+    whereNotILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Adds a UNION to the query.
+     * @description Adds an AND WHERE NOT ILIKE condition to the query.
      */
-    union(query: string, bindings?: any[]): this;
-    union(cb: UnionCallBack<T>): this;
+    andWhereNotILike(column: ModelKey<T>, value: string): this;
+    andWhereNotILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Adds a UNION ALL to the query.
+     * @description Adds an OR WHERE NOT ILIKE condition to the query.
      */
-    unionAll(query: string, bindings?: any[]): this;
-    unionAll(cb: UnionCallBack<T>): this;
-    unionAll(queryBuilder: QueryBuilder<any>): this;
+    orWhereNotILike(column: ModelKey<T>, value: string): this;
+    orWhereNotILike<S extends string>(column: SelectableColumn$1<S>, value: string): this;
     /**
-     * @description Increments the value of a column by a given amount
-     * @typeSafe - In typescript, only numeric columns of the model will be accepted if using a Model
-     * @default value + 1
-     * @returns the number of affected rows
+     * @description Adds a WHERE IN condition to the query.
+     * @warning If the array is empty, it will add an impossible condition.
      */
-    increment(column: string, value: number): Promise<number>;
-    increment(column: NumberModelKey<T>, value: number): Promise<number>;
+    whereIn(column: ModelKey<T>, values: BaseValues[]): this;
+    whereIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
     /**
-     * @description Decrements the value of a column by a given amount
-     * @typeSafe - In typescript, only numeric columns of the model will be accepted if using a Model
-     * @default value - 1
-     * @returns the number of affected rows
+     * @description Adds an AND WHERE IN condition to the query.
+     * @warning If the array is empty, it will add an impossible condition.
      */
-    decrement(column: string, value: number): Promise<number>;
-    decrement(column: NumberModelKey<T>, value: number): Promise<number>;
+    andWhereIn(column: ModelKey<T>, values: BaseValues[]): this;
+    andWhereIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
     /**
-     * @description Executes the query and retrieves the count of results, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     * @description Adds an OR WHERE IN condition to the query.
+     * @warning If the array is empty, it will add an impossible condition.
      */
-    getCount(column?: string): Promise<number>;
+    orWhereIn(column: ModelKey<T>, values: BaseValues[]): this;
+    orWhereIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
     /**
-     * @description Executes the query and retrieves the maximum value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     * @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.
      */
-    getMax(column: string): Promise<number>;
+    whereNotIn(column: ModelKey<T>, values: BaseValues[]): this;
+    whereNotIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    /**
+     * @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(column: ModelKey<T>, values: BaseValues[]): this;
+    andWhereNotIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    /**
+     * @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(column: ModelKey<T>, values: BaseValues[]): this;
+    orWhereNotIn<S extends string>(column: SelectableColumn$1<S>, values: BaseValues[]): this;
+    /**
+     * @description Adds a WHERE NULL condition to the query.
+     */
+    whereNull(column: ModelKey<T>): this;
+    whereNull<S extends string>(column: SelectableColumn$1<S>): this;
+    /**
+     * @description Adds an AND WHERE NULL condition to the query.
+     */
+    andWhereNull(column: ModelKey<T>): this;
+    andWhereNull<S extends string>(column: SelectableColumn$1<S>): this;
+    /**
+     * @description Adds an OR WHERE NULL condition to the query.
+     */
+    orWhereNull(column: ModelKey<T>): this;
+    orWhereNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
-     * @description Executes the query and retrieves the minimum value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     * @description Adds a WHERE NOT NULL condition to the query.
      */
-    getMin(column: string): Promise<number>;
+    whereNotNull(column: ModelKey<T>): this;
+    whereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
-     * @description Executes the query and retrieves the average value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     * @description Adds an AND WHERE NOT NULL condition to the query.
      */
-    getAvg(column: string): Promise<number>;
+    andWhereNotNull(column: ModelKey<T>): this;
+    andWhereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
-     * @description Executes the query and retrieves the sum of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     * @description Adds an OR WHERE NOT NULL condition to the query.
      */
-    getSum(column: string): Promise<number>;
+    orWhereNotNull(column: ModelKey<T>): this;
+    orWhereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
-     * @description Executes the query and retrieves multiple paginated results.
-     * @description Overrides the limit and offset clauses in order to paginate the results.
+     * @description Adds a WHERE REGEXP condition to the query.
+     * @mssql doesn't support REGEXP syntax
+     * @sqlite doesn't support REGEXP syntax
      */
-    paginate(page: number, perPage: number): Promise<RawPaginatedData<S>>;
+    whereRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    whereRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
     /**
-     * @description Overrides the from clause in the query.
+     * @description Adds an AND WHERE REGEXP condition to the query.
+     * @mssql doesn't support REGEXP syntax
+     * @sqlite doesn't support REGEXP syntax
      */
-    from<S extends string>(table: TableFormat<S>, alias?: string): this;
-    from(cb: (qb: QueryBuilder<T>) => void, alias: string): this;
+    andWhereRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    andWhereRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
     /**
-     * @description Adds a CTE to the query using a callback to build the subquery.
+     * @description Adds an OR WHERE REGEXP condition to the query.
+     * @mssql doesn't support REGEXP syntax
+     * @sqlite doesn't support REGEXP syntax
      */
-    with(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    orWhereRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    orWhereRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
     /**
-     * @description Adds a recursive CTE to the query using a callback to build the subquery.
-     * @mssql not supported
+     * @description Adds a WHERE NOT REGEXP condition to the query.
+     * @mssql doesn't support REGEXP syntax
+     * @sqlite doesn't support REGEXP syntax
      */
-    withRecursive(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    whereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    whereNotRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): 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
+     * @description Adds an AND WHERE NOT REGEXP condition to the query.
+     * @mssql doesn't support REGEXP syntax
+     * @sqlite doesn't support REGEXP syntax
      */
-    withMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    andWhereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    andWhereNotRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
     /**
-     * @description Insert record into a table, you can use raw statements in the data object for literal references to other columns
-     * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
-     * @returns raw driver response
+     * @description Adds an OR WHERE NOT REGEXP condition to the query.
+     * @mssql doesn't support REGEXP syntax
+     * @sqlite doesn't support REGEXP syntax
      */
-    insert(data: Record<string, WriteQueryParam$1>, returning?: string[]): Promise<T>;
+    orWhereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    orWhereNotRegexp<S extends string>(column: SelectableColumn$1<S>, regexp: RegExp): this;
     /**
-     * @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 raw driver response
-     * @oracledb may do multiple inserts with auto-generated identity columns
+     * @description Adds a AND WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
      */
-    insertMany(data: Record<string, WriteQueryParam$1>[], returning?: string[]): Promise<T[]>;
+    whereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
     /**
-     * @description Updates or creates a new record using upsert functionality
-     * @param data The data to insert or update
-     * @param searchCriteria The criteria to search for existing records
-     * @param options Upsert options including updateOnConflict and returning columns
-     * @returns The upserted record
+     * @description Adds a AND WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
      */
-    upsert<O extends Record<string, any>>(data: O, searchCriteria: Partial<O>, options?: UpsertOptionsRawBuilder): Promise<T[]>;
+    andWhereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
     /**
-     * @description Updates or creates multiple records using upsert functionality
-     * @param conflictColumns The columns to check for conflicts
-     * @param columnsToUpdate The columns to update on conflict
-     * @param data Array of data objects to insert or update
-     * @param options Upsert options including updateOnConflict and returning columns
+     * @description Adds a OR WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
      */
-    upsertMany<O extends Record<string, any>>(conflictColumns: string[], columnsToUpdate: string[], data: O[], options?: UpsertOptionsRawBuilder): Promise<T[]>;
+    orWhereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
     /**
-     * @description Executes a MERGE statement for MSSQL upsert operations (raw query builder)
+     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
      */
-    private executeMssqlMergeRaw;
+    whereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
     /**
-     * @description Updates records from a table, you can use raw statements in the data object for literal references to other columns
-     * @returns the number of affected rows
+     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
      */
-    update(data: Record<string, WriteQueryParam$1>): Promise<number>;
+    andWhereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
     /**
-     * @description Deletes all records from a table
-     * @warning This operation does not trigger any hook
+     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
      */
-    truncate(): Promise<void>;
+    orWhereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
     /**
-     * @description Deletes records from a table
-     * @returns the number of affected rows
+     * @description Adds a raw WHERE condition to the query.
      */
-    delete(): Promise<number>;
+    whereRaw(query: string, queryParams?: any[]): this;
     /**
-     * @description Soft deletes records from a table
-     * @default column - 'deletedAt'
-     * @default value - The current date and time in UTC timezone in the format "YYYY-MM-DD HH:mm:ss"
-     * @returns the number of affected rows
+     * @description Adds a raw AND WHERE condition to the query.
      */
-    softDelete(options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">): Promise<number>;
+    andWhereRaw(query: string, queryParams?: any[]): this;
     /**
-     * @description Returns the query with the parameters bound to the query
+     * @description Adds a raw OR WHERE condition to the query.
      */
-    toQuery(): string;
+    orWhereRaw(query: string, queryParams?: any[]): this;
     /**
-     * @description Returns the query with database driver placeholders and the params
+     * @description Adds a HAVING condition to the query.
      */
-    unWrap(): ReturnType<typeof AstParser.prototype.parse>;
+    having<S extends string>(column: SelectableColumn$1<S>, value: any): this;
+    having(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
     /**
-     * @description Returns a deep clone of the query builder instance.
+     * @description Adds an AND HAVING condition to the query.
      */
-    clone(): QueryBuilder<T, S>;
+    andHaving<S extends string>(column: SelectableColumn$1<S>, value: any): this;
+    andHaving(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
     /**
-     * @description Gives a fresh instance of the query builder
+     * @description Adds an OR HAVING condition to the query.
      */
-    clear(): QueryBuilder<T, Record<string, any>>;
+    orHaving<S extends string>(column: SelectableColumn$1<S>, value: any): this;
+    orHaving(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
     /**
-     * @description Removes the lock query
+     * @description Adds a raw HAVING condition to the query.
      */
-    clearLockQuery(): this;
+    havingRaw(query: string): this;
     /**
-     * @description Removes any union query
+     * @description Adds a raw OR HAVING condition to the query.
      */
-    clearUnionQuery(): this;
+    andHavingRaw(query: string): this;
     /**
-     * @description Removes any with query
+     * @description Adds a raw OR HAVING condition to the query.
      */
-    clearWithQuery(): this;
-    extractQueryNodes(): QueryNode[];
-    protected clearForFunctions(): this;
+    orHavingRaw(query: string): this;
+    private buildSubQuery;
+    private andWhereSubQuery;
+    private orWhereSubQuery;
+    private andWhereGroup;
+    private orWhereGroup;
+}
+
+type JsonParam = Record<string, unknown> | any[];
+declare class JsonQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends WhereQueryBuilder<T, S> {
     /**
-     * @description Makes a many query and returns the time that took to execute that query
+     * @description Filters records matching exact JSON value.
      */
-    private manyWithPerformance;
+    whereJson(column: ModelKey<T>, value: JsonParam): this;
+    whereJson(column: string, value: JsonParam): this;
     /**
-     * @description Makes a one query and returns the time that took to execute that query
+     * @description Filters records matching the given JSON value.
+     * @mssql Partial JSON matching not supported - only exact matches work
      */
-    private oneWithPerformance;
+    andWhereJson(column: ModelKey<T>, value: JsonParam): this;
+    andWhereJson(column: string, value: JsonParam): this;
     /**
-     * @alias oneOrFailWithPerformance
+     * @description Filters records matching the given JSON value.
+     * @mssql Partial JSON matching not supported - only exact matches work
      */
-    private firstOrFailWithPerformance;
-    private paginateWithPerformance;
-    private paginateWithCursorWithPerformance;
+    orWhereJson(column: ModelKey<T>, value: JsonParam): this;
+    orWhereJson(column: string, value: JsonParam): this;
     /**
-     * @description Makes a one or fail query and returns the time that took to execute that query
+     * @description Filters records where JSON column does NOT contain the given value.
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     * @mssql not supported - CHARINDEX cannot do partial JSON containment
      */
-    private oneOrFailWithPerformance;
+    whereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
+    whereJsonNotContains(column: string, value: JsonParam): this;
     /**
-     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
-     * @description Returns the time that took to execute the query
+     * @description Filters records where JSON column does NOT contain the given value (AND).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     * @mssql not supported - CHARINDEX cannot do partial JSON containment
      */
-    private existsWithPerformance;
-    private pluckWithPerformance;
-    private updateWithPerformance;
-    private insertWithPerformance;
-    private insertManyWithPerformance;
-    private softDeleteWithPerformance;
-    private deleteWithPerformance;
-    private truncateWithPerformance;
+    andWhereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
+    andWhereJsonNotContains(column: string, value: JsonParam): this;
     /**
-     * @description Checks if the current context is an MSSQL transaction
-     * @description MSSQL transactions can only handle one request at a time
+     * @description Filters records where JSON column does NOT contain the given value (OR).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     * @mssql not supported - CHARINDEX cannot do partial JSON containment
      */
-    protected isMssqlTransaction(): boolean;
+    orWhereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
+    orWhereJsonNotContains(column: string, value: JsonParam): this;
     /**
-     * @description Executes pagination queries, serializing them for MSSQL transactions
+     * @description Filters records where JSON column contains the given value.
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     * @mssql not supported - CHARINDEX cannot do partial JSON containment
      */
-    protected executePaginateQueries<M, C>(modelsQuery: () => Promise<M>, countQuery: () => Promise<C>): Promise<[M, C]>;
-    protected getSqlDataSource(mode: "read" | "write"): Promise<SqlDataSource>;
+    whereJsonContains(column: ModelKey<T>, value: JsonParam): this;
+    whereJsonContains(column: string, value: JsonParam): this;
     /**
-     * @description Executes SQL with slave failure handling
-     * @param mode The operation mode (read or write)
-     * @param operation The execSql operation to perform
-     * @returns The result of the operation
+     * @description Filters records where JSON column contains the given value (AND).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     * @mssql not supported - CHARINDEX cannot do partial JSON containment
      */
-    protected execSqlWithSlaveHandling<R>(mode: "read" | "write", operation: (dataSource: SqlDataSource) => Promise<R>): Promise<R>;
-}
-
-/**
- * Allows to get queries without executing them
- */
-declare class DryQueryBuilder<T extends Model = any, S extends Record<string, any> = Record<string, any>> extends QueryBuilder<T, S> {
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
-    many(): this;
+    andWhereJsonContains(column: ModelKey<T>, value: JsonParam): this;
+    andWhereJsonContains(column: string, value: JsonParam): this;
     /**
-     * @description Builds the insert query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param args The arguments to pass to the insert method
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Filters records where JSON column contains the given value (OR).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     * @mssql not supported - CHARINDEX cannot do partial JSON containment
      */
-    insert(...args: Parameters<typeof QueryBuilder.prototype.insert>): this;
+    orWhereJsonContains(column: ModelKey<T>, value: JsonParam): this;
+    orWhereJsonContains(column: string, value: JsonParam): this;
     /**
-     * @description Builds the insert many query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param args The arguments to pass to the insert many method
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Filters records where JSON column does NOT match the given value.
      */
-    insertMany(...args: Parameters<typeof QueryBuilder.prototype.insertMany>): this;
+    whereNotJson(column: ModelKey<T>, value: JsonParam): this;
+    whereNotJson(column: string, value: JsonParam): this;
     /**
-     * @description Builds the upsert query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param args The arguments to pass to the upsert method
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Filters records where JSON column does NOT match the given value (AND).
      */
-    upsert(...args: Parameters<typeof QueryBuilder.prototype.upsert>): this;
-    upsertMany(...args: Parameters<typeof QueryBuilder.prototype.upsertMany>): this;
+    andWhereNotJson(column: ModelKey<T>, value: JsonParam): this;
+    andWhereNotJson(column: string, value: JsonParam): this;
     /**
-     * @description Builds the update query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param data The data to update
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Filters records where JSON column does NOT match the given value (OR).
      */
-    update(data: Record<string, WriteQueryParam>): this;
+    orWhereNotJson(column: ModelKey<T>, value: JsonParam): this;
+    orWhereNotJson(column: string, value: JsonParam): this;
     /**
-     * @description Builds the delete query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Add a raw JSON filter expression.
      */
-    delete(): this;
+    whereJsonRaw(raw: string, params?: any[]): this;
     /**
-     * @description Builds the truncate query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Add a raw JSON filter expression (AND).
      */
-    truncate(): this;
+    andWhereJsonRaw(raw: string, params?: any[]): this;
     /**
-     * @description Builds the soft delete query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param options Soft delete options
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
+     * @description Add a raw JSON filter expression (OR).
      */
-    softDelete(options?: Omit<SoftDeleteOptions<any>, "ignoreBeforeDeleteHook">): this;
+    orWhereJsonRaw(raw: string, params?: any[]): this;
 }
 
 type PluckReturnType<T extends Model, K extends ModelKey<T>> = T[K] extends infer U ? U[] : never;
@@ -4168,9 +4150,7 @@ type UpsertOptionsRawBuilder = {
     updateOnConflict?: boolean;
     returning?: string[];
 };
-type DryQueryBuilderWithoutReadOperations = Omit<DryQueryBuilder, "many" | "one" | "oneOrFail" | "paginate" | "paginateWithCursor" | "exists" | "pluck" | "increment" | "decrement" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "stream" | "chunk" | "paginate" | "paginateWithCursor" | "exists">;
-type DryModelQueryBuilderWithoutReadOperations<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<DryModelQueryBuilder<T, A, R>, "many" | "one" | "oneOrFail" | "paginate" | "paginateWithCursor" | "exists" | "pluck" | "upsert" | "upsertMany" | "increment" | "decrement" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "stream" | "chunk" | "paginate" | "paginateWithCursor" | "exists">;
-type WriteQueryParam$1 = string | number | boolean | Date | RawNode | object | null | undefined;
+type WriteQueryParam = string | number | boolean | Date | RawNode | object | null | undefined;
 /**
  * Simple paginated data type for raw query builders (without Model constraint)
  */
@@ -4323,14 +4303,14 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     /**
      * @description Inserts a new record into the database, it is not advised to use this method directly from the query builder if using a ModelQueryBuilder (`Model.query()`), use the `Model.insert` method instead.
      */
-    insert(...args: Parameters<typeof this$1.model.insert<T>>): ReturnType<typeof this$1.model.insert>;
+    insert(...args: Parameters<typeof this$1.model.insert<T>>): Promise<ReturnType<typeof this$1.model.insert>>;
     /**
      * @description Inserts multiple records into the database, it is not advised to use this method directly from the query builder if using a ModelQueryBuilder (`Model.query()`), use the `Model.insertMany` method instead.
      */
-    insertMany(...args: Parameters<typeof this$1.model.insertMany<T>>): ReturnType<typeof this$1.model.insertMany>;
-    update(data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions): Promise<number>;
-    softDelete(options?: SoftDeleteOptions<T>): Promise<number>;
-    delete(options?: DeleteOptions): Promise<number>;
+    insertMany(...args: Parameters<typeof this$1.model.insertMany<T>>): Promise<ReturnType<typeof this$1.model.insertMany>>;
+    update(data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions): WriteOperation<number>;
+    softDelete(options?: SoftDeleteOptions<T>): WriteOperation<number>;
+    delete(options?: DeleteOptions): WriteOperation<number>;
     getCount(column?: string, options?: {
         ignoreHooks: boolean;
     }): Promise<number>;
@@ -4718,53 +4698,6 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     private truncateWithPerformance;
 }
 
-/**
- * Allows to get model queries without executing them
- */
-declare class DryModelQueryBuilder<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> extends ModelQueryBuilder<T, A, R> {
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
-    many(): this;
-    /**
-     * @description Builds the insert query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param args The arguments to pass to the insert method
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
-     */
-    insert(...args: Parameters<typeof this$1.model.insert<T>>): this;
-    /**
-     * @description Builds the insert many query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param args The arguments to pass to the insert many method
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
-     */
-    insertMany(...args: Parameters<typeof this$1.model.insertMany<T>>): this;
-    /**
-     * @description Builds the update query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param data The data to update
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
-     */
-    update(...args: Parameters<ReturnType<typeof this$1.model.query<T>>["update"]>): this;
-    /**
-     * @description Builds the delete query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param options Delete options
-     * @returns The query builder
-     */
-    delete(...args: Parameters<ReturnType<typeof this$1.model.query<T>>["delete"]>): this;
-    /**
-     * @description Builds the truncate query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @returns The query builder
-     */
-    truncate(): this;
-    /**
-     * @description Builds the soft delete query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
-     * @param options Soft delete options
-     * @warning This method does not run model or column hooks
-     * @returns The query builder
-     */
-    softDelete(...args: Parameters<ReturnType<typeof this$1.model.query<T>>["softDelete"]>): this;
-}
-
 declare class ModelManager<T extends Model> {
     protected sqlDataSource: SqlDataSource;
     protected sqlType: SqlDataSourceType;
@@ -4802,13 +4735,15 @@ declare class ModelManager<T extends Model> {
     findOneByPrimaryKey(value: string | number, returning?: ModelKey<T>[]): Promise<ModelWithoutRelations<T> | null>;
     /**
      * @description Creates a new record in the database
+     * @returns WriteOperation that executes when awaited
      */
-    insert(model: Partial<T>, options?: InsertOptions<T>): Promise<ModelWithoutRelations<T>>;
+    insert(model: Partial<T>, options?: InsertOptions<T>): WriteOperation<ModelWithoutRelations<T>>;
     /**
      * @description Creates multiple records in the database
+     * @returns WriteOperation that executes when awaited
      */
-    insertMany(models: Partial<T>[], options?: InsertOptions<T>): Promise<ModelWithoutRelations<T>[]>;
-    upsertMany(conflictColumns: string[], columnsToUpdate: string[], data: ModelWithoutRelations<T>[], options?: UpsertOptions<T>): Promise<ModelWithoutRelations<T>[]>;
+    insertMany(models: Partial<T>[], options?: InsertOptions<T>): WriteOperation<ModelWithoutRelations<T>[]>;
+    upsertMany(conflictColumns: string[], columnsToUpdate: string[], data: ModelWithoutRelations<T>[], options?: UpsertOptions<T>): WriteOperation<ModelWithoutRelations<T>[]>;
     /**
      * @description Executes a MERGE statement for MSSQL upsert operations
      */
@@ -4830,11 +4765,6 @@ declare class ModelManager<T extends Model> {
      * @description Returns a query builder instance
      */
     query(): Omit<ModelQueryBuilder<T>, "insert" | "insertMany">;
-    /**
-     * @description Returns a dry query builder instance
-     * @description The dry query builder instance will not execute the query, it will return the query statement
-     */
-    dryQuery(): Omit<DryModelQueryBuilder<T>, "insert" | "insertMany">;
     /**
      * @description Mysql does not return the inserted model, so we need to get the inserted model from the database
      */
@@ -5214,10 +5144,6 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
      * @param table The table name to query from
      */
     query<S extends string>(table: TableFormat<S>, options?: RawModelOptions): QueryBuilder;
-    /**
-     * @description Returns a DryQueryBuilder instance that returns the query statement without executing
-     */
-    dryQuery<S extends string>(table: TableFormat<S>, options?: RawModelOptions): DryQueryBuilderWithoutReadOperations;
     /**
      * @description Returns a SchemaBuilder instance for DDL operations
      * @description The builder will execute queries when awaited or when .execute() is called
@@ -6001,11 +5927,6 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
      * @description Gives a query sqlInstance for the given model
      */
     static query<T extends Model>(this: new () => T | typeof Model, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): ModelQueryBuilder<T>;
-    /**
-     * @description Returns a dry query builder instance
-     * @description The dry query builder instance will not execute the query
-     */
-    static dryQuery<T extends Model>(this: new () => T | typeof Model, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): DryModelQueryBuilderWithoutReadOperations<T>;
     /**
      * @description Finds the first record in the database
      * @deprecated Used only for debugging purposes, use `.findOne` or `.query` instead
@@ -6048,7 +5969,7 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
      * @sqlite If no Primary Key is present in the model definition, the model will be returned
      * @sqlite Returning Not supported and won't have effect
      */
-    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelQueryResult<T>>;
+    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): WriteOperation<ModelQueryResult<T>>;
     /**
      * @description Saves multiple records to the database
      * @warning If not using postgres and the model has no primary key, the models will be saved, but it won't be possible to retrieve them so at that point they will be returned as an empty array
@@ -6057,7 +5978,7 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
      * @sqlite Returning Not supported and won't have effect
      * @oracledb may do multiple inserts with auto-generated identity columns
      */
-    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelQueryResult<T>[]>;
+    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): WriteOperation<ModelQueryResult<T>[]>;
     /**
      * @description Syncs in the through table the given models for the given relation
      * @param relation The many to many relation to sync, this is not type safe since many to many relations defined at a decorator level
@@ -6614,8 +6535,8 @@ declare function getUniques(target: typeof Model): UniqueType[];
 type FactoryReturnType<T extends number, O extends Model> = T extends 1 ? O : O[];
 
 declare class ModelFactory<M extends Model> {
-    typeofModel: typeof Model;
-    modelData: Partial<M>;
+    private typeofModel;
+    private modelData;
     /**
      * @description Constructor for the model factory
      */
@@ -7751,4 +7672,4 @@ declare const generateOpenApiModelWithMetadata: <T extends new () => Model>(mode
     $id?: string;
 }>;
 
-export { type AbstractConstructor, type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, type BuildSelectType, type BuildSingleSelectType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, DryModelQueryBuilder, DryQueryBuilder, type ExcludeMethods, type ExtractColumnName, type ExtractSourceColumn, type FetchHooks, type GetColumnType, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IncrementFields, IncrementMixin, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, type MigrationConfig, type MigrationConfigBase, type MixinColumns, MixinFactory, Model, type ModelDataProperties, type ModelInstanceMethods, type ModelInstanceType, ModelQueryBuilder, type ModelQueryResult, type ModelSelectTuple, type ModelSelectableInput, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleDBDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type OracleDBDataSourceInput, type OracleDBPoolInstance, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type ReplicationType, Schema, SchemaBuilder, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type TableFormat, type ThroughModel, type TimestampFields, TimestampMixin, Transaction, type TransactionExecutionOptions, type UlidFields, UlidMixin, type UniqueType, type UseCacheReturnType, type UseConnectionInput, type UuidFields, UuidMixin, belongsTo, bigIntMixin, column, createMixin, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, incrementMixin, index, HysteriaLogger as logger, manyToMany, property, RedisDataSource as redis, timestampMixin, ulidMixin, unique, uuidMixin, view, withPerformance };
+export { type AbstractConstructor, type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, type BuildSelectType, type BuildSingleSelectType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, type ExcludeMethods, type ExtractColumnName, type ExtractSourceColumn, type FetchHooks, type GetColumnType, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IncrementFields, IncrementMixin, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, type MigrationConfig, type MigrationConfigBase, type MixinColumns, MixinFactory, Model, type ModelDataProperties, type ModelInstanceMethods, type ModelInstanceType, ModelQueryBuilder, type ModelQueryResult, type ModelSelectTuple, type ModelSelectableInput, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleDBDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type OracleDBDataSourceInput, type OracleDBPoolInstance, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type ReplicationType, Schema, SchemaBuilder, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type TableFormat, type ThroughModel, type TimestampFields, TimestampMixin, Transaction, type TransactionExecutionOptions, type UlidFields, UlidMixin, type UniqueType, type UseCacheReturnType, type UseConnectionInput, type UuidFields, UuidMixin, WriteOperation, belongsTo, bigIntMixin, column, createMixin, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, incrementMixin, index, HysteriaLogger as logger, manyToMany, property, RedisDataSource as redis, timestampMixin, ulidMixin, unique, uuidMixin, view, withPerformance };