hysteria-orm 10.4.9 → 10.5.0

package/lib/index.d.ts

@@ -10,9 +10,9 @@ import { PoolConfig, PoolClient, QueryResult as QueryResult$1 } from 'pg';
 import * as mysql2_promise from 'mysql2/promise';
 import { PoolOptions, PoolConnection, QueryResult } from 'mysql2/promise';
 import { RedisOptions, Redis } from 'ioredis';
-import { PassThrough } from 'node:stream';
-import { FormatOptionsWithLanguage } from 'sql-formatter';
 import express from 'express';
+import { FormatOptionsWithLanguage } from 'sql-formatter';
+import { PassThrough } from 'node:stream';
 
 type CaseConvention = "camel" | "snake" | "preserve" | RegExp | ((column: string) => string);
 
@@ -765,6 +765,22 @@ type ForeignKeyOptions = CommonConstraintOptions & {
 type CreateTableContext = "alter_table" | "create_table";
 type CommonPostgresExtensions = "postgis" | "uuid-ossp" | "hstore" | "pg_trgm" | "btree_gin" | "btree_gist" | "citext" | "pgcrypto" | "tablefunc" | "unaccent" | "pg_stat_statements" | "ltree" | "cube" | "earthdistance" | "fuzzystrmatch" | "intarray" | "isn" | "lo" | "pg_buffercache" | "pgrowlocks" | "pgstattuple" | "pg_freespacemap" | "postgres_fdw" | "seg" | "tsm_system_rows" | "tsm_system_time" | "plpgsql" | "plperl" | "plpython3u" | "pltcl" | "adminpack" | "amcheck" | "autoinc" | "bloom" | "dict_int" | "dict_xsyn" | "file_fdw" | "insert_username" | "intagg" | "moddatetime" | "old_snapshot" | "pageinspect" | "pg_prewarm" | "pg_surgery" | "pg_visibility" | "pgaudit" | "pglogical" | "pgrouting" | "postgis_topology" | "postgis_raster" | "postgis_sfcgal" | "postgis_tiger_geocoder" | "address_standardizer" | "address_standardizer_data_us" | "refint" | "sslinfo" | "tcn" | "timescaledb" | "vector" | "xml2";
 
+type OpenApiModelType = {
+    type: "object";
+    properties: Record<string, OpenApiModelPropertyType>;
+    required?: string[];
+};
+type OpenApiModelPropertyType = {
+    type: string;
+    items?: OpenApiModelType;
+    enum?: string[];
+    format?: string;
+    description?: string;
+    example?: any;
+    default?: any;
+    nullable?: boolean;
+};
+
 /**
  * @description AdminJS plugin types - All AdminJS imports are done at runtime via dynamic import()
  * @description This ensures the plugin is completely optional
@@ -1110,6 +1126,80 @@ interface CacheAdapter {
 type CacheKeys = Record<string, (...args: any[]) => Promise<any> | any>;
 type UseCacheReturnType<C extends CacheKeys, K extends keyof C> = K extends never ? never : Awaited<ReturnType<C[K]>>;
 
+declare abstract class QueryNode {
+    /**
+     * Sql keyword to use for the query e.g. "select"
+     */
+    keyword: string;
+    /**
+     * The current parameter index to use for the query
+     */
+    currParamIndex: number;
+    /**
+     * Whether the query node is a raw value and should not be parsed by the interpreter
+     */
+    isRawValue: boolean;
+    /**
+     * Whether the keyword can be seen multiple times in the query, e.g. "join" can be seen multiple times in a query
+     */
+    abstract canKeywordBeSeenMultipleTimes: boolean;
+    /**
+     * The string to use to chain the keyword with the next keyword
+     */
+    abstract chainsWith: string;
+    /**
+     * The folder to use for the query node, e.g. "select" is in the "select" folder inside the interpreter map
+     */
+    abstract folder: string;
+    /**
+     * The file to use for the query node, e.g. "select" is in the "select" file inside the interpreter map
+     */
+    abstract file: string;
+    constructor(keyword: string, isRawValue?: boolean);
+}
+
+declare class RawNode extends QueryNode {
+    rawValue: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    chainsWith: string;
+    currParamIndex: number;
+    isRawValue: boolean;
+    folder: string;
+    file: string;
+    constructor(value: string);
+}
+
+type ConstraintType = "primary_key" | "foreign_key" | "unique" | "not_null" | "null" | "default";
+declare class ConstraintNode extends QueryNode {
+    constraintType: ConstraintType;
+    columns?: (string | (() => string))[];
+    references?: {
+        table: string;
+        columns: (string | (() => string))[];
+    };
+    constraintName?: string;
+    onDelete?: "cascade" | "restrict" | "set null" | "no action";
+    onUpdate?: "cascade" | "restrict" | "set null" | "no action";
+    defaultValue?: string | RawNode | undefined;
+    checkExpression?: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(constraintType: ConstraintType, args?: {
+        columns?: string[];
+        references?: {
+            table: string;
+            columns: string[];
+        };
+        constraintName?: string;
+        onDelete?: "cascade" | "restrict" | "set null" | "no action";
+        onUpdate?: "cascade" | "restrict" | "set null" | "no action";
+        defaultValue?: string | RawNode | undefined;
+        checkExpression?: string;
+    }, isRawValue?: boolean);
+}
+
 type Sqlite3ConnectionOptions = {
     mode: number;
 };
@@ -1327,60 +1417,6 @@ type RawQueryOptions = {
     replicationMode?: ReplicationType;
 };
 
-type AstParserType = {
-    sql: string;
-    bindings: any[];
-};
-
-declare abstract class QueryNode {
-    /**
-     * Sql keyword to use for the query e.g. "select"
-     */
-    keyword: string;
-    /**
-     * The current parameter index to use for the query
-     */
-    currParamIndex: number;
-    /**
-     * Whether the query node is a raw value and should not be parsed by the interpreter
-     */
-    isRawValue: boolean;
-    /**
-     * Whether the keyword can be seen multiple times in the query, e.g. "join" can be seen multiple times in a query
-     */
-    abstract canKeywordBeSeenMultipleTimes: boolean;
-    /**
-     * The string to use to chain the keyword with the next keyword
-     */
-    abstract chainsWith: string;
-    /**
-     * The folder to use for the query node, e.g. "select" is in the "select" folder inside the interpreter map
-     */
-    abstract folder: string;
-    /**
-     * The file to use for the query node, e.g. "select" is in the "select" file inside the interpreter map
-     */
-    abstract file: string;
-    constructor(keyword: string, isRawValue?: boolean);
-}
-
-declare class AstParser {
-    private readonly dbType;
-    private readonly model;
-    constructor(model: typeof Model, dbType: SqlDataSourceType);
-    parse(nodes: (QueryNode | null)[], startBindingIndex?: number, isNestedCondition?: boolean): AstParserType;
-    /**
-     * Map the database type to a common type if shares the same driver (e.g. mysql and mariadb)
-     */
-    private mapCommonDbType;
-    /**
-     * @description Generates MSSQL table hints from lock node
-     * MSSQL uses WITH (UPDLOCK), WITH (HOLDLOCK), etc. as table hints
-     * READPAST is the MSSQL equivalent of SKIP LOCKED
-     */
-    private getMssqlTableHints;
-}
-
 declare class ColumnTypeNode extends QueryNode {
     column: string | (() => string);
     dataType: string;
@@ -1406,48 +1442,6 @@ declare class ColumnTypeNode extends QueryNode {
     });
 }
 
-declare class RawNode extends QueryNode {
-    rawValue: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    chainsWith: string;
-    currParamIndex: number;
-    isRawValue: boolean;
-    folder: string;
-    file: string;
-    constructor(value: string);
-}
-
-type ConstraintType = "primary_key" | "foreign_key" | "unique" | "not_null" | "null" | "default";
-declare class ConstraintNode extends QueryNode {
-    constraintType: ConstraintType;
-    columns?: (string | (() => string))[];
-    references?: {
-        table: string;
-        columns: (string | (() => string))[];
-    };
-    constraintName?: string;
-    onDelete?: "cascade" | "restrict" | "set null" | "no action";
-    onUpdate?: "cascade" | "restrict" | "set null" | "no action";
-    defaultValue?: string | RawNode | undefined;
-    checkExpression?: string;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(constraintType: ConstraintType, args?: {
-        columns?: string[];
-        references?: {
-            table: string;
-            columns: string[];
-        };
-        constraintName?: string;
-        onDelete?: "cascade" | "restrict" | "set null" | "no action";
-        onUpdate?: "cascade" | "restrict" | "set null" | "no action";
-        defaultValue?: string | RawNode | undefined;
-        checkExpression?: string;
-    }, isRawValue?: boolean);
-}
-
 type LockType = "for_update" | "for_share" | "for_no_key_update" | "for_key_share";
 declare class LockNode extends QueryNode {
     lockType: LockType;
@@ -1481,109 +1475,10 @@ declare class WithNode extends QueryNode {
     constructor(clause: string, alias: string, body: QueryNode | QueryNode[]);
 }
 
-declare class FromNode extends QueryNode {
-    table: string | QueryNode | QueryNode[];
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    alias?: string;
-    constructor(table: string | QueryNode | QueryNode[], alias?: string);
-}
-
-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);
-}
-
-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);
-}
-
-declare class InterpreterUtils {
-    private readonly model;
-    private readonly modelColumnsMap;
-    constructor(model: typeof Model);
-    formatStringColumn(dbType: SqlDataSourceType, column: string): string;
-    /**
-     * @description Formats the table name for the database type, idempotent for quoting
-     */
-    formatStringTable(dbType: SqlDataSourceType, table: string): string;
-    prepareColumns(columns: string[], values: any[], mode?: "insert" | "update"): Promise<{
-        columns: string[];
-        values: any[];
-    }>;
-    /**
-     * @description Formats the from node for write operations removing the "from" keyword
-     */
-    getFromForWriteOperations(dbType: SqlDataSourceType, fromNode: FromNode): string;
-}
-
-type OpenApiModelType = {
-    type: "object";
-    properties: Record<string, OpenApiModelPropertyType>;
-    required?: string[];
-};
-type OpenApiModelPropertyType = {
-    type: string;
-    items?: OpenApiModelType;
-    enum?: string[];
-    format?: string;
-    description?: string;
-    example?: any;
-    default?: any;
-    nullable?: boolean;
-};
-
-declare abstract class BaseBuilder {
-    protected nodes: QueryNode[];
-    constructor(nodes: QueryNode[]);
-    getNodes(): QueryNode[];
+declare abstract class BaseBuilder {
+    protected nodes: QueryNode[];
+    constructor(nodes: QueryNode[]);
+    getNodes(): QueryNode[];
 }
 
 declare class ConstraintBuilder extends BaseBuilder {
@@ -2165,71 +2060,147 @@ declare class Schema {
     private generateAstInstance;
 }
 
-type DeleteOptions = {
-    ignoreBeforeDeleteHook?: boolean;
-};
-type SoftDeleteOptions<T> = {
-    column?: MongoCollectionKey<T>;
-    value?: string | number | boolean;
-    ignoreBeforeUpdateHook?: boolean;
+type AstParserType = {
+    sql: string;
+    bindings: any[];
 };
 
-/**
- * Allows to get queries without executing them
- */
-declare class DryQueryBuilder extends QueryBuilder {
-    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 QueryBuilder.prototype.insert>): 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 QueryBuilder.prototype.insertMany>): 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
-     */
-    upsert(...args: Parameters<typeof QueryBuilder.prototype.upsert>): this;
-    upsertMany(...args: Parameters<typeof QueryBuilder.prototype.upsertMany>): this;
+declare class AstParser {
+    private readonly dbType;
+    private readonly model;
+    constructor(model: typeof Model, dbType: SqlDataSourceType);
+    parse(nodes: (QueryNode | null)[], startBindingIndex?: number, isNestedCondition?: boolean): AstParserType;
     /**
-     * @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
+     * Map the database type to a common type if shares the same driver (e.g. mysql and mariadb)
      */
-    update(data: Record<string, WriteQueryParam>): this;
+    private mapCommonDbType;
     /**
-     * @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 Generates MSSQL table hints from lock node
+     * MSSQL uses WITH (UPDLOCK), WITH (HOLDLOCK), etc. as table hints
+     * READPAST is the MSSQL equivalent of SKIP LOCKED
      */
-    delete(): this;
+    private getMssqlTableHints;
+}
+
+declare class FromNode extends QueryNode {
+    table: string | QueryNode | QueryNode[];
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    alias?: string;
+    constructor(table: string | QueryNode | QueryNode[], alias?: string);
+}
+
+declare class InterpreterUtils {
+    private readonly model;
+    private readonly modelColumnsMap;
+    constructor(model: typeof Model);
+    formatStringColumn(dbType: SqlDataSourceType, column: string): string;
     /**
-     * @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 Formats the table name for the database type, idempotent for quoting
      */
-    truncate(): this;
+    formatStringTable(dbType: SqlDataSourceType, table: string): string;
+    prepareColumns(columns: string[], values: any[], mode?: "insert" | "update"): Promise<{
+        columns: string[];
+        values: any[];
+    }>;
     /**
-     * @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 Formats the from node for write operations removing the "from" keyword
      */
-    softDelete(options?: Omit<SoftDeleteOptions<any>, "ignoreBeforeDeleteHook">): this;
+    getFromForWriteOperations(dbType: SqlDataSourceType, fromNode: FromNode): string;
+}
+
+type DeleteOptions = {
+    ignoreBeforeDeleteHook?: boolean;
+};
+type SoftDeleteOptions<T> = {
+    column?: MongoCollectionKey<T>;
+    value?: string | number | boolean;
+    ignoreBeforeUpdateHook?: boolean;
+};
+
+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);
 }
 
+type PaginationMetadata = {
+    perPage: number;
+    currentPage: number;
+    firstPage: number;
+    isEmpty: boolean;
+    total: number;
+    lastPage: number;
+    hasMorePages: boolean;
+    hasPages: boolean;
+};
+type CursorPaginationMetadata = {
+    perPage: number;
+    firstPage: number;
+    isEmpty: boolean;
+    total: number;
+};
+type PaginatedData<T extends Model, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = {
+    paginationMetadata: PaginationMetadata;
+    data: ([keyof S] extends [never] ? T & R : SelectedModel<S, R>)[];
+};
+type CursorPaginatedData<T extends Model, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = {
+    paginationMetadata: CursorPaginationMetadata;
+    data: ([keyof S] extends [never] ? T & R : SelectedModel<S, R>)[];
+};
+
 type BaseValues$1 = string | number | boolean | null;
 type BinaryOperatorType$1 = "=" | "!=" | "<>" | ">" | "<" | ">=" | "<=" | "like" | "ilike" | "in";
 declare class HavingNode extends QueryNode {
@@ -2628,7 +2599,7 @@ declare abstract class FooterQueryBuilder<T extends Model> {
      * @description Adds a group by query
      */
     groupBy(...columns: ModelKey<T>[]): this;
-    groupBy<S extends string>(...columns: SelectableColumn<S>[]): this;
+    groupBy<S extends string>(...columns: SelectableColumn$1<S>[]): this;
     /**
      * @description Adds a raw group by query, GROUP BY clause is not necessary and will be added automatically
      */
@@ -2637,7 +2608,7 @@ declare abstract class FooterQueryBuilder<T extends Model> {
      * @description Adds an order by query
      */
     orderBy(column: ModelKey<T>, order: OrderByChoices): this;
-    orderBy<S extends string>(column: SelectableColumn<S>, order: OrderByChoices): this;
+    orderBy<S extends string>(column: SelectableColumn$1<S>, order: OrderByChoices): this;
     /**
      * @description Adds a raw order by query, ORDER BY clause is not necessary and will be added automatically
      */
@@ -2664,180 +2635,180 @@ declare class JoinOnQueryBuilder {
     /**
      * @description Adds a WHERE condition to the query.
      */
-    where(column: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
+    where(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): this;
     where(cb: (queryBuilder: JoinOnQueryBuilder) => void): this;
-    where(column: SelectableColumn<string>, value: BaseValues): this;
+    where(column: SelectableColumn$1<string>, value: BaseValues): this;
     /**
      * @description Adds an AND WHERE condition to the query.
      */
-    andWhere(column: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhere(column: SelectableColumn<string>, value: BaseValues): this;
+    andWhere(column: SelectableColumn$1<string>, operator: BinaryOperatorType, value: BaseValues): 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: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhere(column: SelectableColumn<string>, value: BaseValues): 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: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    whereNot(column: SelectableColumn<string>, value: BaseValues): 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: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhereNot(column: SelectableColumn<string>, value: BaseValues): 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: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhereNot(column: SelectableColumn<string>, value: BaseValues): 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: SelectableColumn<string>, 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: SelectableColumn<string>, 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: SelectableColumn<string>, 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: SelectableColumn<string>, 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: SelectableColumn<string>, 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: SelectableColumn<string>, 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: SelectableColumn<string>, value: string): this;
+    whereLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE LIKE condition to the query.
      */
-    andWhereLike(column: SelectableColumn<string>, value: string): this;
+    andWhereLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE LIKE condition to the query.
      */
-    orWhereLike(column: SelectableColumn<string>, value: string): this;
+    orWhereLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE ILIKE condition to the query.
      */
-    whereILike(column: SelectableColumn<string>, value: string): this;
+    whereILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE ILIKE condition to the query.
      */
-    andWhereILike(column: SelectableColumn<string>, value: string): this;
+    andWhereILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE ILIKE condition to the query.
      */
-    orWhereILike(column: SelectableColumn<string>, value: string): this;
+    orWhereILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE NOT LIKE condition to the query.
      */
-    whereNotLike(column: SelectableColumn<string>, value: string): this;
+    whereNotLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE NOT LIKE condition to the query.
      */
-    andWhereNotLike(column: SelectableColumn<string>, value: string): this;
+    andWhereNotLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE NOT LIKE condition to the query.
      */
-    orWhereNotLike(column: SelectableColumn<string>, value: string): this;
+    orWhereNotLike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE NOT ILIKE condition to the query.
      */
-    whereNotILike(column: SelectableColumn<string>, value: string): this;
+    whereNotILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an AND WHERE NOT ILIKE condition to the query.
      */
-    andWhereNotILike(column: SelectableColumn<string>, value: string): this;
+    andWhereNotILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds an OR WHERE NOT ILIKE condition to the query.
      */
-    orWhereNotILike(column: SelectableColumn<string>, value: string): this;
+    orWhereNotILike(column: SelectableColumn$1<string>, value: string): this;
     /**
      * @description Adds a WHERE IN condition to the query.
      */
-    whereIn(column: SelectableColumn<string>, values: BaseValues[]): this;
+    whereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds an AND WHERE IN condition to the query.
      */
-    andWhereIn(column: SelectableColumn<string>, values: BaseValues[]): this;
+    andWhereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds an OR WHERE IN condition to the query.
      */
-    orWhereIn(column: SelectableColumn<string>, values: BaseValues[]): this;
+    orWhereIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds a WHERE NOT IN condition to the query.
      */
-    whereNotIn(column: SelectableColumn<string>, values: BaseValues[]): this;
+    whereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds an AND WHERE NOT IN condition to the query.
      */
-    andWhereNotIn(column: SelectableColumn<string>, values: BaseValues[]): this;
+    andWhereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds an OR WHERE NOT IN condition to the query.
      */
-    orWhereNotIn(column: SelectableColumn<string>, values: BaseValues[]): this;
+    orWhereNotIn(column: SelectableColumn$1<string>, values: BaseValues[]): this;
     /**
      * @description Adds a WHERE NULL condition to the query.
      */
-    whereNull(column: SelectableColumn<string>): this;
+    whereNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an AND WHERE NULL condition to the query.
      */
-    andWhereNull(column: SelectableColumn<string>): this;
+    andWhereNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an OR WHERE NULL condition to the query.
      */
-    orWhereNull(column: SelectableColumn<string>): this;
+    orWhereNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds a WHERE NOT NULL condition to the query.
      */
-    whereNotNull(column: SelectableColumn<string>): this;
+    whereNotNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an AND WHERE NOT NULL condition to the query.
      */
-    andWhereNotNull(column: SelectableColumn<string>): this;
+    andWhereNotNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds an OR WHERE NOT NULL condition to the query.
      */
-    orWhereNotNull(column: SelectableColumn<string>): this;
+    orWhereNotNull(column: SelectableColumn$1<string>): this;
     /**
      * @description Adds a WHERE REGEXP condition to the query.
      */
-    whereRegexp(column: SelectableColumn<string>, regexp: RegExp): this;
+    whereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an AND WHERE REGEXP condition to the query.
      */
-    andWhereRegexp(column: SelectableColumn<string>, regexp: RegExp): this;
+    andWhereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an OR WHERE REGEXP condition to the query.
      */
-    orWhereRegexp(column: SelectableColumn<string>, regexp: RegExp): this;
+    orWhereRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds a WHERE NOT REGEXP condition to the query.
      */
-    whereNotRegexp(column: SelectableColumn<string>, regexp: RegExp): this;
+    whereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an AND WHERE NOT REGEXP condition to the query.
      */
-    andWhereNotRegexp(column: SelectableColumn<string>, regexp: RegExp): this;
+    andWhereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds an OR WHERE NOT REGEXP condition to the query.
      */
-    orWhereNotRegexp(column: SelectableColumn<string>, regexp: RegExp): this;
+    orWhereNotRegexp(column: SelectableColumn$1<string>, regexp: RegExp): this;
     /**
      * @description Adds a WHERE group condition with AND.
      */
@@ -2973,7 +2944,6 @@ declare abstract class JoinQueryBuilder<T extends Model> extends FooterQueryBuil
 declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
     protected dbType: SqlDataSourceType;
     protected modelSelectedColumns: string[];
-    protected modelAnnotatedColumns: string[];
     protected withQuery?: string;
     protected fromNode: FromNode;
     protected distinctNode: DistinctNode | null;
@@ -2983,18 +2953,29 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
     /**
      * @description Adds a SELECT condition to the query.
      * @description Can be stacked multiple times
-     * @warning For annotations, use the `annotate` method instead, aliases and methods are not supported in the select method and will give error `column "${columnName} as ${alias}" does not exist`
+     * @description Supports: "column", "table.column", "column as alias", "*", "table.*"
      * @example
      * ```ts
      * const user = await User.query().select("name", "age").one(); // SELECT name, age FROM users
      * const user = await User.query().select("name", "users.age").one(); // SELECT name, users.age FROM users
+     * const user = await User.query().select("name as userName").one(); // SELECT name as userName FROM users
      * ```
      */
-    select<S extends string>(...columns: SelectableColumn<S>[]): this;
+    select<S extends string>(...columns: SelectableColumn$1<S>[]): this;
     select(...columns: (ModelKey<T> | "*")[]): this;
     /**
-     * @description Adds a raw select statement to the query
-     * @warning For models, only annotated columns are available and will be added to the `$annotations` property of the model. Everything else will be ignored, if you need a query like `selectRaw` you can use the `QueryBuilder` instead.
+     * @description Parses a column string that may contain an alias (e.g., "column as alias")
+     * @returns The column part and optional alias part
+     */
+    private parseColumnAlias;
+    /**
+     * @description Adds a raw SELECT statement to the query
+     * @description Useful for SQL functions, expressions, or complex selections
+     * @example
+     * ```ts
+     * const result = await User.query().selectRaw("count(*) as total").one();
+     * const result = await User.query().selectRaw("sum(amount) as total_amount").one();
+     * ```
      */
     selectRaw(statement: string): this;
     /**
@@ -3013,19 +2994,6 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      * @description Clears the DISTINCT ON clause
      */
     clearDistinctOn(): this;
-    /**
-     * @description Annotates a column with a SQL method or a simple alias
-     * @description If using a model, the result will be available in the $annotations property of the model, else it will be available in the result of the query
-     * @example
-     * ```ts
-     * const user = await User.query().annotate("max", "id", "maxId").one(); // max(id) as maxId
-     * const user = await User.query().annotate("id", "superId").one(); // id as superId
-     * const user = await User.query().annotate("id", "superId").one(); // id as superId
-     * ```
-     */
-    annotate<A extends string>(column: string, alias: A): this;
-    annotate<A extends string>(sqlMethod: SqlMethod, column: string, alias: A): this;
-    annotate<A extends string>(sqlMethod: string, column: string, alias: A): this;
     /**
      * @description Sets the table to select from, by default is the table defined in the Model
      * @description Can be used on non select queries too, it will only specify the table name (es. INSERT INTO $table)
@@ -3048,19 +3016,17 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      * @postgresql Only usable with PostgreSQL
      */
     distinctOn(...columns: ModelKey<T>[]): this;
-    distinctOn<S extends string>(...columns: SelectableColumn<S>[]): this;
+    distinctOn<S extends string>(...columns: SelectableColumn$1<S>[]): this;
     /**
      * @description Selects a JSON value at the specified path and returns it as JSON
      * @param column The column containing JSON data
      * @param path The JSON path to extract (standardized format: "$.user.name", "user.name", or ["user", "name"])
      * @param alias The alias for the selected value
      * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description Result will be available in model.$annotations[alias]
      * @example
      * ```ts
      * // All databases accept the same path format:
      * const user = await User.query().selectJson("data", "$.user.name", "userName").one();
-     * console.log(user?.$annotations?.userName); // Typed!
      *
      * await User.query().selectJson("data", "user.name", "userName").one(); // $ is optional
      * await User.query().selectJson("data", ["user", "name"], "userName").one();
@@ -3078,12 +3044,10 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      * @param path The JSON path to extract (standardized format)
      * @param alias The alias for the selected value
      * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description Result will be available in model.$annotations[alias]
      * @example
      * ```ts
      * // All databases accept the same path format:
      * const user = await User.query().selectJsonText("data", "$.user.name", "userName").one();
-     * console.log(user?.$annotations?.userName); // Typed!
      *
      * await User.query().selectJsonText("data", ["user", "name"], "userName").one();
      * ```
@@ -3096,12 +3060,10 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      * @param path The JSON path to the array (standardized format, use "$" or "" for root)
      * @param alias The alias for the length value
      * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description Result will be available in model.$annotations[alias]
      * @example
      * ```ts
      * // All databases accept the same path format:
      * const user = await User.query().selectJsonArrayLength("data", "$.items", "itemCount").one();
-     * console.log(user?.$annotations?.itemCount); // Typed!
      *
      * await User.query().selectJsonArrayLength("data", "items", "itemCount").one();
      * await User.query().selectJsonArrayLength("data", "$", "totalCount").one(); // root array
@@ -3115,14 +3077,12 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      * @param path The JSON path to the object (standardized format, use "$" or "" for root)
      * @param alias The alias for the keys
      * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description Result will be available in model.$annotations[alias]
      * @postgres Returns an array of keys
      * @mysql Returns a JSON array of keys
      * @example
      * ```ts
      * // All databases accept the same path format:
      * const user = await User.query().selectJsonKeys("data", "$.user", "userKeys").one();
-     * console.log(user?.$annotations?.userKeys); // Typed!
      *
      * await User.query().selectJsonKeys("data", "user", "userKeys").one();
      * await User.query().selectJsonKeys("data", "$", "rootKeys").one(); // root object
@@ -3134,14 +3094,73 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      * @description Adds a raw JSON select expression
      * @param raw The raw SQL expression
      * @param alias The alias for the selected value
-     * @description Result will be available in model.$annotations[alias]
      * @example
      * ```ts
      * const user = await User.query().selectJsonRaw("data->>'email'", "userEmail").one();
-     * console.log(user?.$annotations?.userEmail); // Typed!
      * ```
      */
     selectJsonRaw<A extends string>(raw: string, alias: A): this;
+    /**
+     * @description Selects COUNT(column) with an alias
+     * @param column The column to count (use "*" for COUNT(*))
+     * @param alias The alias for the count result
+     * @example
+     * ```ts
+     * const result = await User.query().selectCount("id", "totalUsers").one();
+     *
+     * const result = await User.query().selectCount("*", "total").one();
+     * ```
+     */
+    selectCount<A extends string>(column: ModelKey<T> | "*", alias: A): this;
+    selectCount<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects SUM(column) with an alias
+     * @param column The column to sum
+     * @param alias The alias for the sum result
+     * @example
+     * ```ts
+     * const result = await Order.query().selectSum("amount", "totalAmount").one();
+     * console.log(result?.totalAmount); // number
+     * ```
+     */
+    selectSum<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectSum<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects AVG(column) with an alias
+     * @param column The column to average
+     * @param alias The alias for the average result
+     * @example
+     * ```ts
+     * const result = await User.query().selectAvg("age", "averageAge").one();
+     * console.log(result?.averageAge); // number
+     * ```
+     */
+    selectAvg<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectAvg<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects MIN(column) with an alias
+     * @param column The column to get minimum value
+     * @param alias The alias for the min result
+     * @example
+     * ```ts
+     * const result = await User.query().selectMin("age", "youngestAge").one();
+     * console.log(result?.youngestAge); // number
+     * ```
+     */
+    selectMin<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectMin<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects MAX(column) with an alias
+     * @param column The column to get maximum value
+     * @param alias The alias for the max result
+     * @example
+     * ```ts
+     * const result = await User.query().selectMax("age", "oldestAge").one();
+     * console.log(result?.oldestAge); // number
+     * ```
+     */
+    selectMax<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectMax<A extends string>(column: string, alias: A): this;
 }
 
 declare abstract class WhereQueryBuilder<T extends Model> extends SelectQueryBuilder<T> {
@@ -3165,251 +3184,251 @@ declare abstract class WhereQueryBuilder<T extends Model> extends SelectQueryBui
      * @description Adds a WHERE condition to the query.
      */
     where(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    where<S extends string>(column: SelectableColumn<S>, 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<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    where(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    where(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues): 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 Adds an AND WHERE condition to the query.
      */
     andWhere(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhere(column: SelectableColumn<string>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhere(column: ModelKey<T> | SelectableColumn<string>, 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<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    andWhere(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<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 Adds an OR WHERE condition to the query.
      */
     orWhere(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhere<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhere<S extends string>(column: ModelKey<T> | SelectableColumn<S>, 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<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    orWhere(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<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 Adds a negated WHERE condition to the query.
      */
     whereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    whereNot<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    whereNot(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues): this;
-    whereNot(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    whereNot(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): 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 Adds a negated AND WHERE condition to the query.
      */
     andWhereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhereNot<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    andWhereNot(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues): this;
-    andWhereNot(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    andWhereNot(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): 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 Adds a negated OR WHERE condition to the query.
      */
     orWhereNot(column: ModelKey<T>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhereNot<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType, value: BaseValues): this;
-    orWhereNot(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues): this;
-    orWhereNot(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
-    orWhereNot(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): 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 Adds a WHERE BETWEEN condition to the query.
      */
     whereBetween(column: ModelKey<T>, min: BaseValues, max: BaseValues): this;
-    whereBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues, max: BaseValues): this;
+    whereBetween<S extends string>(column: SelectableColumn$1<S>, 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<S>, min: BaseValues, max: BaseValues): this;
+    andWhereBetween<S extends string>(column: SelectableColumn$1<S>, 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<S>, min: BaseValues, max: BaseValues): this;
+    orWhereBetween<S extends string>(column: SelectableColumn$1<S>, 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<S>, min: BaseValues, max: BaseValues): this;
+    whereNotBetween<S extends string>(column: SelectableColumn$1<S>, 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<S>, min: BaseValues, max: BaseValues): this;
+    andWhereNotBetween<S extends string>(column: SelectableColumn$1<S>, 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<S>, min: BaseValues, max: BaseValues): this;
+    orWhereNotBetween<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    whereLike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    andWhereLike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    orWhereLike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    whereILike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    andWhereILike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    orWhereILike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    whereNotLike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    andWhereNotLike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    orWhereNotLike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    whereNotILike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    andWhereNotILike<S extends string>(column: SelectableColumn$1<S>, 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<S>, value: string): this;
+    orWhereNotILike<S extends string>(column: SelectableColumn$1<S>, 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<S>, values: BaseValues[]): this;
+    whereIn<S extends string>(column: SelectableColumn$1<S>, 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<S>, values: BaseValues[]): this;
+    andWhereIn<S extends string>(column: SelectableColumn$1<S>, 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<S>, values: BaseValues[]): this;
+    orWhereIn<S extends string>(column: SelectableColumn$1<S>, 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<S>, 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<S>, 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<S>, 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<S>): 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<S>): 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<S>): this;
+    orWhereNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
      * @description Adds a WHERE NOT NULL condition to the query.
      */
     whereNotNull(column: ModelKey<T>): this;
-    whereNotNull<S extends string>(column: SelectableColumn<S>): this;
+    whereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
      * @description Adds an AND WHERE NOT NULL condition to the query.
      */
     andWhereNotNull(column: ModelKey<T>): this;
-    andWhereNotNull<S extends string>(column: SelectableColumn<S>): this;
+    andWhereNotNull<S extends string>(column: SelectableColumn$1<S>): this;
     /**
      * @description Adds an OR WHERE NOT NULL condition to the query.
      */
     orWhereNotNull(column: ModelKey<T>): this;
-    orWhereNotNull<S extends string>(column: SelectableColumn<S>): this;
+    orWhereNotNull<S extends string>(column: SelectableColumn$1<S>): 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<S>, regexp: RegExp): this;
+    whereRegexp<S extends string>(column: SelectableColumn$1<S>, 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<S>, regexp: RegExp): this;
+    andWhereRegexp<S extends string>(column: SelectableColumn$1<S>, 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<S>, regexp: RegExp): this;
+    orWhereRegexp<S extends string>(column: SelectableColumn$1<S>, 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<S>, regexp: RegExp): this;
+    whereNotRegexp<S extends string>(column: SelectableColumn$1<S>, 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<S>, regexp: RegExp): this;
+    andWhereNotRegexp<S extends string>(column: SelectableColumn$1<S>, 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<S>, regexp: RegExp): this;
+    orWhereNotRegexp<S extends string>(column: SelectableColumn$1<S>, 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.
      */
@@ -3449,17 +3468,17 @@ declare abstract class WhereQueryBuilder<T extends Model> extends SelectQueryBui
     /**
      * @description Adds a HAVING condition to the query.
      */
-    having<S extends string>(column: SelectableColumn<S>, value: any): this;
+    having<S extends string>(column: SelectableColumn$1<S>, value: any): this;
     having(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
     /**
      * @description Adds an AND HAVING condition to the query.
      */
-    andHaving<S extends string>(column: SelectableColumn<S>, value: any): this;
+    andHaving<S extends string>(column: SelectableColumn$1<S>, value: any): this;
     andHaving(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
     /**
      * @description Adds an OR HAVING condition to the query.
      */
-    orHaving<S extends string>(column: SelectableColumn<S>, value: any): this;
+    orHaving<S extends string>(column: SelectableColumn$1<S>, value: any): this;
     orHaving(column: ModelKey<T>, operator: BinaryOperatorType, value: any): this;
     /**
      * @description Adds a raw HAVING condition to the query.
@@ -3570,133 +3589,46 @@ declare class JsonQueryBuilder<T extends Model> extends WhereQueryBuilder<T> {
     orWhereJsonRaw(raw: string, params?: any[]): this;
 }
 
-type PluckReturnType<T extends Model, K extends ModelKey<T>> = T[K] extends infer U ? U[] : never;
-type WhereOnlyQueryBuilder<T extends Model> = Pick<WhereQueryBuilder<T>, "where" | "andWhere" | "orWhere" | "whereNot" | "andWhereNot" | "orWhereNot" | "whereIn" | "andWhereIn" | "orWhereIn" | "whereNotIn" | "andWhereNotIn" | "orWhereNotIn" | "whereBetween" | "andWhereBetween" | "orWhereBetween" | "whereNotBetween" | "andWhereNotBetween" | "orWhereNotBetween" | "whereNull" | "andWhereNull" | "orWhereNull" | "whereNotNull" | "andWhereNotNull" | "orWhereNotNull" | "whereLike" | "andWhereLike" | "orWhereLike" | "whereILike" | "andWhereILike" | "orWhereILike" | "whereNotLike" | "andWhereNotLike" | "orWhereNotLike" | "whereNotILike" | "andWhereNotILike" | "orWhereNotILike" | "whereRegexp" | "andWhereRegexp" | "orWhereRegexp" | "whereNotRegexp" | "andWhereNotRegexp" | "orWhereNotRegexp" | "whereRaw" | "andWhereRaw" | "orWhereRaw" | "whereExists" | "orWhereExists" | "andWhereExists"> & Pick<JsonQueryBuilder<T>, "whereJson" | "andWhereJson" | "orWhereJson" | "whereJsonContains" | "andWhereJsonContains" | "orWhereJsonContains" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains" | "whereJsonRaw" | "andWhereJsonRaw" | "orWhereJsonRaw" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains">;
-type RelationRetrieveMethod<P extends any> = P extends any[] ? "many" : "one";
-type SelectableColumn<T extends string = string> = T extends `${infer Table}.${infer Column}.${string}` ? never : T extends `${string} ${string}` ? never : T extends `.${string}` | `${string}.` ? never : T extends `${string}-${string}` ? never : T extends `${string}.${string}` ? T : T;
-/**
- * @description A column that can be used in a join statement e.g. `users.id`
- */
-type JoinableColumn = `${string}.${string}`;
-/**
- * @description Options for streaming queries
- * @sqlite Ignores the options below
- */
-type StreamOptions = {
-    highWaterMark?: number;
-    /** Postgres only */
-    rowMode?: "array";
-    /** Postgres only */
-    batchSize?: number;
-    /** Postgres only */
-    types?: any;
-    /** Mysql only */
-    objectMode?: boolean;
-};
-type Cursor<T extends Model, K extends ModelKey<T>> = {
-    key: K;
-    value: string | number;
-};
-type PaginateWithCursorOptions<T extends Model, K extends ModelKey<T>> = {
-    discriminator: K;
-    operator?: "<" | ">";
-    orderBy?: "asc" | "desc";
-};
-type UpsertOptionsRawBuilder = {
-    updateOnConflict?: boolean;
-    returning?: string[];
-};
-type DryQueryBuilderWithoutReadOperations = Omit<DryQueryBuilder, "many" | "one" | "oneOrFail" | "first" | "firstOrFail" | "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" | "first" | "firstOrFail" | "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;
-
-declare class SqlModelManagerUtils<T extends Model> {
-    protected dbType: SqlDataSourceType;
-    protected sqlDataSource: SqlDataSource;
-    protected modelRelations: Relation[];
-    protected modelRelationsMap: Map<string, Relation>;
-    constructor(typeofModel: typeof Model, dbType: SqlDataSourceType, sqlDataSource: SqlDataSource);
-    getRelationFromModel(relation: ModelRelation<T>): Relation;
-}
-
-type PaginationMetadata = {
-    perPage: number;
-    currentPage: number;
-    firstPage: number;
-    isEmpty: boolean;
-    total: number;
-    lastPage: number;
-    hasMorePages: boolean;
-    hasPages: boolean;
-};
-type CursorPaginationMetadata = {
-    perPage: number;
-    firstPage: number;
-    isEmpty: boolean;
-    total: number;
-};
-type PaginatedData<T extends Model, A extends object = {}, R extends object = {}> = {
-    paginationMetadata: PaginationMetadata;
-    data: AnnotatedModel<T, A, R>[];
-};
-type CursorPaginatedData<T extends Model, A extends object = {}, R extends object = {}> = {
-    paginationMetadata: CursorPaginationMetadata;
-    data: AnnotatedModel<T, A, R>[];
-};
-
-type UpdateOptions = {
-    ignoreBeforeUpdateHook?: boolean;
-};
-
-/**
- * @description Due to query limitations some query builder methods may not be available in a RelationQueryBuilder
- */
-type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "first" | "firstOrFail" | "paginate" | "pluck" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
-
-/**
- * Helper type to determine if annotation overrides model field or goes to $annotations
- * If K is a key of the model T, it overrides that field in the model.
- * Otherwise, it goes into the annotations object A.
- */
-type AnnotationResult<T extends Model, A extends Record<string, any>, R extends Record<string, any>, K extends string, V> = K extends keyof T ? ModelQueryBuilder<T & {
-    [P in K]: V;
-}, A, R> : ModelQueryBuilder<T, A & {
-    [P in K]: V;
-}, R>;
-declare class ModelQueryBuilder<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> extends QueryBuilder<T> {
-    relation: Relation;
-    protected sqlModelManagerUtils: SqlModelManagerUtils<T>;
-    protected relationQueryBuilders: ModelQueryBuilder<any>[];
-    protected modelSelectedColumns: string[];
-    private modelColumnsMap;
-    private modelColumnsDatabaseNames;
-    protected limitValue?: number;
-    protected offsetValue?: number;
+declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
+    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 Performance methods that return the time that took to execute the query with the result
+     */
     performance: {
-        many: (options?: ManyOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R>[];
+        many: (returnType?: "millis" | "seconds") => Promise<{
+            data: T[];
             time: number;
         }>;
-        one: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R> | null;
+        one: (returnType?: "millis" | "seconds") => Promise<{
+            data: T | null;
             time: number;
         }>;
-        oneOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R>;
+        oneOrFail: (returnType?: "millis" | "seconds") => Promise<{
+            data: T;
             time: number;
         }>;
-        paginate: (page: number, perPage: number, options?: {
-            ignoreHooks?: boolean;
-        }, returnType?: "millis" | "seconds") => Promise<{
-            data: PaginatedData<T, A, R>;
+        paginate: (page: number, perPage: number, returnType?: "millis" | "seconds") => Promise<{
+            data: PaginatedData<T>;
             time: number;
         }>;
-        exists: (returnType?: "millis" | "seconds") => Promise<{
-            data: boolean;
+        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
+            data: [CursorPaginatedData<T>, Cursor<T, ModelKey<T>>];
             time: number;
         }>;
-        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
-            data: [CursorPaginatedData<T, A, R>, Cursor<T, ModelKey<T>>];
+        exists: (returnType?: "millis" | "seconds") => Promise<{
+            data: boolean;
             time: number;
         }>;
         truncate: (returnType?: "millis" | "seconds") => Promise<{
@@ -3707,7 +3639,15 @@ declare class ModelQueryBuilder<T extends Model, A extends Record<string, any> =
             data: number;
             time: number;
         }>;
-        update: (data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions, returnType?: "millis" | "seconds") => Promise<{
+        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;
         }>;
@@ -3720,1472 +3660,1709 @@ declare class ModelQueryBuilder<T extends Model, A extends Record<string, any> =
             time: number;
         }>;
     };
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    constructor(model: typeof Model, sqlDataSource?: SqlDataSource);
     /**
-     * @description Returns true if the query builder is a relation query builder, this changes the behavior of the query builder like limit, offset, etc.
-     * @internal
+     * @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
      */
-    protected get isRelationQueryBuilder(): boolean;
+    setReplicationMode(replicationMode: ReplicationType): this;
     /**
-     * @description Creates a new ModelQueryBuilder instance from a model. Will use the main connection to the database by default.
+     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
      */
-    static from(model: typeof Model, options?: BaseModelMethodOptions): ModelQueryBuilder<InstanceType<typeof model>>;
-    one(options?: OneOptions): Promise<AnnotatedModel<T, A, R> | null>;
-    oneOrFail(options?: {
-        ignoreHooks?: OneOptions["ignoreHooks"] & {
-            customError?: Error;
-        };
-    }): Promise<AnnotatedModel<T, A, R>>;
-    firstOrFail(options?: {
-        ignoreHooks?: OneOptions["ignoreHooks"] & {
-            customError?: Error;
-        };
-    }): Promise<AnnotatedModel<T, A, R>>;
-    many(options?: ManyOptions): Promise<AnnotatedModel<T, A, R>[]>;
-    chunk(chunkSize: number, options?: ManyOptions): AsyncGenerator<AnnotatedModel<T, A, R>[]>;
-    stream(options?: ManyOptions & StreamOptions): Promise<PassThrough & AsyncGenerator<AnnotatedModel<T, A, R>>>;
-    paginateWithCursor<K extends ModelKey<T>>(page: number, options?: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T, A, R>, Cursor<T, K>]>;
+    exists(): Promise<boolean>;
     /**
-     * @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.
+     * @description Executes the query and retrieves multiple results.
      */
-    insert(...args: Parameters<typeof this$1.model.insert<T>>): ReturnType<typeof this$1.model.insert>;
+    many(): Promise<T[]>;
     /**
-     * @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.
+     * @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
      */
-    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>;
-    getCount(column?: string, options?: {
-        ignoreHooks: boolean;
-    }): Promise<number>;
-    getMax(column: string, options?: {
-        ignoreHooks: boolean;
-    }): Promise<number>;
-    getMin(column: string, options?: {
-        ignoreHooks: boolean;
-    }): Promise<number>;
-    getAvg(column: string, options?: {
-        ignoreHooks: boolean;
-    }): Promise<number>;
-    getSum(column: string, options?: {
-        ignoreHooks: boolean;
-    }): Promise<number>;
-    paginate(page: number, perPage: number, options?: {
-        ignoreHooks: boolean;
-    }): Promise<PaginatedData<T, A, R>>;
-    select<S extends string>(...columns: SelectableColumn<S>[]): this;
-    select(...columns: (ModelKey<T> | "*")[]): this;
+    pluck<K extends ModelKey<T>>(key: K): Promise<PluckReturnType<T, K>>;
     /**
-     * @description Annotates a column with a SQL method or a simple alias
-     * @description If the alias matches a model field name, it overrides that field. Otherwise, it's available in $annotations
-     * @example
-     * ```ts
-     * const user = await User.query().annotate("max", "id", "maxId").one(); // max(id) as maxId
-     * const user = await User.query().annotate("id", "superId").one(); // id as superId
-     * // If alias matches model field, it overrides it:
-     * const user = await User.query().annotate("COUNT(*)", "email").one(); // user.email is now a number
-     * ```
+     * @description Executes the query and retrieves a single result.
      */
-    annotate<K extends string, V = any>(column: string, alias: K): AnnotationResult<T, A, R, K, V>;
-    annotate<K extends string, S extends SqlMethod, V = CommonSqlMethodReturnType<S>>(sqlMethod: string, column: string, alias: K): AnnotationResult<T, A, R, K, V>;
-    annotate<K extends string, S extends SqlMethod, V = CommonSqlMethodReturnType<S>>(sqlMethod: S, column: string, alias: K): AnnotationResult<T, A, R, K, V>;
-    annotate<K extends string, S extends SqlMethod, V = CommonSqlMethodReturnType<S>>(sqlMethod: S, column: string, alias: K): AnnotationResult<T, A, R, K, V>;
+    one(): Promise<T | null>;
     /**
-     * @description Selects a JSON value at the specified path and returns it as JSON
-     * @param column The column containing JSON data
-     * @param path The JSON path to extract (standardized format: "$.user.name", "user.name", or ["user", "name"])
-     * @param alias The alias for the selected value
-     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description If alias matches a model field, it overrides that field. Otherwise, it's in $annotations
+     * @description Executes the query and retrieves the first result. Fail if no result is found.
+     */
+    oneOrFail(): Promise<T>;
+    /**
+     * @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
+     */
+    stream<M extends Model = T>(options?: StreamOptions): Promise<PassThrough & AsyncGenerator<M>>;
+    /**
+     * @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
-     * ```ts
-     * // All these path formats are supported:
-     *
-     * // 1. With $ prefix (standard JSON path)
-     * await User.query().selectJson("data", "$.user.name", "userName").one();
-     *
-     * // 2. Without $ prefix ($ is optional)
-     * await User.query().selectJson("data", "user.name", "userName").one();
-     *
-     * // 3. Array format
-     * await User.query().selectJson("data", ["user", "name"], "userName").one();
-     *
-     * // 4. Array indices with dot notation
-     * await User.query().selectJson("data", "items.0.name", "firstItemName").one();
-     *
-     * // 5. Array indices with array format
-     * await User.query().selectJson("data", ["items", 0, "name"], "firstItemName").one();
-     *
-     * // 6. Root object
-     * await User.query().selectJson("data", "$", "allData").one();
+     * 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);
      *
-     * // Access the result - in $annotations if not a model field
-     * const user = await User.query().selectJson("data", "user.name", "userName").one();
-     * console.log(user?.$annotations?.userName); // Typed as any
+     * @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);
+     * }
      *
-     * // If alias matches model field, it overrides it
-     * const user2 = await User.query().selectJson("data", "$.name", "email").one();
-     * console.log(user2?.email); // Overrides model's email field
-     * ```
+     * console.log(chunks);
      */
-    selectJson<K extends string>(column: ModelKey<T>, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, any>;
-    selectJson<K extends string>(column: string, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, any>;
+    chunk(chunkSize: number): AsyncGenerator<T[], void, unknown>;
     /**
-     * @description Selects a JSON value at the specified path and returns it as text
-     * @param column The column containing JSON data
-     * @param path The JSON path to extract (standardized format)
-     * @param alias The alias for the selected value
-     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description If alias matches a model field, it overrides that field. Otherwise, it's in $annotations
-     * @example
-     * ```ts
-     * // All these path formats are supported:
-     *
-     * // 1. With $ prefix
-     * await User.query().selectJsonText("data", "$.user.email", "userEmail").one();
-     *
-     * // 2. Without $ prefix
-     * await User.query().selectJsonText("data", "user.email", "userEmail").one();
-     *
-     * // 3. Array format
-     * await User.query().selectJsonText("data", ["user", "email"], "userEmail").one();
-     *
-     * // 4. Array indices
-     * await User.query().selectJsonText("data", "tags.0", "firstTag").one();
-     * await User.query().selectJsonText("data", ["tags", 0], "firstTag").one();
-     *
-     * // 5. Deep nesting
-     * await User.query().selectJsonText("data", "user.profile.bio", "biography").one();
-     *
-     * // Access the result - in $annotations if not a model field
-     * const user = await User.query().selectJsonText("data", "user.email", "userEmail").one();
-     * console.log(user?.$annotations?.userEmail); // Typed as string
-     * ```
+     * @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
      */
-    selectJsonText<K extends string>(column: ModelKey<T>, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, string>;
-    selectJsonText<K extends string>(column: string, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, string>;
+    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T>, Cursor<T, K>]>;
     /**
-     * @description Selects the length of a JSON array
-     * @param column The column containing JSON array data
-     * @param path The JSON path to the array (standardized format, use "$" or "" for root)
-     * @param alias The alias for the length value
-     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description If alias matches a model field, it overrides that field. Otherwise, it's in $annotations
-     * @warning Not supported in SQLite
-     * @example
-     * ```ts
-     * // All these path formats are supported:
-     *
-     * // 1. With $ prefix
-     * await User.query().selectJsonArrayLength("data", "$.items", "itemCount").one();
-     *
-     * // 2. Without $ prefix
-     * await User.query().selectJsonArrayLength("data", "items", "itemCount").one();
-     *
-     * // 3. Array format
-     * await User.query().selectJsonArrayLength("data", ["items"], "itemCount").one();
-     *
-     * // 4. Root array (use "$" or "")
-     * await User.query().selectJsonArrayLength("data", "$", "totalCount").one();
-     * await User.query().selectJsonArrayLength("data", "", "totalCount").one();
-     *
-     * // 5. Nested arrays
-     * await User.query().selectJsonArrayLength("data", "user.roles", "roleCount").one();
-     * await User.query().selectJsonArrayLength("data", ["user", "roles"], "roleCount").one();
-     *
-     * // 6. Deeply nested arrays
-     * await User.query().selectJsonArrayLength("data", "level1.level2.items", "deepCount").one();
-     *
-     * // Access the result - in $annotations if not a model field
-     * const user = await User.query().selectJsonArrayLength("data", "items", "count").one();
-     * console.log(user?.$annotations?.count); // Typed as number
-     * ```
+     * @description Selects a subquery, subquery must return a single column
      */
-    selectJsonArrayLength<K extends string>(column: ModelKey<T>, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, number>;
-    selectJsonArrayLength<K extends string>(column: string, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, number>;
+    selectSubQuery(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: string): this;
     /**
-     * @description Selects the keys of a JSON object
-     * @param column The column containing JSON object data
-     * @param path The JSON path to the object (standardized format, use "$" or "" for root)
-     * @param alias The alias for the keys
-     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
-     * @description If alias matches a model field, it overrides that field. Otherwise, it's in $annotations
-     * @warning Not supported in SQLite or MSSQL
-     * @postgresql Returns a native array of keys
-     * @mysql Returns a JSON array of keys
-     * @example
-     * ```ts
-     * // All these path formats are supported:
-     *
-     * // 1. With $ prefix
-     * await User.query().selectJsonKeys("data", "$.settings", "settingKeys").one();
-     *
-     * // 2. Without $ prefix
-     * await User.query().selectJsonKeys("data", "settings", "settingKeys").one();
-     *
-     * // 3. Array format
-     * await User.query().selectJsonKeys("data", ["settings"], "settingKeys").one();
-     *
-     * // 4. Root object (use "$" or "")
-     * await User.query().selectJsonKeys("data", "$", "rootKeys").one();
-     * await User.query().selectJsonKeys("data", "", "rootKeys").one();
-     *
-     * // 5. Nested objects
-     * await User.query().selectJsonKeys("data", "user.profile", "profileKeys").one();
-     * await User.query().selectJsonKeys("data", ["user", "profile"], "profileKeys").one();
-     *
-     * // 6. Deeply nested objects
-     * await User.query().selectJsonKeys("data", "settings.display.theme", "themeKeys").one();
-     *
-     * // Access the result - in $annotations if not a model field
-     * const user = await User.query().selectJsonKeys("data", "settings", "keys").one();
-     * console.log(user?.$annotations?.keys); // Typed as any[] - ["theme", "fontSize", "autoSave"]
-     * ```
+     * @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
      */
-    selectJsonKeys<K extends string>(column: ModelKey<T>, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, any[]>;
-    selectJsonKeys<K extends string>(column: string, path: JsonPathInput, alias: K): AnnotationResult<T, A, R, K, any[]>;
+    lockForUpdate(options?: {
+        skipLocked?: boolean;
+        noWait?: boolean;
+    }): this;
     /**
-     * @description Adds a raw JSON select expression for database-specific operations
-     * @param raw The raw SQL expression (database-specific syntax)
-     * @param alias The alias for the selected value
-     * @description If alias matches a model field, it overrides that field. Otherwise, it's in $annotations
-     * @description Use this for advanced JSON operations not covered by other selectJson* methods
-     * @warning This bypasses path standardization - you must write database-specific SQL
-     * @example
-     * ```ts
-     * // PostgreSQL - Extract as text with ->> operator
-     * await User.query().selectJsonRaw("data->>'email'", "userEmail").one();
-     *
-     * // PostgreSQL - Extract nested JSON with -> operator
-     * await User.query().selectJsonRaw("data->'user'->'profile'->>'name'", "profileName").one();
-     *
-     * // PostgreSQL - Array element access
-     * await User.query().selectJsonRaw("data->'items'->0->>'name'", "firstName").one();
-     *
-     * // MySQL - Extract value with JSON_EXTRACT and ->>
-     * await User.query().selectJsonRaw("data->>'$.email'", "userEmail").one();
-     *
-     * // MySQL - Array length with JSON_LENGTH
-     * await User.query().selectJsonRaw("JSON_LENGTH(data, '$.items')", "itemCount").one();
-     *
-     * // MSSQL - Extract value with JSON_VALUE
-     * await User.query().selectJsonRaw("JSON_VALUE(data, '$.email')", "userEmail").one();
-     *
-     * // SQLite - Extract value with json_extract
-     * await User.query().selectJsonRaw("json_extract(data, '$.email')", "userEmail").one();
-     *
-     * // Access the result - in $annotations if not a model field
-     * const user = await User.query().selectJsonRaw("data->>'email'", "userEmail").one();
-     * console.log(user?.$annotations?.userEmail); // Typed as any
-     * ```
+     * @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
      */
-    selectJsonRaw<K extends string>(raw: string, alias: K): AnnotationResult<T, A, R, K, any>;
+    forShare(options?: {
+        skipLocked?: boolean;
+        noWait?: boolean;
+    }): this;
     /**
-     * @description Removes annotations from the serialized model, by default, annotations are maintained in the serialized model if `annotate` is used
+     * @description Adds a UNION to the query.
      */
-    removeAnnotations(): ModelQueryBuilder<T, {}>;
+    union(query: string, bindings?: any[]): this;
+    union(cb: UnionCallBack<T>): this;
     /**
-     * @description Fills the relations in the model in the serialized response. Relation must be defined in the model.
-     * @warning Many to many relations have special behavior, since they require a join, a join clause will always be added to the query.
-     * @warning Many to many relations uses the model foreign key for mapping in the `$annotations` property, this property will be removed from the model after the relation is filled.
-     * @warning Foreign keys should always be selected in the relation query builder, otherwise the relation will not be filled.
-     * @mssql HasMany relations with limit/offset and orderByRaw may fail with "Ambiguous column name" error - use fully qualified column names (e.g., `table.column`) in orderByRaw
-     * @cockroachdb HasMany relations with limit/offset and orderByRaw may fail with "Ambiguous column name" error - use fully qualified column names (e.g., `table.column`) in orderByRaw
+     * @description Adds a UNION ALL to the query.
      */
-    load<RelationKey extends ModelRelation<T>, IA extends Record<string, any> = {}, IR extends Record<string, any> = {}>(relation: RelationKey, cb: (queryBuilder: RelationQueryBuilderType<RelatedInstance<T, RelationKey>>) => RelationQueryBuilderType<RelatedInstance<T, RelationKey>, IA, IR>): ModelQueryBuilder<T, A, R & {
-        [K in RelationKey]: Awaited<ReturnType<ModelQueryBuilder<RelatedInstance<T, K>, IA, IR>[RelationRetrieveMethod<T[K]>]>>;
-    }>;
-    load<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: RelationQueryBuilderType<RelatedInstance<T, RelationKey>>) => void): ModelQueryBuilder<T, A, R & {
-        [K in RelationKey]: Awaited<ReturnType<ModelQueryBuilder<RelatedInstance<T, K>, {}, {}>[RelationRetrieveMethod<T[K]>]>>;
-    }>;
+    unionAll(query: string, bindings?: any[]): this;
+    unionAll(cb: UnionCallBack<T>): this;
+    unionAll(queryBuilder: QueryBuilder<any>): this;
     /**
-     * @description Clears the relations from the query builder
+     * @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
      */
-    clearRelations(): this;
+    increment(column: string, value: number): Promise<number>;
+    increment(column: NumberModelKey<T>, value: number): Promise<number>;
     /**
-     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation
-     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the 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 the number of affected rows
      */
-    havingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
-    havingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
+    decrement(column: string, value: number): Promise<number>;
+    decrement(column: NumberModelKey<T>, value: number): Promise<number>;
     /**
-     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation
-     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the 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.
      */
-    andHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
-    andHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
+    getCount(column?: string): Promise<number>;
     /**
-     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation,
-     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the 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.
      */
-    orHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
-    orHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
+    getMax(column: string): Promise<number>;
     /**
-     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the Relation
-     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the 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.
      */
-    notHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
-    notHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
+    getMin(column: string): Promise<number>;
     /**
-     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the relation
-     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the 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.
      */
-    andNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
-    andNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
+    getAvg(column: string): Promise<number>;
     /**
-     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the Relation
-     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     * @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.
      */
-    orNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
-    orNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
+    getSum(column: string): Promise<number>;
     /**
-     * @description Returns a copy of the query builder instance.
+     * @description Executes the query and retrieves multiple paginated results.
+     * @description Overrides the limit and offset clauses in order to paginate the results.
      */
-    clone(): this;
+    paginate(page: number, perPage: number): Promise<PaginatedData<T>>;
     /**
-     * @description Recursively processes all relations, including nested ones
+     * @description Overrides the from clause in the query.
      */
-    protected processRelationsRecursively(models: T[]): Promise<void>;
-    protected mapRelatedModelsToModels<R extends ModelWithoutRelations<T>>(relation: Relation, modelsToFillWithRelations: T[], relatedModels: R[]): void;
-    protected getRelatedModelsForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): Promise<ModelWithoutRelations<T>[]>;
-    protected getRelatedModelsQueryForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): ModelQueryBuilder<T>;
-    protected getFilterValuesFromModelsForRelation(relation: Relation, models: T[]): any[];
-    protected applyHavingRelatedFilter(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, operator?: BinaryOperatorType, value?: BaseValues): void;
-    protected addAdditionalColumnsToModel(row: any, typeofModel: typeof Model): Record<string, any>;
-    private manyWithPerformance;
-    private oneWithPerformance;
-    private oneOrFailWithPerformance;
-    private firstOrFailWithPerformance;
-    private paginateWithPerformance;
-    private paginateWithCursorWithPerformance;
-    private existsWithPerformance;
-    private pluckWithPerformance;
-    private softDeleteWithPerformance;
-    private updateWithPerformance;
-    private deleteWithPerformance;
-    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;
+    from<S extends string>(table: TableFormat<S>, alias?: string): this;
+    from(cb: (qb: QueryBuilder<T>) => void, alias: string): 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 Adds a CTE to the query using a callback to build the subquery.
      */
-    insert(...args: Parameters<typeof this$1.model.insert<T>>): this;
+    with(alias: string, cb: (qb: QueryBuilder<T>) => void): 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 Adds a recursive CTE to the query using a callback to build the subquery.
+     * @mssql not supported
      */
-    insertMany(...args: Parameters<typeof this$1.model.insertMany<T>>): this;
+    withRecursive(alias: string, cb: (qb: QueryBuilder<T>) => void): 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 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
      */
-    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;
-    protected logs: boolean;
-    protected model: typeof Model;
-    protected modelInstance: T;
-    protected astParser: AstParser;
-    protected interpreterUtils: InterpreterUtils;
-    protected replicationMode: "master" | "slave" | null;
+    withMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
     /**
-     * @description Constructor for ModelManager class.
+     * @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
      */
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    insert(data: Record<string, WriteQueryParam$1>, returning?: string[]): Promise<T>;
     /**
-     * @description Sets the replication mode for queries created by this model manager
+     * @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
      */
-    setReplicationMode(mode: "master" | "slave"): this;
+    insertMany(data: Record<string, WriteQueryParam$1>[], returning?: string[]): Promise<T[]>;
     /**
-     * @description Finds all records that match the input
+     * @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
      */
-    find<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input?: FindType<T, S, R>): Promise<AnnotatedModel<T, {}>[]>;
+    upsert<O extends Record<string, any>>(data: O, searchCriteria: Partial<O>, options?: UpsertOptionsRawBuilder): Promise<T[]>;
     /**
-     * @description Finds the first record that matches the input
+     * @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
      */
-    findOne<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: FindOneType<T, S, R>): Promise<AnnotatedModel<T, {}> | null>;
+    upsertMany<O extends Record<string, any>>(conflictColumns: string[], columnsToUpdate: string[], data: O[], options?: UpsertOptionsRawBuilder): Promise<T[]>;
     /**
-     * @description Finds the first record that matches the input or throws an error
+     * @description Executes a MERGE statement for MSSQL upsert operations (raw query builder)
      */
-    findOneOrFail<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: FindOneType<T, S, R>): Promise<AnnotatedModel<T, {}>>;
+    private executeMssqlMergeRaw;
     /**
-     * @description Finds a record by its primary key
-     * @description Ignores all model hooks
-     * @throws {HysteriaError} if the model has no primary key
+     * @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
      */
-    findOneByPrimaryKey(value: string | number, returning?: ModelKey<T>[]): Promise<AnnotatedModel<T, {}> | null>;
+    update(data: Record<string, WriteQueryParam$1>): Promise<number>;
     /**
-     * @description Creates a new record in the database
+     * @description Deletes all records from a table
+     * @warning This operation does not trigger any hook
      */
-    insert(model: Partial<T>, options?: InsertOptions<T>): Promise<AnnotatedModel<T, {}>>;
+    truncate(): Promise<void>;
     /**
-     * @description Creates multiple records in the database
+     * @description Deletes records from a table
+     * @returns the number of affected rows
      */
-    insertMany(models: Partial<T>[], options?: InsertOptions<T>): Promise<AnnotatedModel<T, {}>[]>;
-    upsertMany(conflictColumns: string[], columnsToUpdate: string[], data: ModelWithoutRelations<T>[], options?: UpsertOptions<T>): Promise<AnnotatedModel<T, {}>[]>;
+    delete(): Promise<number>;
     /**
-     * @description Executes a MERGE statement for MSSQL upsert operations
+     * @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
      */
-    private executeMssqlMerge;
+    softDelete(options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">): Promise<number>;
     /**
-     * @description Updates a record, returns the updated record
-     * @description Model is retrieved from the database using the primary key regardless of any model hooks
-     * @description Can only be used if the model has a primary key, use a massive update if the model has no primary key
+     * @description Returns the query with the parameters bound to the query
      */
-    updateRecord(model: Partial<T>, options?: {
-        returning?: ModelKey<T>[];
-    }): Promise<AnnotatedModel<T, {}>>;
+    toQuery(): string;
     /**
-     * @description Deletes a record
-     * @description Can only be used if the model has a primary key, use a massive delete if the model has no primary key
+     * @description Returns the query with database driver placeholders and the params
      */
-    deleteRecord(model: T): Promise<void>;
+    unWrap(): ReturnType<typeof AstParser.prototype.parse>;
     /**
-     * @description Returns a query builder instance
+     * @description Returns a deep clone of the query builder instance.
      */
-    query(): Omit<ModelQueryBuilder<T>, "insert" | "insertMany">;
+    clone(): this;
     /**
-     * @description Returns a dry query builder instance
-     * @description The dry query builder instance will not execute the query, it will return the query statement
+     * @description Gives a fresh instance of the query builder
      */
-    dryQuery(): Omit<DryModelQueryBuilder<T>, "insert" | "insertMany">;
+    clear(): QueryBuilder<any>;
     /**
-     * @description Mysql does not return the inserted model, so we need to get the inserted model from the database
+     * @description Removes the lock query
      */
-    private handleMysqlInsert;
+    clearLockQuery(): this;
     /**
-     * @description Oracle with identity columns doesn't support INSERT ALL properly.
-     * This method inserts records one at a time to avoid duplicate ID issues.
-     * After each insert, it queries the row back using unique columns to get the generated ID.
+     * @description Removes any union query
      */
-    private handleOracleIdentityInsert;
-    private handleWhereCondition;
-    private applyFieldCondition;
-}
-
-type TableColumnInfo = {
-    name: string;
-    dataType: string;
-    isNullable: boolean;
-    defaultValue: string | number | boolean | null;
-    length?: number | null;
-    precision?: number | null;
-    scale?: number | null;
-    withTimezone?: boolean | null;
-};
-type TableIndexInfo = {
-    name: string;
-    columns: string[];
-    isUnique: boolean;
-};
-type TablePrimaryKeyInfo = {
-    name?: string;
-    columns: string[];
-};
-type TableSchemaInfo = {
-    columns: TableColumnInfo[];
-    indexes: TableIndexInfo[];
-    foreignKeys: TableForeignKeyInfo[];
-    primaryKey?: TablePrimaryKeyInfo;
-};
-type TableForeignKeyInfo = {
-    name?: string;
-    columns: string[];
-    referencedTable: string;
-    referencedColumns: string[];
-    onDelete?: string | null;
-    onUpdate?: string | null;
-};
-
-/**
- * @description Maps a SqlDataSourceType to the raw driver response type
- */
-type RawQueryResponseType<D extends SqlDataSourceType> = D extends "mysql" | "mariadb" ? QueryResult : D extends "postgres" | "cockroachdb" ? QueryResult$1 : D extends "sqlite" ? RunResult : D extends "mssql" ? IResult<any> : D extends "oracledb" ? Result<any> : any;
-
-type TransactionIsolationLevel = "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
-type StartTransactionOptions = {
-    isolationLevel?: TransactionIsolationLevel;
-};
-/**
- * @description Options for the transaction execution
- */
-type TransactionExecutionOptions = {
+    clearUnionQuery(): this;
     /**
-     * @description If true, the transaction will throw an error if it is inactive
+     * @description Removes any with query
      */
-    throwErrorOnInactiveTransaction?: boolean;
-};
-
-/**
- * @description Transaction class, not meant to be used directly, use sql.transaction() instead
- */
-declare class Transaction {
+    clearWithQuery(): this;
+    extractQueryNodes(): QueryNode[];
+    protected clearForFunctions(): this;
     /**
-     * @description The sql data source instance that the transaction is running on here you can both query or execute raw queries
-     * @example
-     * ```ts
-     * import { sql } from "hysteria-orm";
-     * import { User } from "./models/user";
-     *
-     * // Raw queries
-     * const trx = await sql.transaction();
-     * await trx.rawQuery("SELECT * FROM users");
-     *
-     * // Model manager
-     * const modelManager = trx.sql.getModelManager(User);
-     * await modelManager.insert({ name: "John Doe" });
-     *
-     * // Query builder
-     * await trx.query(User.table).insert({ name: "John Doe" });
-     *
-     * await trx.commit();
-     * ```
+     * @description Makes a many query and returns the time that took to execute that query
      */
-    sql: Omit<SqlDataSource, "transaction" | "startGlobalTransaction">;
+    private manyWithPerformance;
     /**
-     * @description Whether the transaction is active
+     * @description Makes a one query and returns the time that took to execute that query
      */
-    isActive: boolean;
+    private oneWithPerformance;
     /**
-     * @description The transaction unique identifier
+     * @alias oneOrFailWithPerformance
      */
-    transactionId: string;
-    private connectionReleased;
-    private isolationLevel?;
-    private isNested;
-    private nestingDepth;
-    constructor(sql: SqlDataSource, isolationLevel?: TransactionIsolationLevel, isNested?: boolean, nestingDepth?: number);
+    private firstOrFailWithPerformance;
+    private paginateWithPerformance;
+    private paginateWithCursorWithPerformance;
     /**
-     * @description Creates a new transaction with the same isolation level and same connection using save points
-     * @description If a callback is provided, it will execute the callback and commit or rollback the nested transaction save points based on the callback's success or failure
+     * @description Makes a one or fail query and returns the time that took to execute that query
      */
-    nestedTransaction(): Promise<Transaction>;
-    nestedTransaction(cb: (trx: Transaction) => Promise<void>): Promise<void>;
+    private oneOrFailWithPerformance;
     /**
-     * @description Starts a transaction, automatically handled from the sql data source instance in the `transaction` method
+     * @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
      */
-    transaction(): Promise<void>;
+    private existsWithPerformance;
+    private pluckWithPerformance;
+    private updateWithPerformance;
+    private insertWithPerformance;
+    private insertManyWithPerformance;
+    private softDeleteWithPerformance;
+    private deleteWithPerformance;
+    private truncateWithPerformance;
     /**
-     * @description Commit the transaction releasing the connection
-     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
-     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
+     * @description Checks if the current context is an MSSQL transaction
+     * @description MSSQL transactions can only handle one request at a time
      */
-    commit(options?: TransactionExecutionOptions): Promise<void>;
+    protected isMssqlTransaction(): boolean;
     /**
-     * @description Rollback the transaction releasing the connection
-     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
-     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
+     * @description Executes pagination queries, serializing them for MSSQL transactions
      */
-    rollback(options?: TransactionExecutionOptions): Promise<void>;
+    protected executePaginateQueries<M, C>(modelsQuery: () => Promise<M>, countQuery: () => Promise<C>): Promise<[M, C]>;
+    protected getSqlDataSource(mode: "read" | "write"): Promise<SqlDataSource>;
     /**
-     * @description Release the connection, does nothing if the connection is already released
+     * @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
      */
-    private releaseConnection;
-    private getIsolationLevelQuery;
-    private getSavePointName;
-    private getMssqlTransactionLevel;
+    protected execSqlWithSlaveHandling<R>(mode: "read" | "write", operation: (dataSource: SqlDataSource) => Promise<R>): Promise<R>;
 }
 
 /**
- * @description The SqlDataSource class is the main class for interacting with the database, it's used to create connections, execute queries, and manage transactions
- * @example
- * ```ts
- * // Create and connect to a database
- * const sql = new SqlDataSource({
- *   type: "mysql",
- *   host: "localhost",
- *   username: "root",
- *   password: "password",
- *   database: "mydb",
- *   models: { User, Post }
- * });
- * await sql.connect();
- *
- * // Now you can use the connection
- * const users = await sql.query("users").many();
- * ```
+ * Allows to get queries without executing them
  */
-declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> extends DataSource {
-    #private;
-    private globalTransaction;
-    private sqlType;
-    private _models;
-    private ownsPool;
+declare class DryQueryBuilder extends QueryBuilder {
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    many(): this;
     /**
-     * @description The slaves data sources to use for the sql data source, slaves are automatically used for read operations unless specified otherwise
+     * @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
      */
-    slaves: SqlDataSource<D, T, C>[];
+    insert(...args: Parameters<typeof QueryBuilder.prototype.insert>): this;
     /**
-     * @description The algorithm to use for selecting the slave for read operations
-     * @default "roundRobin" - Distributes requests evenly across all slaves in sequence
-     * @option "random" - Randomly selects a slave for each request
+     * @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
      */
-    slaveAlgorithm: SlaveAlgorithm;
+    insertMany(...args: Parameters<typeof QueryBuilder.prototype.insertMany>): this;
     /**
-     * @description The current index for round-robin slave selection
-     * @private
+     * @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
      */
-    private roundRobinIndex;
+    upsert(...args: Parameters<typeof QueryBuilder.prototype.upsert>): this;
+    upsertMany(...args: Parameters<typeof QueryBuilder.prototype.upsertMany>): this;
     /**
-     * @description The pool of connections for the database
+     * @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
      */
-    sqlPool: SqlPoolType | null;
+    update(data: Record<string, WriteQueryParam>): this;
     /**
-     * @description Only used in transaction context to specify the connection, not meant to be used directly
-     * @private
+     * @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
      */
-    sqlConnection: GetConnectionReturnType<D> | null;
+    delete(): this;
     /**
-     * @description Options provided in the sql data source initialization
+     * @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
+     */
+    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(options?: Omit<SoftDeleteOptions<any>, "ignoreBeforeDeleteHook">): this;
+}
+
+type PluckReturnType<T extends Model, K extends ModelKey<T>> = T[K] extends infer U ? U[] : never;
+type WhereOnlyQueryBuilder<T extends Model> = Pick<WhereQueryBuilder<T>, "where" | "andWhere" | "orWhere" | "whereNot" | "andWhereNot" | "orWhereNot" | "whereIn" | "andWhereIn" | "orWhereIn" | "whereNotIn" | "andWhereNotIn" | "orWhereNotIn" | "whereBetween" | "andWhereBetween" | "orWhereBetween" | "whereNotBetween" | "andWhereNotBetween" | "orWhereNotBetween" | "whereNull" | "andWhereNull" | "orWhereNull" | "whereNotNull" | "andWhereNotNull" | "orWhereNotNull" | "whereLike" | "andWhereLike" | "orWhereLike" | "whereILike" | "andWhereILike" | "orWhereILike" | "whereNotLike" | "andWhereNotLike" | "orWhereNotLike" | "whereNotILike" | "andWhereNotILike" | "orWhereNotILike" | "whereRegexp" | "andWhereRegexp" | "orWhereRegexp" | "whereNotRegexp" | "andWhereNotRegexp" | "orWhereNotRegexp" | "whereRaw" | "andWhereRaw" | "orWhereRaw" | "whereExists" | "orWhereExists" | "andWhereExists"> & Pick<JsonQueryBuilder<T>, "whereJson" | "andWhereJson" | "orWhereJson" | "whereJsonContains" | "andWhereJsonContains" | "orWhereJsonContains" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains" | "whereJsonRaw" | "andWhereJsonRaw" | "orWhereJsonRaw" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains">;
+type RelationRetrieveMethod<P extends any> = P extends any[] ? "many" : "one";
+type SelectableColumn$1<T extends string = string> = T extends `${infer Table}.${infer Column}.${string}` ? never : T extends `${string}(${string})` ? T : T extends `${string} as ${string}` ? T : T extends `${string} ${string}` ? never : T extends `.${string}` | `${string}.` ? never : T extends `${string}-${string}` ? never : T extends `${string}.${string}` ? T : T;
+/**
+ * @description A column that can be used in a join statement e.g. `users.id`
+ */
+type JoinableColumn = `${string}.${string}`;
+/**
+ * @description Options for streaming queries
+ * @sqlite Ignores the options below
+ */
+type StreamOptions = {
+    highWaterMark?: number;
+    /** Postgres only */
+    rowMode?: "array";
+    /** Postgres only */
+    batchSize?: number;
+    /** Postgres only */
+    types?: any;
+    /** Mysql only */
+    objectMode?: boolean;
+};
+type Cursor<T extends Model, K extends ModelKey<T>> = {
+    key: K;
+    value: string | number;
+};
+type PaginateWithCursorOptions<T extends Model, K extends ModelKey<T>> = {
+    discriminator: K;
+    operator?: "<" | ">";
+    orderBy?: "asc" | "desc";
+};
+type UpsertOptionsRawBuilder = {
+    updateOnConflict?: boolean;
+    returning?: string[];
+};
+type DryQueryBuilderWithoutReadOperations = Omit<DryQueryBuilder, "many" | "one" | "oneOrFail" | "first" | "firstOrFail" | "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" | "first" | "firstOrFail" | "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;
+
+declare class SqlModelManagerUtils<T extends Model> {
+    protected dbType: SqlDataSourceType;
+    protected sqlDataSource: SqlDataSource;
+    protected modelRelations: Relation[];
+    protected modelRelationsMap: Map<string, Relation>;
+    constructor(typeofModel: typeof Model, dbType: SqlDataSourceType, sqlDataSource: SqlDataSource);
+    getRelationFromModel(relation: ModelRelation<T>): Relation;
+}
+
+type UpdateOptions = {
+    ignoreBeforeUpdateHook?: boolean;
+};
+
+/**
+ * @description Due to query limitations some query builder methods may not be available in a RelationQueryBuilder
+ */
+type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "first" | "firstOrFail" | "paginate" | "pluck" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
+
+declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> = ModelWithoutRelations<T>, R extends Record<string, any> = {}> extends QueryBuilder<T> {
+    relation: Relation;
+    protected sqlModelManagerUtils: SqlModelManagerUtils<T>;
+    protected relationQueryBuilders: ModelQueryBuilder<any>[];
+    protected modelSelectedColumns: string[];
+    private modelColumnsMap;
+    private modelColumnsDatabaseNames;
+    protected limitValue?: number;
+    protected offsetValue?: number;
+    performance: {
+        many: (options?: ManyOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: SelectedModel<S, R>[];
+            time: number;
+        }>;
+        one: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: SelectedModel<S, R> | null;
+            time: number;
+        }>;
+        oneOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: SelectedModel<S, R>;
+            time: number;
+        }>;
+        paginate: (page: number, perPage: number, options?: {
+            ignoreHooks?: boolean;
+        }, returnType?: "millis" | "seconds") => Promise<{
+            data: PaginatedData<T, S, R>;
+            time: number;
+        }>;
+        exists: (returnType?: "millis" | "seconds") => Promise<{
+            data: boolean;
+            time: number;
+        }>;
+        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
+            data: [CursorPaginatedData<T, S, R>, Cursor<T, ModelKey<T>>];
+            time: number;
+        }>;
+        truncate: (returnType?: "millis" | "seconds") => Promise<{
+            data: void;
+            time: number;
+        }>;
+        delete: (returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        update: (data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions, 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 Returns true if the query builder is a relation query builder, this changes the behavior of the query builder like limit, offset, etc.
+     * @internal
+     */
+    protected get isRelationQueryBuilder(): boolean;
+    /**
+     * @description Creates a new ModelQueryBuilder instance from a model. Will use the main connection to the database by default.
+     */
+    static from(model: typeof Model, options?: BaseModelMethodOptions): ModelQueryBuilder<InstanceType<typeof model>>;
+    one(options?: OneOptions): Promise<SelectedModel<S, R> | null>;
+    oneOrFail(options?: {
+        ignoreHooks?: OneOptions["ignoreHooks"] & {
+            customError?: Error;
+        };
+    }): Promise<SelectedModel<S, R>>;
+    firstOrFail(options?: {
+        ignoreHooks?: OneOptions["ignoreHooks"] & {
+            customError?: Error;
+        };
+    }): Promise<SelectedModel<S, R>>;
+    many(options?: ManyOptions): Promise<SelectedModel<S, R>[]>;
+    chunk(chunkSize: number, options?: ManyOptions): AsyncGenerator<SelectedModel<S, R>[]>;
+    stream(options?: ManyOptions & StreamOptions): Promise<PassThrough & AsyncGenerator<SelectedModel<S, R>>>;
+    paginateWithCursor<K extends ModelKey<T>>(page: number, options?: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T, S, R>, Cursor<T, K>]>;
+    /**
+     * @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>;
+    /**
+     * @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>;
+    getCount(column?: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getMax(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getMin(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getAvg(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getSum(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    paginate(page: number, perPage: number, options?: {
+        ignoreHooks: boolean;
+    }): Promise<PaginatedData<T, S, R>>;
+    /**
+     * @description Adds columns to the SELECT clause with full type safety.
+     * @description Supports formats: "column", "table.column", "column as alias", "*", "table.*"
+     * @description When columns are selected, the return type reflects only those columns
+     * @example
+     * ```ts
+     * // Select specific columns - return type is { id: number, name: string }
+     * const users = await User.query().select("id", "name").many();
+     *
+     * // Select with alias - return type includes the alias
+     * const users = await User.query().select("id as userId").many();
+     *
+     * // Select all - return type is the full model
+     * const users = await User.query().select("*").many();
+     * ```
+     */
+    select<Columns extends readonly SelectableColumn<T>[]>(...columns: Columns): ModelQueryBuilder<T, ComposeBuildSelect<S, T, Columns extends readonly string[] ? Columns : readonly string[]>, R>;
+    /**
+     * @description Adds a raw SELECT statement with type-safe return type.
+     * @description Use the generic parameter to specify the type of the selected columns.
+     * @example
+     * ```ts
+     * // Select raw with type - return type includes the typed columns
+     * const users = await User.query()
+     *   .selectRaw<{ count: number }>("count(*) as count")
+     *   .many();
+     * // users[0].count is typed as number
+     *
+     * // Can be chained with other selects
+     * const users = await User.query()
+     *   .select("id")
+     *   .selectRaw<{ total: number }>("sum(amount) as total")
+     *   .many();
+     * // users[0] is { id: number, total: number }
+     * ```
+     */
+    selectRaw<Added extends Record<string, any> = Record<string, any>>(statement: string): ModelQueryBuilder<T, ComposeSelect<S, Added>, R>;
+    /**
+     * @description Selects a subquery with a typed alias
+     * @param cbOrQueryBuilder A callback that receives a QueryBuilder or a QueryBuilder instance
+     * @param alias The alias for the subquery result
+     * @description Subquery must return a single column
+     * @example
+     * ```ts
+     * const users = await User.query()
+     *   .select("id")
+     *   .selectSubQuery<number, "postCount">((subQuery) => {
+     *     subQuery
+     *       .select("COUNT(*)")
+     *       .from("posts")
+     *       .whereColumn("posts.user_id", "users.id");
+     *   }, "postCount")
+     *   .many();
+     * // users[0].postCount is typed as number
+     * ```
+     */
+    selectSubQuery<ValueType = any, Alias extends string = string>(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: ValueType;
+    }>, R>;
+    /**
+     * @description Clears the SELECT clause and resets to default model type
+     * @example
+     * ```ts
+     * const users = await User.query()
+     *   .select("id")
+     *   .clearSelect() // Resets to selecting all model columns
+     *   .many();
+     * ```
+     */
+    clearSelect(): ModelQueryBuilder<T, ModelWithoutRelations<T>, R>;
+    /**
+     * @description Selects a JSON value at the specified path and returns it as JSON
+     * @param column The column containing JSON data
+     * @param path The JSON path to extract (standardized format: "$.user.name", "user.name", or ["user", "name"])
+     * @param alias The alias for the selected value
+     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
+     * @description Result is available as a direct property on the model with the alias name
+     * @example
+     * ```ts
+     * // All these path formats are supported:
+     *
+     * // 1. With $ prefix (standard JSON path)
+     * await User.query().selectJson("data", "$.user.name", "userName").one();
+     *
+     * // 2. Without $ prefix ($ is optional)
+     * await User.query().selectJson("data", "user.name", "userName").one();
+     *
+     * // 3. Array format
+     * await User.query().selectJson("data", ["user", "name"], "userName").one();
+     *
+     * // 4. Array indices with dot notation
+     * await User.query().selectJson("data", "items.0.name", "firstItemName").one();
+     *
+     * // 5. Array indices with array format
+     * await User.query().selectJson("data", ["items", 0, "name"], "firstItemName").one();
+     *
+     * // 6. Root object
+     * await User.query().selectJson("data", "$", "allData").one();
+     *
+     * // Access the result directly on the model
+     * const user = await User.query().selectJson<string, "userName">("data", "user.name", "userName").one();
+     * console.log(user?.userName); // Typed as string
+     * ```
+     */
+    selectJson<ValueType = any, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: ValueType;
+    }>, R>;
+    /**
+     * @description Selects a JSON value at the specified path and returns it as text
+     * @param column The column containing JSON data
+     * @param path The JSON path to extract (standardized format)
+     * @param alias The alias for the selected value
+     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
+     * @description Result is available as a direct property on the model with the alias name
+     * @example
+     * ```ts
+     * // All these path formats are supported:
+     *
+     * // 1. With $ prefix
+     * await User.query().selectJsonText("data", "$.user.email", "userEmail").one();
+     *
+     * // 2. Without $ prefix
+     * await User.query().selectJsonText("data", "user.email", "userEmail").one();
+     *
+     * // 3. Array format
+     * await User.query().selectJsonText("data", ["user", "email"], "userEmail").one();
+     *
+     * // 4. Array indices
+     * await User.query().selectJsonText("data", "tags.0", "firstTag").one();
+     * await User.query().selectJsonText("data", ["tags", 0], "firstTag").one();
+     *
+     * // 5. Deep nesting
+     * await User.query().selectJsonText("data", "user.profile.bio", "biography").one();
+     *
+     * // Access the result directly on the model
+     * const user = await User.query().selectJsonText<string, "userEmail">("data", "user.email", "userEmail").one();
+     * console.log(user?.userEmail); // Typed as string
+     * ```
+     */
+    selectJsonText<ValueType = string, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: ValueType;
+    }>, R>;
+    /**
+     * @description Selects the length of a JSON array
+     * @param column The column containing JSON array data
+     * @param path The JSON path to the array (standardized format, use "$" or "" for root)
+     * @param alias The alias for the length value
+     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
+     * @description Result is available as a direct property on the model with the alias name
+     * @warning Not supported in SQLite
+     * @example
+     * ```ts
+     * // All these path formats are supported:
+     *
+     * // 1. With $ prefix
+     * await User.query().selectJsonArrayLength("data", "$.items", "itemCount").one();
+     *
+     * // 2. Without $ prefix
+     * await User.query().selectJsonArrayLength("data", "items", "itemCount").one();
+     *
+     * // 3. Array format
+     * await User.query().selectJsonArrayLength("data", ["items"], "itemCount").one();
+     *
+     * // 4. Root array (use "$" or "")
+     * await User.query().selectJsonArrayLength("data", "$", "totalCount").one();
+     * await User.query().selectJsonArrayLength("data", "", "totalCount").one();
+     *
+     * // 5. Nested arrays
+     * await User.query().selectJsonArrayLength("data", "user.roles", "roleCount").one();
+     * await User.query().selectJsonArrayLength("data", ["user", "roles"], "roleCount").one();
+     *
+     * // 6. Deeply nested arrays
+     * await User.query().selectJsonArrayLength("data", "level1.level2.items", "deepCount").one();
+     *
+     * // Access the result directly on the model
+     * const user = await User.query().selectJsonArrayLength<number, "count">("data", "items", "count").one();
+     * console.log(user?.count); // Typed as number
+     * ```
+     */
+    selectJsonArrayLength<ValueType = number, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: ValueType;
+    }>, R>;
+    /**
+     * @description Selects the keys of a JSON object
+     * @param column The column containing JSON object data
+     * @param path The JSON path to the object (standardized format, use "$" or "" for root)
+     * @param alias The alias for the keys
+     * @description Path format is standardized across all databases - ORM converts to DB-specific syntax
+     * @description Result is available as a direct property on the model with the alias name
+     * @warning Not supported in SQLite or MSSQL
+     * @postgresql Returns a native array of keys
+     * @mysql Returns a JSON array of keys
+     * @example
+     * ```ts
+     * // All these path formats are supported:
+     *
+     * // 1. With $ prefix
+     * await User.query().selectJsonKeys("data", "$.settings", "settingKeys").one();
+     *
+     * // 2. Without $ prefix
+     * await User.query().selectJsonKeys("data", "settings", "settingKeys").one();
+     *
+     * // 3. Array format
+     * await User.query().selectJsonKeys("data", ["settings"], "settingKeys").one();
+     *
+     * // 4. Root object (use "$" or "")
+     * await User.query().selectJsonKeys("data", "$", "rootKeys").one();
+     * await User.query().selectJsonKeys("data", "", "rootKeys").one();
+     *
+     * // 5. Nested objects
+     * await User.query().selectJsonKeys("data", "user.profile", "profileKeys").one();
+     * await User.query().selectJsonKeys("data", ["user", "profile"], "profileKeys").one();
+     *
+     * // 6. Deeply nested objects
+     * await User.query().selectJsonKeys("data", "settings.display.theme", "themeKeys").one();
+     *
+     * // Access the result directly on the model
+     * const user = await User.query().selectJsonKeys<string[], "keys">("data", "settings", "keys").one();
+     * console.log(user?.keys); // Typed as string[] - ["theme", "fontSize", "autoSave"]
+     * ```
      */
-    inputDetails: SqlDataSourceInput<D, T, C>;
+    selectJsonKeys<ValueType = string[], Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: ValueType;
+    }>, R>;
     /**
-     * @description Adapter for `useCache`, uses an in memory strategy by default
+     * @description Adds a raw JSON select expression for database-specific operations
+     * @param raw The raw SQL expression (database-specific syntax)
+     * @param alias The alias for the selected value
+     * @description Result is available as a direct property on the model with the alias name
+     * @description Use this for advanced JSON operations not covered by other selectJson* methods
+     * @warning This bypasses path standardization - you must write database-specific SQL
+     * @example
+     * ```ts
+     * // PostgreSQL - Extract as text with ->> operator
+     * await User.query().selectJsonRaw("data->>'email'", "userEmail").one();
+     *
+     * // PostgreSQL - Extract nested JSON with -> operator
+     * await User.query().selectJsonRaw("data->'user'->'profile'->>'name'", "profileName").one();
+     *
+     * // PostgreSQL - Array element access
+     * await User.query().selectJsonRaw("data->'items'->0->>'name'", "firstName").one();
+     *
+     * // MySQL - Extract value with json_extract and ->>
+     * await User.query().selectJsonRaw("data->>'$.email'", "userEmail").one();
+     *
+     * // MySQL - Array length with json_length
+     * await User.query().selectJsonRaw("json_length(data, '$.items')", "itemCount").one();
+     *
+     * // MSSQL - Extract value with json_value
+     * await User.query().selectJsonRaw("json_value(data, '$.email')", "userEmail").one();
+     *
+     * // SQLite - Extract value with json_extract
+     * await User.query().selectJsonRaw("json_extract(data, '$.email')", "userEmail").one();
+     *
+     * // Access the result directly on the model
+     * const user = await User.query().selectJsonRaw<string, "userEmail">("data->>'email'", "userEmail").one();
+     * console.log(user?.userEmail); // Typed as string
+     * ```
      */
-    cacheAdapter: CacheAdapter;
+    selectJsonRaw<ValueType = any, Alias extends string = string>(raw: string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: ValueType;
+    }>, R>;
     /**
-     * @description Maps global keys to specific handlers for cache handling
+     * @description Selects COUNT(column) with a typed alias
+     * @param column The column to count (use "*" for COUNT(*), supports "table.column" format)
+     * @param alias The alias for the count result
+     * @example
+     * ```ts
+     * // Count all rows
+     * const result = await User.query().selectCount("*", "totalUsers").one();
+     * console.log(result?.totalUsers); // Typed as number
+     *
+     * // Count specific column
+     * const result = await User.query().selectCount("id", "userCount").one();
+     *
+     * // With table prefix
+     * const result = await User.query().selectCount("users.id", "total").one();
+     * ```
      */
-    cacheKeys: C;
+    selectCount<Alias extends string>(column: ModelKey<T> | "*" | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
     /**
-     * @description Migration configuration for the sql data source
+     * @description Selects SUM(column) with a typed alias
+     * @param column The column to sum (supports "table.column" format)
+     * @param alias The alias for the sum result
+     * @example
+     * ```ts
+     * const result = await Order.query().selectSum("amount", "totalAmount").one();
+     * console.log(result?.totalAmount); // Typed as number
+     *
+     * // With table prefix
+     * const result = await Order.query().selectSum("orders.amount", "total").one();
+     * ```
      */
-    migrationConfig: {
-        path: string;
-        tsconfig?: string;
-        lock: boolean;
-        transactional: boolean;
-        lockTimeout?: number;
-    };
+    selectSum<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
     /**
-     * @description Seeder configuration for the sql data source
+     * @description Selects AVG(column) with a typed alias
+     * @param column The column to average (supports "table.column" format)
+     * @param alias The alias for the average result
+     * @example
+     * ```ts
+     * const result = await User.query().selectAvg("age", "averageAge").one();
+     * console.log(result?.averageAge); // Typed as number
+     *
+     * // With table prefix
+     * const result = await User.query().selectAvg("users.age", "avgAge").one();
+     * ```
      */
-    seederConfig: {
-        path: string;
-        tsconfig?: string;
-    };
+    selectAvg<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
     /**
-     * @description AdminJS configuration options
+     * @description Selects MIN(column) with a typed alias
+     * @param column The column to get minimum value (supports "table.column" format)
+     * @param alias The alias for the min result
+     * @example
+     * ```ts
+     * const result = await User.query().selectMin("age", "youngestAge").one();
+     * console.log(result?.youngestAge); // Typed as number
+     *
+     * // With table prefix
+     * const result = await User.query().selectMin("users.age", "minAge").one();
+     * ```
      */
-    private adminJsOptions?;
+    selectMin<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
     /**
-     * @description Cached AdminJS instance
+     * @description Selects MAX(column) with a typed alias
+     * @param column The column to get maximum value (supports "table.column" format)
+     * @param alias The alias for the max result
+     * @example
+     * ```ts
+     * const result = await User.query().selectMax("age", "oldestAge").one();
+     * console.log(result?.oldestAge); // Typed as number
+     *
+     * // With table prefix
+     * const result = await User.query().selectMax("users.age", "maxAge").one();
+     * ```
      */
-    private adminJsInstance?;
+    selectMax<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
     /**
-     * @description Callback to handle slave server failures
+     * @description Fills the relations in the model in the serialized response. Relation must be defined in the model.
+     * @warning Many to many relations have special behavior, since they require a join, a join clause will always be added to the query.
+     * @warning Many to many relations uses the model foreign key for mapping, this property will be removed from the model after the relation is filled.
+     * @warning Foreign keys should always be selected in the relation query builder, otherwise the relation will not be filled.
+     * @mssql HasMany relations with limit/offset and orderByRaw may fail with "Ambiguous column name" error - use fully qualified column names (e.g., `table.column`) in orderByRaw
+     * @cockroachdb HasMany relations with limit/offset and orderByRaw may fail with "Ambiguous column name" error - use fully qualified column names (e.g., `table.column`) in orderByRaw
      */
-    private onSlaveServerFailure?;
+    load<RelationKey extends ModelRelation<T>, IS extends Record<string, any> = ModelWithoutRelations<RelatedInstance<T, RelationKey>>, IR extends Record<string, any> = {}>(relation: RelationKey, cb: (queryBuilder: RelationQueryBuilderType<RelatedInstance<T, RelationKey>, ModelWithoutRelations<RelatedInstance<T, RelationKey>>, {}>) => RelationQueryBuilderType<RelatedInstance<T, RelationKey>, IS, IR>): ModelQueryBuilder<T, S, R & {
+        [K in RelationKey]: Awaited<ReturnType<ModelQueryBuilder<RelatedInstance<T, K>, IS, IR>[RelationRetrieveMethod<T[K]>]>>;
+    }>;
+    load<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: RelationQueryBuilderType<RelatedInstance<T, RelationKey>, ModelWithoutRelations<RelatedInstance<T, RelationKey>>, {}>) => void): ModelQueryBuilder<T, S, R & {
+        [K in RelationKey]: Awaited<ReturnType<ModelQueryBuilder<RelatedInstance<T, K>, ModelWithoutRelations<RelatedInstance<T, K>>, {}>[RelationRetrieveMethod<T[K]>]>>;
+    }>;
     /**
-     * @description Returns the configured slave failure callback
+     * @description Clears the relations from the query builder
      */
-    getOnSlaveServerFailure(): ((error: Error, context: SlaveContext) => void | Promise<void>) | undefined;
+    clearRelations(): this;
     /**
-     * @description Returns the primary instance of the SqlDataSource (set via connect with setPrimary: true)
-     * All models by default will use this instance to execute queries unless you pass a different connection/transaction in the query options
+     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
      */
-    static get instance(): SqlDataSource;
+    havingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    havingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
     /**
-     * @description Creates a secondary database connection that won't be set as the primary instance
-     * @description By default not used by the Models, you have to pass it as a parameter to the Models to use it
-     * @example
-     * ```ts
-     * const secondaryDb = await SqlDataSource.connectToSecondarySource({
-     *   type: "postgres",
-     *   host: "replica.db.com",
-     *   ...
-     * });
-     *
-     * const user = await User.query({ connection: secondaryDb }).many();
-     * ```
+     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
      */
-    static connectToSecondarySource<U extends SqlDataSourceType, M extends Record<string, SqlDataSourceModel> = {}, K extends CacheKeys = {}>(input: Omit<SqlDataSourceInput<U, M, K>, "slaves">, cb?: (sqlDataSource: SqlDataSource<U, M, K>) => Promise<void> | void): Promise<SqlDataSource<U, M, K>>;
+    andHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    andHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
     /**
-     * @description Creates a temporary connection that is automatically closed after the callback is executed
-     * @example
-     * ```ts
-     * await SqlDataSource.useConnection({
-     *   type: "mysql",
-     *   ...connectionData
-     * }, async (sql) => {
-     *   const user = await User.query({ connection: sql }).many();
-     * });
-     * // Connection is automatically closed here
-     * ```
+     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation,
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
      */
-    static useConnection<U extends SqlDataSourceType, M extends Record<string, SqlDataSourceModel> = {}, K extends CacheKeys = {}>(connectionDetails: UseConnectionInput<U, M, K>, cb: (sqlDataSource: SqlDataSource<U, M, K>) => Promise<void>): Promise<void>;
+    orHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    orHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
     /**
-     * @description Closes the primary connection (singleton instance)
+     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the Relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
      */
-    static disconnect(): Promise<void>;
+    notHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    notHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
     /**
-     * @description Starts a global transaction on the primary database connection
-     * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
+     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
      */
-    static startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
+    andNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    andNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
     /**
-     * @description Commits a global transaction on the primary database connection
-     * @throws {HysteriaError} If the global transaction is not started
+     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the Relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
      */
-    static commitGlobalTransaction(): Promise<void>;
+    orNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    orNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType | BaseValues, maybeValue?: BaseValues): this;
     /**
-     * @description Rolls back a global transaction on the primary database connection
-     * @throws {HysteriaError} If the global transaction is not started
+     * @description Returns a copy of the query builder instance.
      */
-    static rollbackGlobalTransaction(): Promise<void>;
+    clone(): this;
     /**
-     * @description Returns true if the primary instance is in a global transaction
+     * @description Recursively processes all relations, including nested ones
      */
-    static get isInGlobalTransaction(): boolean;
+    protected processRelationsRecursively(models: T[]): Promise<void>;
+    protected mapRelatedModelsToModels<R extends ModelWithoutRelations<T>>(relation: Relation, modelsToFillWithRelations: T[], relatedModels: R[]): void;
+    protected getRelatedModelsForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): Promise<ModelWithoutRelations<T>[]>;
+    protected getRelatedModelsQueryForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): ModelQueryBuilder<any, any, any>;
+    protected getFilterValuesFromModelsForRelation(relation: Relation, models: T[]): any[];
+    protected applyHavingRelatedFilter(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, operator?: BinaryOperatorType, value?: BaseValues): void;
+    protected addAdditionalColumnsToModel(row: any, typeofModel: typeof Model): Record<string, any>;
+    private manyWithPerformance;
+    private oneWithPerformance;
+    private oneOrFailWithPerformance;
+    private firstOrFailWithPerformance;
+    private paginateWithPerformance;
+    private paginateWithCursorWithPerformance;
+    private existsWithPerformance;
+    private pluckWithPerformance;
+    private softDeleteWithPerformance;
+    private updateWithPerformance;
+    private deleteWithPerformance;
+    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 Creates a new SqlDataSource instance. Call `.connect()` to establish the connection.
-     * @param input Configuration options for the database connection. If not provided, uses env variables.
-     * @example
-     * ```ts
-     * // With explicit config
-     * const sql = new SqlDataSource({
-     *   type: "mysql",
-     *   host: "localhost",
-     *   username: "root",
-     *   password: "password",
-     *   database: "mydb",
-     *   models: { User, Post }
-     * });
-     * await sql.connect();
-     *
-     * // Using env variables
-     * const sql = new SqlDataSource();
-     * await sql.connect();
-     * ```
+     * @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
      */
-    constructor(input?: SqlDataSourceInput<D, T, C>);
+    insert(...args: Parameters<typeof this$1.model.insert<T>>): this;
     /**
-     * @description Establishes the database connection and sets this instance as the primary connection, it also connects to the slaves if any are configured
-     * @throws {HysteriaError} If the connection is already established, use `SqlDataSource.useConnection` or `SqlDataSource.connectToSecondarySource` for auxiliary connections
-     * @example
-     * ```ts
-     * const sql = new SqlDataSource({ type: "mysql", ... });
-     * await sql.connect();
-     * ```
+     * @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
      */
-    connect(): Promise<void>;
+    insertMany(...args: Parameters<typeof this$1.model.insertMany<T>>): this;
     /**
-     * @description Returns true if the connection is established
+     * @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
      */
-    get isConnected(): boolean;
+    update(...args: Parameters<ReturnType<typeof this$1.model.query<T>>["update"]>): this;
     /**
-     * @description Returns true if this instance is in a global transaction
+     * @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
      */
-    get isInGlobalTransaction(): boolean;
+    delete(...args: Parameters<ReturnType<typeof this$1.model.query<T>>["delete"]>): this;
     /**
-     * @description Returns the models configured on this SqlDataSource instance
+     * @description Builds the truncate query statement without executing it, use 'unWrap' or 'toQuery' to get the query statement
+     * @returns The query builder
      */
-    get models(): T;
+    truncate(): this;
     /**
-     * @description Selects a slave from the pool using the configured algorithm
-     * @returns A slave SqlDataSource instance or null if no slaves are available
+     * @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
      */
-    getSlave(): SqlDataSource<D, T, C> | null;
+    softDelete(...args: Parameters<ReturnType<typeof this$1.model.query<T>>["softDelete"]>): this;
+}
+
+declare class ModelManager<T extends Model> {
+    protected sqlDataSource: SqlDataSource;
+    protected sqlType: SqlDataSourceType;
+    protected logs: boolean;
+    protected model: typeof Model;
+    protected modelInstance: T;
+    protected astParser: AstParser;
+    protected interpreterUtils: InterpreterUtils;
+    protected replicationMode: "master" | "slave" | null;
     /**
-     * @description Uses the cache adapter to get a value from the cache
-     * @param key The key to get the value from
-     * @param args The arguments to pass to the key handler
+     * @description Constructor for ModelManager class.
      */
-    useCache<K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
     /**
-     * @description Uses the cache adapter to get a value from the cache
-     * @param key The key to get the value from
-     * @param ttl The time to live for the value in milliseconds
-     * @param args The arguments to pass to the key handler
+     * @description Sets the replication mode for queries created by this model manager
      */
-    useCache<K extends keyof C>(key: K, ttl: number, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
+    setReplicationMode(mode: "master" | "slave"): this;
     /**
-     * @description Invalidates a value from the cache
-     * @param key The key to invalidate the value from
-     * @param args The arguments to pass to the key handler (required if the handler expects arguments)
+     * @description Finds all records that match the input
      */
-    invalidCache<K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<void>;
-    invalidCache<K extends keyof C>(key: K): Promise<void>;
+    find<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input?: FindType<T, S, R>): Promise<ModelWithoutRelations<T>[]>;
     /**
-     * @description Invalidates all values from the cache starting with the given key
-     * @param key The key to invalidate the values from
+     * @description Finds the first record that matches the input
      */
-    invalidateAllCache(key: string): Promise<void>;
+    findOne<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: FindOneType<T, S, R>): Promise<ModelWithoutRelations<T> | null>;
     /**
-     * @description Clones the SqlDataSource instance
-     * @param options.shouldRecreatePool Whether to recreate the pool of connections for the given driver, by default it's false
-     * @sqlite ignores the shouldRecreatePool option
-     * @returns A new SqlDataSource instance with the same input details
+     * @description Finds the first record that matches the input or throws an error
      */
-    clone(options?: SqlCloneOptions): Promise<this>;
+    findOneOrFail<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: FindOneType<T, S, R>): Promise<ModelWithoutRelations<T>>;
     /**
-     * @description Returns the type of the database
+     * @description Finds a record by its primary key
+     * @description Ignores all model hooks
+     * @throws {HysteriaError} if the model has no primary key
      */
-    getDbType(): D;
+    findOneByPrimaryKey(value: string | number, returning?: ModelKey<T>[]): Promise<ModelWithoutRelations<T> | null>;
     /**
-     * @description Returns a QueryBuilder instance for raw queries
-     * @description Query builder from the SqlDataSource instance returns raw data from the database
-     * @param table The table name to query from
+     * @description Creates a new record in the database
      */
-    query<S extends string>(table: TableFormat<S>, options?: RawModelOptions): QueryBuilder;
+    insert(model: Partial<T>, options?: InsertOptions<T>): Promise<ModelWithoutRelations<T>>;
     /**
-     * @description Returns a DryQueryBuilder instance that returns the query statement without executing
+     * @description Creates multiple records in the database
      */
-    dryQuery<S extends string>(table: TableFormat<S>, options?: RawModelOptions): DryQueryBuilderWithoutReadOperations;
+    insertMany(models: Partial<T>[], options?: InsertOptions<T>): Promise<ModelWithoutRelations<T>[]>;
+    upsertMany(conflictColumns: string[], columnsToUpdate: string[], data: ModelWithoutRelations<T>[], options?: UpsertOptions<T>): Promise<ModelWithoutRelations<T>[]>;
     /**
-     * @description Return the query to alter the given table schema
+     * @description Executes a MERGE statement for MSSQL upsert operations
      */
-    alterTable(...args: Parameters<Schema["alterTable"]>): string[];
+    private executeMssqlMerge;
     /**
-     * @description Return the query to create the given table schema
+     * @description Updates a record, returns the updated record
+     * @description Model is retrieved from the database using the primary key regardless of any model hooks
+     * @description Can only be used if the model has a primary key, use a massive update if the model has no primary key
      */
-    createTable(...args: Parameters<Schema["createTable"]>): string;
+    updateRecord(model: Partial<T>, options?: {
+        returning?: ModelKey<T>[];
+    }): Promise<ModelWithoutRelations<T>>;
     /**
-     * @description Starts a global transaction on the database
-     * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
+     * @description Deletes a record
+     * @description Can only be used if the model has a primary key, use a massive delete if the model has no primary key
      */
-    startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
+    deleteRecord(model: T): Promise<void>;
     /**
-     * @description Commits a global transaction on the database
-     * @throws {HysteriaError} If the global transaction is not started
+     * @description Returns a query builder instance
      */
-    commitGlobalTransaction(options?: TransactionExecutionOptions): Promise<void>;
+    query(): Omit<ModelQueryBuilder<T>, "insert" | "insertMany">;
     /**
-     * @description Rolls back a global transaction on the database
+     * @description Returns a dry query builder instance
+     * @description The dry query builder instance will not execute the query, it will return the query statement
      */
-    rollbackGlobalTransaction(options?: TransactionExecutionOptions): Promise<void>;
+    dryQuery(): Omit<DryModelQueryBuilder<T>, "insert" | "insertMany">;
     /**
-     * @description Starts a transaction on a dedicated connection from the pool
-     * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
-     * @param options.isolationLevel The isolation level to use for the transaction
-     * @sqlite ignores the isolation level
+     * @description Mysql does not return the inserted model, so we need to get the inserted model from the database
      */
-    transaction(options?: StartTransactionOptions): Promise<Transaction>;
-    transaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
+    private handleMysqlInsert;
     /**
-     * @description Returns a ModelManager instance for the given model
+     * @description Oracle with identity columns doesn't support INSERT ALL properly.
+     * This method inserts records one at a time to avoid duplicate ID issues.
+     * After each insert, it queries the row back using unique columns to get the generated ID.
      */
-    getModelManager<M extends Model>(model: {
-        new (): M;
-    } | typeof Model): ModelManager<M>;
+    private handleOracleIdentityInsert;
+    private handleWhereCondition;
+    private applyFieldCondition;
+}
+
+type TableColumnInfo = {
+    name: string;
+    dataType: string;
+    isNullable: boolean;
+    defaultValue: string | number | boolean | null;
+    length?: number | null;
+    precision?: number | null;
+    scale?: number | null;
+    withTimezone?: boolean | null;
+};
+type TableIndexInfo = {
+    name: string;
+    columns: string[];
+    isUnique: boolean;
+};
+type TablePrimaryKeyInfo = {
+    name?: string;
+    columns: string[];
+};
+type TableSchemaInfo = {
+    columns: TableColumnInfo[];
+    indexes: TableIndexInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    primaryKey?: TablePrimaryKeyInfo;
+};
+type TableForeignKeyInfo = {
+    name?: string;
+    columns: string[];
+    referencedTable: string;
+    referencedColumns: string[];
+    onDelete?: string | null;
+    onUpdate?: string | null;
+};
+
+/**
+ * @description Maps a SqlDataSourceType to the raw driver response type
+ */
+type RawQueryResponseType<D extends SqlDataSourceType> = D extends "mysql" | "mariadb" ? QueryResult : D extends "postgres" | "cockroachdb" ? QueryResult$1 : D extends "sqlite" ? RunResult : D extends "mssql" ? IResult<any> : D extends "oracledb" ? Result<any> : any;
+
+type TransactionIsolationLevel = "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+type StartTransactionOptions = {
+    isolationLevel?: TransactionIsolationLevel;
+};
+/**
+ * @description Options for the transaction execution
+ */
+type TransactionExecutionOptions = {
     /**
-     * @description Returns the current raw driver Pool
-     * @throws {HysteriaError} If the connection pool is not established
+     * @description If true, the transaction will throw an error if it is inactive
      */
-    getPool(): getPoolReturnType<D>;
+    throwErrorOnInactiveTransaction?: boolean;
+};
+
+/**
+ * @description Transaction class, not meant to be used directly, use sql.transaction() instead
+ */
+declare class Transaction {
     /**
-     * @description Returns a connection from the pool
-     * @throws {HysteriaError} If the connection is not established
+     * @description The sql data source instance that the transaction is running on here you can both query or execute raw queries
+     * @example
+     * ```ts
+     * import { sql } from "hysteria-orm";
+     * import { User } from "./models/user";
+     *
+     * // Raw queries
+     * const trx = await sql.transaction();
+     * await trx.rawQuery("SELECT * FROM users");
+     *
+     * // Model manager
+     * const modelManager = trx.sql.getModelManager(User);
+     * await modelManager.insert({ name: "John Doe" });
+     *
+     * // Query builder
+     * await trx.query(User.table).insert({ name: "John Doe" });
+     *
+     * await trx.commit();
+     * ```
      */
-    getConnection(): Promise<GetConnectionReturnType<D>>;
+    sql: Omit<SqlDataSource, "transaction" | "startGlobalTransaction">;
     /**
-     * @description Closes the current connection
-     * @description If there is an active global transaction, it will be rolled back
-     * @description Also disconnects all slave connections if any are configured
+     * @description Whether the transaction is active
      */
-    disconnect(): Promise<void>;
+    isActive: boolean;
     /**
-     * @description Returns the connection details
+     * @description The transaction unique identifier
      */
-    getConnectionDetails(): SqlDataSourceInput<D, T, C>;
+    transactionId: string;
+    private connectionReleased;
+    private isolationLevel?;
+    private isNested;
+    private nestingDepth;
+    constructor(sql: SqlDataSource, isolationLevel?: TransactionIsolationLevel, isNested?: boolean, nestingDepth?: number);
     /**
-     * @description Syncs the schema of the database with the models metadata
-     * @warning This will drop and recreate all the indexes and constraints, use with caution
-     * @sqlite Not supported but won't throw an error
+     * @description Creates a new transaction with the same isolation level and same connection using save points
+     * @description If a callback is provided, it will execute the callback and commit or rollback the nested transaction save points based on the callback's success or failure
      */
-    syncSchema(options?: {
-        transactional: boolean;
-    }): Promise<void>;
+    nestedTransaction(): Promise<Transaction>;
+    nestedTransaction(cb: (trx: Transaction) => Promise<void>): Promise<void>;
     /**
-     * @description Extracts rows from raw query result based on database type
-     * MySQL/MariaDB returns [rows, fields], Postgres returns {rows: []}, others return rows directly
+     * @description Starts a transaction, automatically handled from the sql data source instance in the `transaction` method
      */
-    private extractRowsFromRawResult;
+    transaction(): Promise<void>;
     /**
-     * @description Executes a raw query on the database and returns the raw driver result
+     * @description Commit the transaction releasing the connection
+     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
+     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
      */
-    rawQuery<R = RawQueryResponseType<D>>(query: string, params?: any[], options?: RawQueryOptions): Promise<R>;
+    commit(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @description Adds a raw statement to an operation that will be executed as is
-     * @example
-     * ```ts
-     * await sql.query("users").where("name", sql.rawStatement("LOWER(name)"));
-     * await sql.query("users").update({
-     *   name: sql.rawStatement("LOWER(name)"),
-     * });
-     * await sql.query("users").insert({
-     *   name: sql.rawStatement("LOWER(name)"),
-     * });
-     * ```
+     * @description Rollback the transaction releasing the connection
+     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
+     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
      */
-    rawStatement(value: string): RawNode;
+    rollback(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @description Retrieves information from the database for the given table
+     * @description Release the connection, does nothing if the connection is already released
      */
-    getTableSchema(table: string): Promise<TableSchemaInfo>;
+    private releaseConnection;
+    private getIsolationLevelQuery;
+    private getSavePointName;
+    private getMssqlTransactionLevel;
+}
+
+/**
+ * @description The SqlDataSource class is the main class for interacting with the database, it's used to create connections, execute queries, and manage transactions
+ * @example
+ * ```ts
+ * // Create and connect to a database
+ * const sql = new SqlDataSource({
+ *   type: "mysql",
+ *   host: "localhost",
+ *   username: "root",
+ *   password: "password",
+ *   database: "mydb",
+ *   models: { User, Post }
+ * });
+ * await sql.connect();
+ *
+ * // Now you can use the connection
+ * const users = await sql.query("users").many();
+ * ```
+ */
+declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> extends DataSource {
+    #private;
+    private globalTransaction;
+    private sqlType;
+    private _models;
+    private ownsPool;
     /**
-     * @description Models provided inside the connection method will always be used for openapi schema generation
-     * @experimental
+     * @description The slaves data sources to use for the sql data source, slaves are automatically used for read operations unless specified otherwise
      */
-    getModelOpenApiSchema(): (OpenApiModelType & {
-        modelName: string;
-        $id?: string;
-    })[];
+    slaves: SqlDataSource<D, T, C>[];
     /**
-     * @description Initializes AdminJS with the configured options
-     * @throws {HysteriaError} If AdminJS is not enabled in the configuration
+     * @description The algorithm to use for selecting the slave for read operations
+     * @default "roundRobin" - Distributes requests evenly across all slaves in sequence
+     * @option "random" - Randomly selects a slave for each request
      */
-    initializeAdminJs(): Promise<AdminJsAdminInstance>;
+    slaveAlgorithm: SlaveAlgorithm;
     /**
-     * @description Initializes AdminJS with Express router
-     * @throws {HysteriaError} If AdminJS is not enabled in the configuration
+     * @description The current index for round-robin slave selection
+     * @private
      */
-    initializeAdminJsExpress(): Promise<Required<AdminJsInstance>>;
+    private roundRobinIndex;
     /**
-     * @description Returns the AdminJS instance if initialized
+     * @description The pool of connections for the database
      */
-    getAdminJs(): AdminJsInstance | undefined;
+    sqlPool: SqlPoolType | null;
     /**
-     * @description Returns the AdminJS configuration options
+     * @description Only used in transaction context to specify the connection, not meant to be used directly
+     * @private
      */
-    getAdminJsOptions(): AdminJsOptions | undefined;
+    sqlConnection: GetConnectionReturnType<D> | null;
     /**
-     * @description Checks if AdminJS is enabled
+     * @description Options provided in the sql data source initialization
      */
-    isAdminJsEnabled(): boolean;
+    inputDetails: SqlDataSourceInput<D, T, C>;
     /**
-     * @description Introspects table columns metadata
+     * @description Adapter for `useCache`, uses an in memory strategy by default
      */
-    getTableInfo(table: string): Promise<TableColumnInfo[]>;
+    cacheAdapter: CacheAdapter;
     /**
-     * @description Introspects table indexes metadata
+     * @description Maps global keys to specific handlers for cache handling
      */
-    getIndexInfo(table: string): Promise<TableIndexInfo[]>;
+    cacheKeys: C;
     /**
-     * @description Introspects table foreign keys metadata
+     * @description Migration configuration for the sql data source
      */
-    getForeignKeyInfo(table: string): Promise<TableForeignKeyInfo[]>;
+    migrationConfig: {
+        path: string;
+        tsconfig?: string;
+        lock: boolean;
+        transactional: boolean;
+        lockTimeout?: number;
+    };
     /**
-     * @description Introspects table primary key from the database
+     * @description Seeder configuration for the sql data source
      */
-    getPrimaryKeyInfo(table: string): Promise<TablePrimaryKeyInfo | undefined>;
+    seederConfig: {
+        path: string;
+        tsconfig?: string;
+    };
     /**
-     * @description Acquires an advisory lock
-     * @description Useful for preventing concurrent operations from running simultaneously
-     * @param lockKey - The lock identifier (defaults to 'hysteria_lock')
-     * @param timeoutMs - Maximum time to wait for lock in milliseconds (postgres/mssql only)
-     * @returns true if lock was acquired, false otherwise
+     * @description AdminJS configuration options
      */
-    acquireLock(lockKey?: string, timeoutMs?: number): Promise<boolean>;
+    private adminJsOptions?;
     /**
-     * @description Releases an advisory lock
-     * @param lockKey - The lock identifier (defaults to 'hysteria_lock')
-     * @returns true if lock was released, false otherwise
+     * @description Cached AdminJS instance
      */
-    releaseLock(lockKey?: string): Promise<boolean>;
+    private adminJsInstance?;
     /**
-     * @description Converts a string to a numeric lock ID for databases that require it
+     * @description Callback to handle slave server failures
      */
-    private hashStringToLockId;
+    private onSlaveServerFailure?;
     /**
-     * @description Executes an operation on a slave, handling failures with the configured callback
-     * @param operation The operation to execute on the slave
-     * @returns The result of the operation, or falls back to master if slave fails
+     * @description Returns the configured slave failure callback
      */
-    private executeOnSlave;
+    getOnSlaveServerFailure(): ((error: Error, context: SlaveContext) => void | Promise<void>) | undefined;
     /**
-     * @description Internal method to establish connection without setting as primary instance
-     * @description Used by connectToSecondarySource and useConnection
+     * @description Returns the primary instance of the SqlDataSource (set via connect with setPrimary: true)
+     * All models by default will use this instance to execute queries unless you pass a different connection/transaction in the query options
      */
-    private connectWithoutSettingPrimary;
-}
-
-type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & Pick<Model, keyof Model>;
-type NumberModelKey<T extends Model> = {
-    [K in keyof T]: T[K] extends number | bigint ? K : never;
-}[keyof T];
-type BaseModelMethodOptions = {
+    static get instance(): SqlDataSource;
     /**
-     * @description The connection to use for the model, by default the main connection will be used
-     * @description The main connection is the one created via `new SqlDataSource().connect()`
+     * @description Creates a secondary database connection that won't be set as the primary instance
+     * @description By default not used by the Models, you have to pass it as a parameter to the Models to use it
      * @example
      * ```ts
-     * import { SqlDataSource } from "hysteria-orm";
-     * const customConnection = await SqlDataSource.connectToSecondarySource({
+     * const secondaryDb = await SqlDataSource.connectToSecondarySource({
      *   type: "postgres",
-     *   host: "localhost",
-     *   username: "root",
-     *   password: "root",
-     *   database: "test",
-     *   port: 5432,
+     *   host: "replica.db.com",
+     *   ...
      * });
      *
-     * const user = await User.query({ connection: customConnection }).one();
+     * const user = await User.query({ connection: secondaryDb }).many();
      * ```
      */
-    connection?: SqlDataSource;
-    /**
-     * @description The transaction instance to use for the model
-     */
-    trx?: Transaction;
-    /**
-     * @description Whether to ignore the hooks for the model
-     */
-    ignoreHooks?: boolean;
-    /**
-     * @description The replication mode to use for the model
-     * @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
-     */
-    replicationMode?: ReplicationType;
-};
-/**
- * @description Options that can be provided to a raw sql operation (like the raw QueryBuilder)
- */
-type RawModelOptions = {
+    static connectToSecondarySource<U extends SqlDataSourceType, M extends Record<string, SqlDataSourceModel> = {}, K extends CacheKeys = {}>(input: Omit<SqlDataSourceInput<U, M, K>, "slaves">, cb?: (sqlDataSource: SqlDataSource<U, M, K>) => Promise<void> | void): Promise<SqlDataSource<U, M, K>>;
     /**
-     * Alias for the table
+     * @description Creates a temporary connection that is automatically closed after the callback is executed
+     * @example
+     * ```ts
+     * await SqlDataSource.useConnection({
+     *   type: "mysql",
+     *   ...connectionData
+     * }, async (sql) => {
+     *   const user = await User.query({ connection: sql }).many();
+     * });
+     * // Connection is automatically closed here
+     * ```
      */
-    alias?: string;
+    static useConnection<U extends SqlDataSourceType, M extends Record<string, SqlDataSourceModel> = {}, K extends CacheKeys = {}>(connectionDetails: UseConnectionInput<U, M, K>, cb: (sqlDataSource: SqlDataSource<U, M, K>) => Promise<void>): Promise<void>;
     /**
-     * @description Convert the column casing before making a Database query, by default preserves what is provided
+     * @description Closes the primary connection (singleton instance)
      */
-    databaseCaseConvention?: CaseConvention;
+    static disconnect(): Promise<void>;
     /**
-     * Column to use for soft deleted, by default is `deleted_at`
+     * @description Starts a global transaction on the primary database connection
+     * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
      */
-    softDeleteColumn?: string;
+    static startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
     /**
-     * Column to use for soft deleted, by default is date in format: "YYYY-MM-DD HH:mm:ss" in UTC timezone
+     * @description Commits a global transaction on the primary database connection
+     * @throws {HysteriaError} If the global transaction is not started
      */
-    softDeleteValue?: string | boolean;
-};
-
-declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
-    model: typeof Model;
-    protected astParser: AstParser;
-    protected unionNodes: UnionNode[];
-    protected withNodes: WithNode[];
-    protected lockQueryNodes: LockNode[];
-    protected isNestedCondition: boolean;
-    protected mustRemoveAnnotations: 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;
+    static commitGlobalTransaction(): Promise<void>;
     /**
-     * @description Performance methods that return the time that took to execute the query with the result
-     */
-    performance: {
-        many: (returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, any, any>[];
-            time: number;
-        }>;
-        one: (returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, any, any> | null;
-            time: number;
-        }>;
-        oneOrFail: (returnType?: "millis" | "seconds") => Promise<{
-            data: any;
-            time: number;
-        }>;
-        paginate: (page: number, perPage: number, returnType?: "millis" | "seconds") => Promise<{
-            data: PaginatedData<T>;
-            time: number;
-        }>;
-        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
-            data: [CursorPaginatedData<T>, 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 Rolls back a global transaction on the primary database connection
+     * @throws {HysteriaError} If the global transaction is not started
+     */
+    static rollbackGlobalTransaction(): Promise<void>;
     /**
-     * @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 Returns true if the primary instance is in a global transaction
      */
-    setReplicationMode(replicationMode: ReplicationType): this;
+    static get isInGlobalTransaction(): boolean;
     /**
-     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
+     * @description Creates a new SqlDataSource instance. Call `.connect()` to establish the connection.
+     * @param input Configuration options for the database connection. If not provided, uses env variables.
+     * @example
+     * ```ts
+     * // With explicit config
+     * const sql = new SqlDataSource({
+     *   type: "mysql",
+     *   host: "localhost",
+     *   username: "root",
+     *   password: "password",
+     *   database: "mydb",
+     *   models: { User, Post }
+     * });
+     * await sql.connect();
+     *
+     * // Using env variables
+     * const sql = new SqlDataSource();
+     * await sql.connect();
+     * ```
      */
-    exists(): Promise<boolean>;
+    constructor(input?: SqlDataSourceInput<D, T, C>);
     /**
-     * @description Executes the query and retrieves multiple results.
+     * @description Establishes the database connection and sets this instance as the primary connection, it also connects to the slaves if any are configured
+     * @throws {HysteriaError} If the connection is already established, use `SqlDataSource.useConnection` or `SqlDataSource.connectToSecondarySource` for auxiliary connections
+     * @example
+     * ```ts
+     * const sql = new SqlDataSource({ type: "mysql", ... });
+     * await sql.connect();
+     * ```
      */
-    many(): Promise<AnnotatedModel<T, any, any>[]>;
+    connect(): Promise<void>;
     /**
-     * @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 Returns true if the connection is established
      */
-    pluck<K extends ModelKey<T>>(key: K): Promise<PluckReturnType<T, K>>;
+    get isConnected(): boolean;
     /**
-     * @description Executes the query and retrieves a single result.
+     * @description Returns true if this instance is in a global transaction
      */
-    one(): Promise<AnnotatedModel<T, any, any> | null>;
+    get isInGlobalTransaction(): boolean;
     /**
-     * @description Executes the query and retrieves the first result. Fail if no result is found.
+     * @description Returns the models configured on this SqlDataSource instance
      */
-    oneOrFail(): Promise<AnnotatedModel<T, any, any>>;
+    get models(): T;
     /**
-     * @alias oneOrFail
+     * @description Selects a slave from the pool using the configured algorithm
+     * @returns A slave SqlDataSource instance or null if no slaves are available
      */
-    firstOrFail(): Promise<AnnotatedModel<T, any, any>>;
+    getSlave(): SqlDataSource<D, T, C> | null;
     /**
-     * @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 Uses the cache adapter to get a value from the cache
+     * @param key The key to get the value from
+     * @param args The arguments to pass to the key handler
      */
-    stream<M extends Model = T>(options?: StreamOptions): Promise<PassThrough & AsyncGenerator<AnnotatedModel<M, {}, {}>>>;
+    useCache<K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
     /**
-     * @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 Uses the cache adapter to get a value from the cache
+     * @param key The key to get the value from
+     * @param ttl The time to live for the value in milliseconds
+     * @param args The arguments to pass to the key handler
      */
-    chunk(chunkSize: number): AsyncGenerator<any[], void, unknown>;
+    useCache<K extends keyof C>(key: K, ttl: number, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
     /**
-     * @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 Invalidates a value from the cache
+     * @param key The key to invalidate the value from
+     * @param args The arguments to pass to the key handler (required if the handler expects arguments)
      */
-    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T>, Cursor<T, K>]>;
+    invalidCache<K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<void>;
+    invalidCache<K extends keyof C>(key: K): Promise<void>;
     /**
-     * @description Selects a subquery, subquery must return a single column
+     * @description Invalidates all values from the cache starting with the given key
+     * @param key The key to invalidate the values from
      */
-    selectSubQuery(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: string): this;
+    invalidateAllCache(key: string): Promise<void>;
     /**
-     * @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 Clones the SqlDataSource instance
+     * @param options.shouldRecreatePool Whether to recreate the pool of connections for the given driver, by default it's false
+     * @sqlite ignores the shouldRecreatePool option
+     * @returns A new SqlDataSource instance with the same input details
      */
-    lockForUpdate(options?: {
-        skipLocked?: boolean;
-        noWait?: boolean;
-    }): this;
+    clone(options?: SqlCloneOptions): Promise<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 Returns the type of the database
      */
-    forShare(options?: {
-        skipLocked?: boolean;
-        noWait?: boolean;
-    }): this;
+    getDbType(): D;
     /**
-     * @description Adds a UNION to the query.
+     * @description Returns a QueryBuilder instance for raw queries
+     * @description Query builder from the SqlDataSource instance returns raw data from the database
+     * @param table The table name to query from
      */
-    union(query: string, bindings?: any[]): this;
-    union(cb: UnionCallBack<T>): this;
+    query<S extends string>(table: TableFormat<S>, options?: RawModelOptions): QueryBuilder;
     /**
-     * @description Adds a UNION ALL to the query.
+     * @description Returns a DryQueryBuilder instance that returns the query statement without executing
      */
-    unionAll(query: string, bindings?: any[]): this;
-    unionAll(cb: UnionCallBack<T>): this;
-    unionAll(queryBuilder: QueryBuilder<any>): this;
+    dryQuery<S extends string>(table: TableFormat<S>, options?: RawModelOptions): DryQueryBuilderWithoutReadOperations;
     /**
-     * @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 Return the query to alter the given table schema
      */
-    increment(column: string, value: number): Promise<number>;
-    increment(column: NumberModelKey<T>, value: number): Promise<number>;
+    alterTable(...args: Parameters<Schema["alterTable"]>): string[];
     /**
-     * @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 Return the query to create the given table schema
      */
-    decrement(column: string, value: number): Promise<number>;
-    decrement(column: NumberModelKey<T>, value: number): Promise<number>;
+    createTable(...args: Parameters<Schema["createTable"]>): string;
     /**
-     * @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 Starts a global transaction on the database
+     * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
      */
-    getCount(column?: string): Promise<number>;
+    startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
     /**
-     * @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 Commits a global transaction on the database
+     * @throws {HysteriaError} If the global transaction is not started
      */
-    getMax(column: string): Promise<number>;
+    commitGlobalTransaction(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @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 Rolls back a global transaction on the database
      */
-    getMin(column: string): Promise<number>;
+    rollbackGlobalTransaction(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @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 Starts a transaction on a dedicated connection from the pool
+     * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
+     * @param options.isolationLevel The isolation level to use for the transaction
+     * @sqlite ignores the isolation level
      */
-    getAvg(column: string): Promise<number>;
+    transaction(options?: StartTransactionOptions): Promise<Transaction>;
+    transaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
     /**
-     * @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 Returns a ModelManager instance for the given model
      */
-    getSum(column: string): Promise<number>;
+    getModelManager<M extends Model>(model: {
+        new (): M;
+    } | typeof Model): ModelManager<M>;
     /**
-     * @description Executes the query and retrieves multiple paginated results.
-     * @description Overrides the limit and offset clauses in order to paginate the results.
+     * @description Returns the current raw driver Pool
+     * @throws {HysteriaError} If the connection pool is not established
      */
-    paginate(page: number, perPage: number): Promise<PaginatedData<T>>;
+    getPool(): getPoolReturnType<D>;
     /**
-     * @description Overrides the from clause in the query.
+     * @description Returns a connection from the pool
+     * @throws {HysteriaError} If the connection is not established
      */
-    from<S extends string>(table: TableFormat<S>, alias?: string): this;
-    from(cb: (qb: QueryBuilder<T>) => void, alias: string): this;
+    getConnection(): Promise<GetConnectionReturnType<D>>;
     /**
-     * @description Adds a CTE to the query using a callback to build the subquery.
+     * @description Closes the current connection
+     * @description If there is an active global transaction, it will be rolled back
+     * @description Also disconnects all slave connections if any are configured
      */
-    with(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    disconnect(): Promise<void>;
     /**
-     * @description Adds a recursive CTE to the query using a callback to build the subquery.
-     * @mssql not supported
+     * @description Returns the connection details
      */
-    withRecursive(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    getConnectionDetails(): SqlDataSourceInput<D, T, C>;
     /**
-     * @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 Syncs the schema of the database with the models metadata
+     * @warning This will drop and recreate all the indexes and constraints, use with caution
+     * @sqlite Not supported but won't throw an error
      */
-    withMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    syncSchema(options?: {
+        transactional: boolean;
+    }): Promise<void>;
     /**
-     * @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 Extracts rows from raw query result based on database type
+     * MySQL/MariaDB returns [rows, fields], Postgres returns {rows: []}, others return rows directly
      */
-    insert(data: Record<string, WriteQueryParam$1>, returning?: string[]): Promise<T>;
+    private extractRowsFromRawResult;
+    /**
+     * @description Executes a raw query on the database and returns the raw driver result
+     */
+    rawQuery<R = RawQueryResponseType<D>>(query: string, params?: any[], options?: RawQueryOptions): Promise<R>;
+    /**
+     * @description Adds a raw statement to an operation that will be executed as is
+     * @example
+     * ```ts
+     * await sql.query("users").where("name", sql.rawStatement("LOWER(name)"));
+     * await sql.query("users").update({
+     *   name: sql.rawStatement("LOWER(name)"),
+     * });
+     * await sql.query("users").insert({
+     *   name: sql.rawStatement("LOWER(name)"),
+     * });
+     * ```
+     */
+    rawStatement(value: string): RawNode;
+    /**
+     * @description Retrieves information from the database for the given table
+     */
+    getTableSchema(table: string): Promise<TableSchemaInfo>;
     /**
-     * @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 Models provided inside the connection method will always be used for openapi schema generation
+     * @experimental
      */
-    insertMany(data: Record<string, WriteQueryParam$1>[], returning?: string[]): Promise<T[]>;
+    getModelOpenApiSchema(): (OpenApiModelType & {
+        modelName: string;
+        $id?: string;
+    })[];
     /**
-     * @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 Initializes AdminJS with the configured options
+     * @throws {HysteriaError} If AdminJS is not enabled in the configuration
      */
-    upsert<O extends Record<string, any>>(data: O, searchCriteria: Partial<O>, options?: UpsertOptionsRawBuilder): Promise<T[]>;
+    initializeAdminJs(): Promise<AdminJsAdminInstance>;
     /**
-     * @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 Initializes AdminJS with Express router
+     * @throws {HysteriaError} If AdminJS is not enabled in the configuration
      */
-    upsertMany<O extends Record<string, any>>(conflictColumns: string[], columnsToUpdate: string[], data: O[], options?: UpsertOptionsRawBuilder): Promise<T[]>;
+    initializeAdminJsExpress(): Promise<Required<AdminJsInstance>>;
     /**
-     * @description Executes a MERGE statement for MSSQL upsert operations (raw query builder)
+     * @description Returns the AdminJS instance if initialized
      */
-    private executeMssqlMergeRaw;
+    getAdminJs(): AdminJsInstance | undefined;
     /**
-     * @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 Returns the AdminJS configuration options
      */
-    update(data: Record<string, WriteQueryParam$1>): Promise<number>;
+    getAdminJsOptions(): AdminJsOptions | undefined;
     /**
-     * @description Deletes all records from a table
-     * @warning This operation does not trigger any hook
+     * @description Checks if AdminJS is enabled
      */
-    truncate(): Promise<void>;
+    isAdminJsEnabled(): boolean;
     /**
-     * @description Deletes records from a table
-     * @returns the number of affected rows
+     * @description Introspects table columns metadata
      */
-    delete(): Promise<number>;
+    getTableInfo(table: string): Promise<TableColumnInfo[]>;
     /**
-     * @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 Introspects table indexes metadata
      */
-    softDelete(options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">): Promise<number>;
+    getIndexInfo(table: string): Promise<TableIndexInfo[]>;
     /**
-     * @description Returns the query with the parameters bound to the query
+     * @description Introspects table foreign keys metadata
      */
-    toQuery(): string;
+    getForeignKeyInfo(table: string): Promise<TableForeignKeyInfo[]>;
     /**
-     * @description Returns the query with database driver placeholders and the params
+     * @description Introspects table primary key from the database
      */
-    unWrap(): ReturnType<typeof AstParser.prototype.parse>;
+    getPrimaryKeyInfo(table: string): Promise<TablePrimaryKeyInfo | undefined>;
     /**
-     * @description Returns a deep clone of the query builder instance.
+     * @description Acquires an advisory lock
+     * @description Useful for preventing concurrent operations from running simultaneously
+     * @param lockKey - The lock identifier (defaults to 'hysteria_lock')
+     * @param timeoutMs - Maximum time to wait for lock in milliseconds (postgres/mssql only)
+     * @returns true if lock was acquired, false otherwise
      */
-    clone(): this;
+    acquireLock(lockKey?: string, timeoutMs?: number): Promise<boolean>;
     /**
-     * @description Gives a fresh instance of the query builder
+     * @description Releases an advisory lock
+     * @param lockKey - The lock identifier (defaults to 'hysteria_lock')
+     * @returns true if lock was released, false otherwise
      */
-    clear(): QueryBuilder<any>;
+    releaseLock(lockKey?: string): Promise<boolean>;
     /**
-     * @description Removes the lock query
+     * @description Converts a string to a numeric lock ID for databases that require it
      */
-    clearLockQuery(): this;
+    private hashStringToLockId;
     /**
-     * @description Removes any union query
+     * @description Executes an operation on a slave, handling failures with the configured callback
+     * @param operation The operation to execute on the slave
+     * @returns The result of the operation, or falls back to master if slave fails
      */
-    clearUnionQuery(): this;
+    private executeOnSlave;
     /**
-     * @description Removes any with query
+     * @description Internal method to establish connection without setting as primary instance
+     * @description Used by connectToSecondarySource and useConnection
      */
-    clearWithQuery(): this;
-    extractQueryNodes(): QueryNode[];
-    protected clearForFunctions(): this;
+    private connectWithoutSettingPrimary;
+}
+
+type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & Pick<Model, keyof Model>;
+type NumberModelKey<T extends Model> = {
+    [K in keyof T]: T[K] extends number | bigint ? K : never;
+}[keyof T];
+type BaseModelMethodOptions = {
     /**
-     * @description Makes a many query and returns the time that took to execute that query
+     * @description The connection to use for the model, by default the main connection will be used
+     * @description The main connection is the one created via `new SqlDataSource().connect()`
+     * @example
+     * ```ts
+     * import { SqlDataSource } from "hysteria-orm";
+     * const customConnection = await SqlDataSource.connectToSecondarySource({
+     *   type: "postgres",
+     *   host: "localhost",
+     *   username: "root",
+     *   password: "root",
+     *   database: "test",
+     *   port: 5432,
+     * });
+     *
+     * const user = await User.query({ connection: customConnection }).one();
+     * ```
      */
-    private manyWithPerformance;
+    connection?: SqlDataSource;
     /**
-     * @description Makes a one query and returns the time that took to execute that query
+     * @description The transaction instance to use for the model
      */
-    private oneWithPerformance;
+    trx?: Transaction;
     /**
-     * @alias oneOrFailWithPerformance
+     * @description Whether to ignore the hooks for the model
      */
-    private firstOrFailWithPerformance;
-    private paginateWithPerformance;
-    private paginateWithCursorWithPerformance;
+    ignoreHooks?: boolean;
     /**
-     * @description Makes a one or fail query and returns the time that took to execute that query
+     * @description The replication mode to use for the model
+     * @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
      */
-    private oneOrFailWithPerformance;
+    replicationMode?: ReplicationType;
+};
+/**
+ * @description Options that can be provided to a raw sql operation (like the raw QueryBuilder)
+ */
+type RawModelOptions = {
     /**
-     * @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
+     * Alias for the table
      */
-    private existsWithPerformance;
-    private pluckWithPerformance;
-    private updateWithPerformance;
-    private insertWithPerformance;
-    private insertManyWithPerformance;
-    private softDeleteWithPerformance;
-    private deleteWithPerformance;
-    private truncateWithPerformance;
+    alias?: string;
     /**
-     * @description Checks if the current context is an MSSQL transaction
-     * @description MSSQL transactions can only handle one request at a time
+     * @description Convert the column casing before making a Database query, by default preserves what is provided
      */
-    protected isMssqlTransaction(): boolean;
+    databaseCaseConvention?: CaseConvention;
     /**
-     * @description Executes pagination queries, serializing them for MSSQL transactions
+     * Column to use for soft deleted, by default is `deleted_at`
      */
-    protected executePaginateQueries<M, C>(modelsQuery: () => Promise<M>, countQuery: () => Promise<C>): Promise<[M, C]>;
-    protected getSqlDataSource(mode: "read" | "write"): Promise<SqlDataSource>;
+    softDeleteColumn?: string;
     /**
-     * @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
+     * Column to use for soft deleted, by default is date in format: "YYYY-MM-DD HH:mm:ss" in UTC timezone
      */
-    protected execSqlWithSlaveHandling<R>(mode: "read" | "write", operation: (dataSource: SqlDataSource) => Promise<R>): Promise<R>;
-}
-
-type UnionCallBack<T extends Model> = (queryBuilder: QueryBuilder<T>) => QueryBuilder<T>;
-type SqlMethod = "sum" | "avg" | "max" | "min" | "count" | "upper" | "lower" | "trim" | "length" | "cast" | "convert" | "abs" | "round" | "floor" | "ceil";
+    softDeleteValue?: string | boolean;
+};
 
+/**
+ * Extracts the instance type from a Model class type.
+ *
+ * @example
+ * type UserInstance = ModelInstanceType<typeof User>; // User
+ */
 type ModelInstanceType<O> = O extends typeof Model ? InstanceType<O> : never;
+/**
+ * Available fetch hook combinations for query execution.
+ * Hooks can be selectively ignored when fetching data.
+ */
 type FetchHooks = ["afterFetch"] | ["beforeFetch"] | ["afterFetch", "beforeFetch"] | ["beforeFetch", "afterFetch"] | [];
 type OneOptions = {
     ignoreHooks?: FetchHooks;
@@ -5193,11 +5370,206 @@ type OneOptions = {
 type ManyOptions = {
     ignoreHooks?: FetchHooks;
 };
-type AnnotatedModel<T extends Model, A extends object = {}, R extends object = {}> = [keyof A] extends [never] ? ModelWithoutRelations<T> & R : ModelWithoutRelations<T> & {
-    $annotations: A;
-} & R;
-type CommonSqlMethodReturnType<T extends SqlMethod> = T extends "count" | "sum" | "avg" | "min" | "max" ? number : T extends "upper" | "lower" | "trim" ? string : T extends "length" ? number : T extends "cast" | "convert" ? any : T extends "abs" | "round" | "floor" | "ceil" ? number : any;
+/**
+ * Extracts the related Model type from a relation key.
+ *
+ * @example
+ * // If User has: posts: Post[]
+ * type PostModel = RelatedInstance<User, "posts">; // Post
+ *
+ * // If User has: profile: Profile
+ * type ProfileModel = RelatedInstance<User, "profile">; // Profile
+ */
 type RelatedInstance<M extends Model, K extends ModelRelation<M>> = NonNullable<M[K]> extends (infer R)[] ? R extends Model ? R : never : NonNullable<M[K]> extends Model ? NonNullable<M[K]> : never;
+/**
+ * Utility type to convert a union to an intersection.
+ * Used internally to combine multiple select column types.
+ *
+ * @internal
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Represents all valid column selection formats with intellisense support.
+ *
+ * ## Supported Formats
+ *
+ * | Format                    | Example                  | Description                    |
+ * |---------------------------|--------------------------|--------------------------------|
+ * | Model column              | `"name"`                 | Direct column with intellisense |
+ * | Qualified column          | `"users.name"`           | Table-prefixed column          |
+ * | Aliased column            | `"name as userName"`     | Column with custom alias       |
+ * | Wildcard                  | `"*"`                    | Select all from primary table  |
+ * | Table wildcard            | `"users.*"`              | Select all from specific table |
+ *
+ * @example
+ * User.query().select(
+ *   "name",                    // Model column with intellisense
+ *   "users.email",             // Qualified column
+ *   "age as userAge",          // Aliased column
+ *   "*"                        // All columns
+ * );
+ */
+type SelectableColumn<T extends Model> = ModelKey<T> | `${string}.${string}` | `${string} as ${string}` | `${string}(${string}) as ${string}` | "*";
+/**
+ * Extracts the final property name from a column selection string.
+ *
+ * This type determines what property name will be available on the result:
+ * - Plain columns use their name directly
+ * - Aliased columns use the alias
+ * - Wildcards return `never` (handled specially to return full model)
+ *
+ * ## Extraction Rules
+ *
+ * | Input                    | Output        | Explanation                    |
+ * |--------------------------|---------------|--------------------------------|
+ * | `"name"`                 | `"name"`      | Direct column                  |
+ * | `"users.name"`           | `"name"`      | Extract column from qualified  |
+ * | `"name as userName"`     | `"userName"`  | Use alias                      |
+ * | `"users.name as author"` | `"author"`    | Alias takes precedence         |
+ * | `"*"`                    | `never`       | Wildcard - full model          |
+ * | `"users.*"`              | `never`       | Table wildcard - Record<>      |
+ */
+type ExtractColumnName<S extends string> = S extends `${string} as ${infer Alias}` ? Alias : S extends "*" ? never : S extends `${string}.*` ? never : S extends `${string}.${infer Column}` ? Column extends "*" ? never : Column : S;
+/**
+ * Resolves the TypeScript type for a selected column.
+ *
+ * If the column exists in the model, its type is used.
+ * Otherwise, `any` is used (for aliased columns, joins, etc.).
+ *
+ * @example
+ * // If User.age is `number`:
+ * GetColumnType<User, "age">    // number
+ * GetColumnType<User, "custom"> // any (not a model column)
+ */
+type GetColumnType<T extends Model, ColumnName extends string> = ColumnName extends keyof ModelWithoutRelations<T> ? ModelWithoutRelations<T>[ColumnName] : any;
+/**
+ * Builds the type for a single selected column.
+ *
+ * ## Type Resolution
+ *
+ * | Selection          | Result Type                           |
+ * |--------------------|---------------------------------------|
+ * | `"*"`              | `ModelWithoutRelations<T>` (full)     |
+ * | `"table.*"`        | `Record<string, any>` (unknown shape) |
+ * | `"column"`         | `{ column: ColumnType }`              |
+ * | `"col as alias"`   | `{ alias: ColumnType }`               |
+ *
+ * @internal
+ */
+type BuildSingleSelectType<T extends Model, S extends string> = S extends "*" ? ModelWithoutRelations<T> : S extends `${string}.*` ? Record<string, any> : ExtractColumnName<S> extends never ? {} : {
+    [K in ExtractColumnName<S>]: GetColumnType<T, ExtractColumnName<S>>;
+};
+/**
+ * Checks if a column selection includes wildcards or is empty.
+ * Used to determine if the full model type should be returned.
+ *
+ * @internal
+ */
+type HasStarOrEmpty<Columns extends readonly string[]> = Columns["length"] extends 0 ? true : "*" extends Columns[number] ? true : false;
+/**
+ * Unique symbol used internally to mark that a select() has been called.
+ */
+declare const SELECT_BRAND: unique symbol;
+/**
+ * Marker type to indicate that a select() has been called.
+ * This brand is used to distinguish between:
+ * - Initial state: ModelWithoutRelations<T> (no select called)
+ * - After select: { selectedColumns } & Pick<Model, keyof Model> & SelectBrand
+ *
+ * @internal
+ */
+type SelectBrand = {
+    [SELECT_BRAND]?: never;
+};
+/**
+ * Builds the combined TypeScript type for multiple selected columns.
+ *
+ * This is the main type used to compute the return type of `select()` calls.
+ * It handles all the complexity of combining multiple column selections into
+ * a single coherent type.
+ *
+ * ## Rules
+ *
+ * 1. **Empty selection or `*`**: Returns full `ModelWithoutRelations<T>`
+ * 2. **Specific columns**: Returns intersection of all selected column types
+ * 3. **With `table.*`**: Adds `Record<string, any>` to allow unknown properties
+ * 4. **Always includes**: Base `Model` methods (save, delete, etc.)
+ *
+ * @example
+ * // .select("name", "age as userAge")
+ * BuildSelectType<User, ["name", "age as userAge"]>
+ * // Result: { name: string; userAge: number } & Pick<Model, keyof Model>
+ *
+ * @example
+ * // .select("*")
+ * BuildSelectType<User, ["*"]>
+ * // Result: ModelWithoutRelations<User> (all columns)
+ */
+type BuildSelectType<T extends Model, Columns extends readonly string[]> = HasStarOrEmpty<Columns> extends true ? ModelWithoutRelations<T> : UnionToIntersection<{
+    [K in keyof Columns]: Columns[K] extends string ? BuildSingleSelectType<T, Columns[K]> : {};
+}[number]> extends infer Result ? Result extends Record<string, any> ? keyof Result extends never ? ModelWithoutRelations<T> : Result & Pick<Model, keyof Model> & SelectBrand : ModelWithoutRelations<T> : ModelWithoutRelations<T>;
+/**
+ * Composes a new selection with the existing selection state.
+ *
+ * - If S is the default ModelWithoutRelations (no previous select), drops default columns
+ *   and returns only the new selection with model methods
+ * - If S already has SelectBrand (from a previous select), composes with new selection
+ *
+ * Uses SelectBrand (a unique symbol) as a marker to detect if a select has been called.
+ *
+ * @typeParam S - Current selection state
+ * @typeParam Added - New fields being added by the select
+ *
+ * @example
+ * // First select - drops default columns
+ * ComposeSelect<ModelWithoutRelations<User>, { count: number }>
+ * // Result: Pick<Model, keyof Model> & SelectBrand & { count: number }
+ *
+ * @example
+ * // Chained select - composes with previous
+ * ComposeSelect<{ count: number } & Pick<Model, keyof Model> & SelectBrand, { userName: string }>
+ * // Result: { count: number } & Pick<Model, keyof Model> & SelectBrand & { userName: string }
+ */
+type ComposeSelect<S extends Record<string, any>, Added extends Record<string, any>> = (typeof SELECT_BRAND extends keyof S ? S : Pick<Model, keyof Model> & SelectBrand) & Added;
+/**
+ * Composes a BuildSelectType result with the existing selection state.
+ *
+ * Similar to ComposeSelect but designed for use with BuildSelectType which already
+ * includes Pick<Model, keyof Model> and SelectBrand in its result.
+ *
+ * - If S is the default ModelWithoutRelations (no previous select), returns just BuildSelectType
+ * - If S already has SelectBrand (from a previous select), composes S with BuildSelectType
+ * - This is checked using the SELECT_BRAND symbol to detect if another select was already used
+ *
+ * @typeParam S - Current selection state
+ * @typeParam T - The Model type
+ * @typeParam Columns - The columns being selected
+ *
+ * @example
+ * // First select - returns BuildSelectType result
+ * ComposeBuildSelect<ModelWithoutRelations<User>, User, ["id", "name"]>
+ * // Result: { id: number; name: string } & Pick<Model, keyof Model> & SelectBrand
+ *
+ * @example
+ * // Chained select - composes with previous
+ * ComposeBuildSelect<{ count: number } & Pick<Model, keyof Model> & SelectBrand, User, ["id"]>
+ * // Result: { count: number } & Pick<Model, keyof Model> & SelectBrand & { id: number }
+ */
+type ComposeBuildSelect<S extends Record<string, any>, T extends Model, Columns extends readonly string[]> = (typeof SELECT_BRAND extends keyof S ? S : {}) & BuildSelectType<T, Columns>;
+/**
+ * The final result type for ModelQueryBuilder queries.
+ *
+ * Combines selected columns (S) with loaded relations (R) into a single type.
+ *
+ * @typeParam S - Selected columns type from `select()` calls
+ * @typeParam R - Relations type from `load()` calls
+ *
+ * @example
+ * // User.query().select("name").load("posts").one()
+ * SelectedModel<{ name: string }, { posts: Post[] }>
+ * // Result: { name: string; posts: Post[] }
+ */
+type SelectedModel<S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R;
 
 type NullableAndUndefinable<T> = T | (T | null) | (T | undefined) | (T | null | undefined);
 type UpsertOptions<T extends Model> = {
@@ -5329,7 +5701,7 @@ declare abstract class Model extends Entity {
     /**
      * @description Returns all the records for the given model
      */
-    static all<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<AnnotatedModel<T, {}>[]>;
+    static all<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<ModelWithoutRelations<T>[]>;
     /**
      * @description Gives a query sqlInstance for the given model
      */
@@ -5343,7 +5715,7 @@ declare abstract class Model extends Entity {
      * @description Finds the first record in the database
      * @deprecated Used only for debugging purposes, use `.findOne` or `.query` instead
      */
-    static first<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<AnnotatedModel<T, {}> | null>;
+    static first<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<ModelWithoutRelations<T> | null>;
     /**
      * @description Finds records for the given model
      */
@@ -5373,26 +5745,24 @@ declare abstract class Model extends Entity {
     /**
      * @description Refreshes a model from the database, the model must have a primary key defined
      */
-    static refresh<T extends Model>(this: new () => T | typeof Model, model: T, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<AnnotatedModel<T, {}> | null>;
+    static refresh<T extends Model>(this: new () => T | typeof Model, model: T, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelWithoutRelations<T> | null>;
     /**
      * @description Saves a new record to the database
-     * @description $annotations will be ignored if set in the modelData and won't be returned in the response
      * @warning If not using postgres and the model has no primary key, the model will be saved, but it won't be possible to retrieve it so at that point it will be returned as null, this is not typed as Model | null for type safety reasons
      * @mysql If no Primary Key is present in the model definition, the model will be returned
      * @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<AnnotatedModel<T, {}>>;
+    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelWithoutRelations<T>>;
     /**
      * @description Saves multiple records to the database
-     * @description $annotations will be ignored if set in the modelData and won't be returned in the response
      * @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
      * @mysql If no Primary Key is present in the model definition, the model will be returned
      * @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
      * @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<AnnotatedModel<T, {}>[]>;
+    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelWithoutRelations<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
@@ -5414,7 +5784,7 @@ declare abstract class Model extends Entity {
      * @description Can only be used if the model has a primary key, use a massive update if the model has no primary key
      * @throws {HysteriaError} If the model has no primary key
      */
-    static updateRecord<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: Partial<T>, updatePayload?: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<AnnotatedModel<T, {}>>;
+    static updateRecord<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: Partial<T>, updatePayload?: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelWithoutRelations<T>>;
     /**
      * @description Finds the first record or creates a new one if it doesn't exist
      */
@@ -5427,12 +5797,12 @@ declare abstract class Model extends Entity {
     /**
      * @description Updates or creates a new record, if no searchCriteria payload is provided, provided data will be inserted as is
      */
-    static upsert<T extends Model>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, data: Partial<ModelWithoutRelations<T>>, options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<AnnotatedModel<T, {}>>;
+    static upsert<T extends Model>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, data: Partial<ModelWithoutRelations<T>>, options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<ModelWithoutRelations<T>>;
     /**
      * @description Updates or creates multiple records
      * @param {updateOnConflict} If true, the record will be updated if it exists, otherwise it will be ignored
      */
-    static upsertMany<T extends Model>(this: new () => T | typeof Model, conflictColumns: ModelKey<T>[], data: Partial<ModelWithoutRelations<T>>[], options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<AnnotatedModel<T, {}>[]>;
+    static upsertMany<T extends Model>(this: new () => T | typeof Model, conflictColumns: ModelKey<T>[], data: Partial<ModelWithoutRelations<T>>[], options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<ModelWithoutRelations<T>[]>;
     /**
      * @description Deletes a record to the database
      */
@@ -5446,7 +5816,7 @@ declare abstract class Model extends Entity {
     static softDelete<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: T, softDeleteOptions?: {
         column?: ModelKey<T>;
         value?: string | number | boolean | Date;
-    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<AnnotatedModel<T, {}>>;
+    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelWithoutRelations<T>>;
     /**
      * @description Truncates the table for the given model
      */
@@ -5666,12 +6036,6 @@ declare abstract class Model extends Entity {
      * @throws {HysteriaError} If the model has no primary key valorized in the instance
      */
     refresh<T extends Model = this>(options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<T>;
-    /**
-     * @description Converts the model to a JSON object
-     * @description Flattens all `$annotations` into the JSON object at first level including the relations
-     * @warning Use with caution, this method flattens the `$annotations` into the JSON object at first level including the relations, so if you have conflicting column names between model columns and annotations, the annotation could override the model column value
-     */
-    toJSON(): Record<string, any>;
 }
 
 type BaseModelRelationType = {
@@ -6939,4 +7303,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 AnnotatedModel, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, 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 CommonSqlMethodReturnType, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, DryModelQueryBuilder, DryQueryBuilder, type FetchHooks, 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 ModelInstanceType, ModelQueryBuilder, 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, type SeederConfig, 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, DryModelQueryBuilder, DryQueryBuilder, type ExtractColumnName, 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 ModelInstanceType, ModelQueryBuilder, 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, 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 };