hysteria-orm 10.5.0 → 10.5.2

package/lib/index.d.ts

@@ -1169,37 +1169,6 @@ declare class RawNode extends QueryNode {
     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;
 };
@@ -1417,6 +1386,12 @@ type RawQueryOptions = {
     replicationMode?: ReplicationType;
 };
 
+declare abstract class BaseBuilder {
+    protected nodes: QueryNode[];
+    constructor(nodes: QueryNode[]);
+    getNodes(): QueryNode[];
+}
+
 declare class ColumnTypeNode extends QueryNode {
     column: string | (() => string);
     dataType: string;
@@ -1442,45 +1417,6 @@ declare class ColumnTypeNode extends QueryNode {
     });
 }
 
-type LockType = "for_update" | "for_share" | "for_no_key_update" | "for_key_share";
-declare class LockNode extends QueryNode {
-    lockType: LockType;
-    skipLocked: boolean;
-    noWait: boolean;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(lockType: LockType, skipLocked?: boolean, noWait?: boolean);
-}
-
-declare class UnionNode extends QueryNode {
-    query: QueryNode | QueryNode[] | string;
-    isAll: boolean;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(query: QueryNode | QueryNode[] | string, isAll?: boolean);
-}
-
-declare class WithNode extends QueryNode {
-    alias: string;
-    body: QueryNode | QueryNode[];
-    clause: string;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(clause: string, alias: string, body: QueryNode | QueryNode[]);
-}
-
-declare abstract class BaseBuilder {
-    protected nodes: QueryNode[];
-    constructor(nodes: QueryNode[]);
-    getNodes(): QueryNode[];
-}
-
 declare class ConstraintBuilder extends BaseBuilder {
     private readonly columnNode;
     private readonly tableName?;
@@ -1858,6 +1794,70 @@ declare class CreateTableBuilder extends BaseBuilder {
     getNamedConstraints(): QueryNode[];
 }
 
+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;
+    skipLocked: boolean;
+    noWait: boolean;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(lockType: LockType, skipLocked?: boolean, noWait?: boolean);
+}
+
+declare class UnionNode extends QueryNode {
+    query: QueryNode | QueryNode[] | string;
+    isAll: boolean;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(query: QueryNode | QueryNode[] | string, isAll?: boolean);
+}
+
+declare class WithNode extends QueryNode {
+    alias: string;
+    body: QueryNode | QueryNode[];
+    clause: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(clause: string, alias: string, body: QueryNode | QueryNode[]);
+}
+
 declare class AlterTableBuilder extends BaseBuilder {
     private table;
     private sqlType;
@@ -1959,105 +1959,146 @@ declare class AlterTableBuilder extends BaseBuilder {
     dropPrimaryKey(table?: string): void;
 }
 
-declare class Schema {
-    queryStatements: string[];
-    sqlType: SqlDataSourceType;
-    constructor(sqlType?: SqlDataSourceType);
+/**
+ * @description SchemaBuilder class for building and executing DDL queries
+ * @description Implements PromiseLike to support both await-based execution and query retrieval
+ *
+ * @example Execute when awaited:
+ * ```ts
+ * await sql.schema().createTable("users", (table) => {
+ *   table.addColumn("id", "integer", { primaryKey: true });
+ * });
+ * ```
+ *
+ * @example Get SQL without executing:
+ * ```ts
+ * const sql = sql.schema().createTable("users", (table) => {
+ *   table.addColumn("id", "integer", { primaryKey: true });
+ * }).toQuery();
+ * ```
+ *
+ * @example Multiple operations:
+ * ```ts
+ * const builder = sql.schema();
+ * builder.createTable("users", (table) => { ... });
+ * builder.createTable("posts", (table) => { ... });
+ * await builder; // Execute all
+ * ```
+ */
+declare class SchemaBuilder implements PromiseLike<void> {
+    #private;
+    private schema;
+    private dataSource;
+    private executionPromise;
+    private state;
+    private executionError;
+    constructor(dataSource: SqlDataSource, sqlType?: SqlDataSourceType);
     /**
-     * @description Adds a raw statement to define a default value as is
-     * @example
-     * ```ts
-     * schema.rawStatement("CURRENT_TIMESTAMP");
-     * schema.alterTable("users", (table) => {
-     *   table.timestamp("created_at").default(this.schema.rawStatement("CURRENT_TIMESTAMP"));
-     * });
-     * ```
+     * @description PromiseLike.then implementation - called when awaiting the builder
+     * @description Executes all pending SQL queries on first await
      */
-    rawStatement(value: string): RawNode;
+    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
     /**
-     * @description Add raw query to the migration
+     * @description Adds a raw statement to define a default value as is
      */
-    rawQuery(query: string): void;
+    rawStatement(value: string): RawNode;
     /**
-     * @description Runs the sql in the given file, throws error if file does not exist or is not .sql or .txt
-     * @description File is splitted by semicolons and each statement is executed separately and in order
+     * @description Add raw query to the schema
      */
-    runFile(filePath: string): void;
+    rawQuery(query: string): this;
     /**
      * @description Create table constructor
-     * @mssql Does not support ifNotExists option
      */
     createTable(table: string, cb: (table: CreateTableBuilder) => void, options?: {
         ifNotExists?: boolean;
-    }): void;
+    }): this;
     /**
      * @description Alter table constructor
-     * @mssql Limited support - cannot modify columns with constraints; see AlterTableBuilder methods for details
      */
-    alterTable(table: string, cb: (t: AlterTableBuilder) => void): void;
+    alterTable(table: string, cb: (t: AlterTableBuilder) => void): this;
     /**
      * @description Drop table in the database
      */
-    dropTable(table: string, ifExists?: boolean): void;
+    dropTable(table: string, ifExists?: boolean): this;
     /**
      * @description Rename table in the database
-     * @mssql Uses sp_rename procedure; does not update references in views/procedures/triggers
      */
-    renameTable(oldTable: string, newTable: string): void;
+    renameTable(oldTable: string, newTable: string): this;
     /**
      * @description Truncate table
      */
-    truncateTable(table: string): void;
+    truncateTable(table: string): this;
     /**
      * @description Create index on table
      */
-    createIndex(table: string, columns: string[] | string, options: CommonConstraintOptions): void;
+    createIndex(table: string, columns: string[] | string, options?: CommonConstraintOptions): this;
     /**
      * @description Drop index on table
-     * @mysql requires table name for index drop
      */
-    dropIndex(indexName: string, table?: string): void;
+    dropIndex(indexName: string, table?: string): this;
     /**
      * @description Adds a primary key to a table
      */
-    addPrimaryKey(table: string, columns: string[]): void;
+    addPrimaryKey(table: string, columns: string[]): this;
     /**
      * @description Adds a UNIQUE constraint to a table
      */
-    addUnique(table: string, columns: string[] | string, options?: CommonConstraintOptions): void;
+    addUnique(table: string, columns: string[] | string, options?: CommonConstraintOptions): this;
     /**
-     * @description Drops a foreign key from a table, uses a standard constraint name pattern: fk_${table}_${leftColumn}_${rightColumn}
-     * @description If a custom constraint name was used to generate the foreign key, use `dropConstraint` instead
+     * @description Adds a constraint to a table
      */
-    dropForeignKey(table: string, leftColumn: string, rightColumn: string): void;
+    addConstraint(table: string, type: string, ...rest: any[]): this;
     /**
-     * @description Drops a UNIQUE constraint from a table
-     * @description If no constraintName is provided, it computes the default name using columns
+     * @description Drops a primary key from a table
      */
-    dropUnique(table: string, columnsOrConstraintName: string | string[], options?: CommonConstraintOptions): void;
+    dropPrimaryKey(table: string): this;
     /**
-     * @description Drops a primary key from a table
+     * @description Drops a foreign key from a table
      */
-    dropPrimaryKey(table: string): void;
+    dropForeignKey(table: string, leftColumn: string, rightColumn: string): this;
     /**
-     * @description Adds a foreign key to a table
+     * @description Drops a UNIQUE constraint from a table
      */
-    addConstraint(table: string, ...options: ConstructorParameters<typeof ConstraintNode>): void;
+    dropUnique(table: string, columnsOrConstraintName: string | string[], options?: CommonConstraintOptions): this;
     /**
      * @description Drops a constraint from a table
      */
-    dropConstraint(table: string, constraintName: string): void;
+    dropConstraint(table: string, constraintName: string): this;
     /**
      * @description Create database extension, only supported for postgres
-     * @postgres Supports extensions like PostGIS, uuid-ossp, hstore, etc.
-     * @mysql Extensions are not supported - outputs a comment
-     * @sqlite Extensions are loaded dynamically - outputs a comment
-     * @mssql Extensions are not supported - outputs a comment
-     * @oracledb Extensions are not supported - outputs a comment
      */
-    createExtension(extensionName: CommonPostgresExtensions, ifNotExists?: boolean): void;
-    createExtension(extensionName: string, ifNotExists?: boolean): void;
-    private generateAstInstance;
+    createExtension(extensionName: CommonPostgresExtensions, ifNotExists?: boolean): this;
+    createExtension(extensionName: string, ifNotExists?: boolean): this;
+    /**
+     * @description Returns the SQL statement(s)
+     * @returns Single string if one statement, array if multiple
+     */
+    toQuery(): string | string[];
+    /**
+     * @description Returns all statements as an array
+     */
+    toQueries(): string[];
+    /**
+     * @description Returns the SQL statement(s) as a formatted string
+     */
+    toString(): string;
+    /**
+     * @description Executes all pending SQL queries
+     * @description Can be called explicitly or via await (PromiseLike)
+     */
+    execute(): Promise<void>;
+    /**
+     * @description Returns true if the builder has been executed
+     */
+    isExecuted(): boolean;
+    /**
+     * @description Returns true if the builder is pending execution
+     */
+    isPending(): boolean;
+    /**
+     * @description Returns true if the builder execution failed
+     */
+    hasFailed(): boolean;
 }
 
 type AstParserType = {
@@ -2120,6 +2161,8 @@ type SoftDeleteOptions<T> = {
     ignoreBeforeUpdateHook?: boolean;
 };
 
+type JsonPathInput = string | (string | number)[];
+
 declare class DeleteNode extends QueryNode {
     fromNode: FromNode;
     chainsWith: string;
@@ -2176,31 +2219,6 @@ declare class UpdateNode extends QueryNode {
     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 {
@@ -2250,8 +2268,6 @@ declare class WhereGroupNode extends QueryNode {
     constructor(nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[], chainsWith?: "and" | "or");
 }
 
-type JsonPathInput = string | (string | number)[];
-
 declare class DistinctNode extends QueryNode {
     chainsWith: string;
     canKeywordBeSeenMultipleTimes: boolean;
@@ -2568,7 +2584,7 @@ type UniqueType = {
     name: string;
 };
 
-declare abstract class FooterQueryBuilder<T extends Model> {
+declare abstract class FooterQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> {
     protected sqlDataSource: SqlDataSource;
     protected model: typeof Model;
     protected groupByNodes: GroupByNode[];
@@ -2839,7 +2855,7 @@ declare class JoinOnQueryBuilder {
  * @description Callback type for join conditions
  */
 type JoinOnCallback = (query: JoinOnQueryBuilder) => void;
-declare abstract class JoinQueryBuilder<T extends Model> extends FooterQueryBuilder<T> {
+declare abstract class JoinQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends FooterQueryBuilder<T, S> {
     protected joinNodes: JoinNode[];
     protected constructor(model: typeof Model, sqlDataSource: SqlDataSource);
     /**
@@ -2941,7 +2957,7 @@ declare abstract class JoinQueryBuilder<T extends Model> extends FooterQueryBuil
     fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, callback: JoinOnCallback): this;
 }
 
-declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
+declare class SelectQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends JoinQueryBuilder<T, S> {
     protected dbType: SqlDataSourceType;
     protected modelSelectedColumns: string[];
     protected withQuery?: string;
@@ -2953,31 +2969,30 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
     /**
      * @description Adds a SELECT condition to the query.
      * @description Can be stacked multiple times
-     * @description Supports: "column", "table.column", "column as alias", "*", "table.*"
+     * @description Supports: "column", "table.column", "*", "table.*", or [column, alias] tuples
      * @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("id", "name")                           // Simple columns
+     * .select(["id", "userId"], ["name", "userName"]) // Columns with aliases
+     * .select("id", ["name", "userName"])             // Mixed
      */
-    select<S extends string>(...columns: SelectableColumn$1<S>[]): this;
-    select(...columns: (ModelKey<T> | "*")[]): this;
+    select<C extends string>(...columns: (SelectableColumn$1<C> | Selectable)[]): this;
+    select(...columns: (ModelKey<T> | "*" | Selectable)[]): this;
     /**
-     * @description Parses a column string that may contain an alias (e.g., "column as alias")
-     * @returns The column part and optional alias part
+     * @description Adds a raw SELECT statement to the query
      */
-    private parseColumnAlias;
+    selectRaw(statement: string): this;
     /**
-     * @description Adds a raw SELECT statement to the query
-     * @description Useful for SQL functions, expressions, or complex selections
+     * @description Selects a SQL function applied to a column with a typed alias.
+     * @description Provides intellisense for common SQL functions while accepting any custom function.
+     * @param func The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
+     * @param column The column to apply the function to (use "*" for count(*))
+     * @param alias The alias for the result
      * @example
-     * ```ts
-     * const result = await User.query().selectRaw("count(*) as total").one();
-     * const result = await User.query().selectRaw("sum(amount) as total_amount").one();
-     * ```
+     * .selectFunc("count", "*", "total")
+     * .selectFunc("upper", "name", "upperName")
+     * .selectFunc("custom_fn", "column", "result")
      */
-    selectRaw(statement: string): this;
+    selectFunc<A extends string>(sqlFunc: SqlFunction, column: string, alias: A): this;
     /**
      * @description Clears the SELECT clause
      */
@@ -2996,13 +3011,10 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
     clearDistinctOn(): 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)
-     * @param table The table name to query from, must be in valid sql format `table` or `table as alias`
      */
-    from<S extends string>(table: TableFormat<S>): this;
+    from<F extends string>(table: TableFormat<F>): this;
     /**
      * @description Sets the table to select from, by default is the table defined in the Model
-     * @description Better naming convention for non select queries
      * @alias from
      */
     table(table: string): this;
@@ -3011,159 +3023,38 @@ declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
      */
     distinct(): this;
     /**
-     * @description Adds a DISTINCT ON clause to the query, does not stack, only the last one will be used
-     * @warning Cannot use both DISTINCT and DISTINCT ON in the same query, only the DISTINCT ON will be used
+     * @description Adds a DISTINCT ON clause to the query
      * @postgresql Only usable with PostgreSQL
      */
     distinctOn(...columns: ModelKey<T>[]): this;
-    distinctOn<S extends string>(...columns: SelectableColumn$1<S>[]): this;
+    distinctOn<C extends string>(...columns: SelectableColumn$1<C>[]): 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
-     * @example
-     * ```ts
-     * // All databases accept the same path format:
-     * const user = await User.query().selectJson("data", "$.user.name", "userName").one();
-     *
-     * await User.query().selectJson("data", "user.name", "userName").one(); // $ is optional
-     * await User.query().selectJson("data", ["user", "name"], "userName").one();
-     *
-     * // Array indices:
-     * await User.query().selectJson("data", "items.0.name", "firstItemName").one();
-     * await User.query().selectJson("data", ["items", 0, "name"], "firstItemName").one();
-     * ```
      */
     selectJson<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
     selectJson<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
      * @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
-     * @example
-     * ```ts
-     * // All databases accept the same path format:
-     * const user = await User.query().selectJsonText("data", "$.user.name", "userName").one();
-     *
-     * await User.query().selectJsonText("data", ["user", "name"], "userName").one();
-     * ```
      */
     selectJsonText<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
     selectJsonText<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
      * @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
-     * @example
-     * ```ts
-     * // All databases accept the same path format:
-     * const user = await User.query().selectJsonArrayLength("data", "$.items", "itemCount").one();
-     *
-     * await User.query().selectJsonArrayLength("data", "items", "itemCount").one();
-     * await User.query().selectJsonArrayLength("data", "$", "totalCount").one(); // root array
-     * ```
      */
     selectJsonArrayLength<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
     selectJsonArrayLength<A extends string>(column: string, path: JsonPathInput, alias: A): 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
-     * @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();
-     *
-     * await User.query().selectJsonKeys("data", "user", "userKeys").one();
-     * await User.query().selectJsonKeys("data", "$", "rootKeys").one(); // root object
-     * ```
      */
     selectJsonKeys<A extends string>(column: ModelKey<T>, path: JsonPathInput, alias: A): this;
     selectJsonKeys<A extends string>(column: string, path: JsonPathInput, alias: A): this;
     /**
      * @description Adds a raw JSON select expression
-     * @param raw The raw SQL expression
-     * @param alias The alias for the selected value
-     * @example
-     * ```ts
-     * const user = await User.query().selectJsonRaw("data->>'email'", "userEmail").one();
-     * ```
      */
     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> {
+declare abstract class WhereQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends SelectQueryBuilder<T, S> {
     protected whereNodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
     protected havingNodes: HavingNode[];
     protected isNestedCondition: boolean;
@@ -3500,7 +3391,7 @@ declare abstract class WhereQueryBuilder<T extends Model> extends SelectQueryBui
 }
 
 type JsonParam = Record<string, unknown> | any[];
-declare class JsonQueryBuilder<T extends Model> extends WhereQueryBuilder<T> {
+declare class JsonQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> extends WhereQueryBuilder<T, S> {
     /**
      * @description Filters records matching exact JSON value.
      */
@@ -3589,7 +3480,7 @@ declare class JsonQueryBuilder<T extends Model> extends WhereQueryBuilder<T> {
     orWhereJsonRaw(raw: string, params?: any[]): this;
 }
 
-declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
+declare class QueryBuilder<T extends Model = any, S extends Record<string, any> = Record<string, any>> extends JsonQueryBuilder<T, S> {
     model: typeof Model;
     protected astParser: AstParser;
     protected unionNodes: UnionNode[];
@@ -3608,23 +3499,23 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      */
     performance: {
         many: (returnType?: "millis" | "seconds") => Promise<{
-            data: T[];
+            data: S[];
             time: number;
         }>;
         one: (returnType?: "millis" | "seconds") => Promise<{
-            data: T | null;
+            data: S | null;
             time: number;
         }>;
         oneOrFail: (returnType?: "millis" | "seconds") => Promise<{
-            data: T;
+            data: S;
             time: number;
         }>;
         paginate: (page: number, perPage: number, returnType?: "millis" | "seconds") => Promise<{
-            data: PaginatedData<T>;
+            data: RawPaginatedData<S>;
             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>>];
+            data: [RawCursorPaginatedData<S>, Cursor<T, ModelKey<T>>];
             time: number;
         }>;
         exists: (returnType?: "millis" | "seconds") => Promise<{
@@ -3669,6 +3560,75 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      * @description If set to "slave", read operations will use slave and write operations will use master
      */
     setReplicationMode(replicationMode: ReplicationType): this;
+    /**
+     * @description Adds a SELECT condition to the query with type safety.
+     * @description Can be stacked multiple times
+     * @description Supports: "column", "table.column", "*", "table.*", or [column, alias] tuples
+     * @example
+     * ```ts
+     * const user = await sql.query("users").select("name", "age").one();
+     * // user type: { name: any, age: any } | null
+     *
+     * const user = await sql.query("users").select(["name", "userName"]).one();
+     * // user type: { userName: any } | null
+     * ```
+     */
+    select<const Columns extends readonly Selectable[]>(...columns: Columns): QueryBuilder<T, ComposeBuildRawSelect<S, Columns>>;
+    /**
+     * @description Adds a raw SELECT statement to the query with type safety.
+     * @description Use the generic parameter to specify the type of the selected columns.
+     * @example
+     * ```ts
+     * const result = await sql.query("users")
+     *   .selectRaw<{ total: number }>("count(*) as total")
+     *   .one();
+     * // result type: { total: number } | null
+     * ```
+     */
+    selectRaw<Added extends Record<string, any> = Record<string, any>>(statement: string): QueryBuilder<T, ComposeRawSelect<S, Added>>;
+    /**
+     * @description Clears the SELECT clause and resets type to default
+     */
+    clearSelect(): QueryBuilder<T, Record<string, any>>;
+    /**
+     * @description Selects a SQL function applied to a column with a typed alias.
+     * @description Provides intellisense for common SQL functions while accepting any custom function.
+     * @description Return type is auto-inferred based on function name (number for count/sum/avg, string for upper/lower/trim, etc.)
+     * @param sqlFunc The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
+     * @param column The column to apply the function to (use "*" for count(*))
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await sql.query("users")
+     *   .selectFunc("count", "*", "total")
+     *   .one();
+     * // result type: { total: number } | null - auto-inferred!
+     * ```
+     */
+    selectFunc<F extends SqlFunction, Alias extends string>(sqlFunc: F, column: string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: SqlFunctionReturnType<F>;
+    }>>;
+    /**
+     * @description Selects a subquery, subquery must return a single column
+     */
+    selectSubQuery<ValueType = any, Alias extends string = string>(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectJson<ValueType = any, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectJsonText<ValueType = string, Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectJsonArrayLength<Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectJsonKeys<Alias extends string = string>(column: ModelKey<T> | string, path: JsonPathInput, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: string[];
+    }>>;
+    selectJsonRaw<ValueType = any, Alias extends string = string>(raw: string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
     /**
      * @description Executes the query and returns true if the query returns at least one result, false otherwise.
      */
@@ -3676,7 +3636,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
     /**
      * @description Executes the query and retrieves multiple results.
      */
-    many(): Promise<T[]>;
+    many(): Promise<S[]>;
     /**
      * @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
@@ -3685,18 +3645,18 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
     /**
      * @description Executes the query and retrieves a single result.
      */
-    one(): Promise<T | null>;
+    one(): Promise<S | null>;
     /**
      * @description Executes the query and retrieves the first result. Fail if no result is found.
      */
-    oneOrFail(): Promise<T>;
+    oneOrFail(): Promise<S>;
     /**
      * @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>>;
+    stream<M = S>(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
@@ -3726,7 +3686,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      *
      * console.log(chunks);
      */
-    chunk(chunkSize: number): AsyncGenerator<T[], void, unknown>;
+    chunk(chunkSize: number): AsyncGenerator<S[], void, unknown>;
     /**
      * @description Executes the query and retrieves multiple paginated results.
      * @description Overrides the limit and offset clauses in order to paginate the results.
@@ -3740,11 +3700,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      * @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
      */
-    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T>, Cursor<T, K>]>;
-    /**
-     * @description Selects a subquery, subquery must return a single column
-     */
-    selectSubQuery(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: string): this;
+    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[RawCursorPaginatedData<S>, Cursor<T, K>]>;
     /**
      * @description Locks the table for update
      * @param skipLocked - If true, the query will skip locked rows
@@ -3814,7 +3770,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      * @description Executes the query and retrieves multiple paginated results.
      * @description Overrides the limit and offset clauses in order to paginate the results.
      */
-    paginate(page: number, perPage: number): Promise<PaginatedData<T>>;
+    paginate(page: number, perPage: number): Promise<RawPaginatedData<S>>;
     /**
      * @description Overrides the from clause in the query.
      */
@@ -3901,11 +3857,11 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
     /**
      * @description Returns a deep clone of the query builder instance.
      */
-    clone(): this;
+    clone(): QueryBuilder<T, S>;
     /**
      * @description Gives a fresh instance of the query builder
      */
-    clear(): QueryBuilder<any>;
+    clear(): QueryBuilder<T, Record<string, any>>;
     /**
      * @description Removes the lock query
      */
@@ -3972,7 +3928,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
 /**
  * Allows to get queries without executing them
  */
-declare class DryQueryBuilder extends QueryBuilder {
+declare class DryQueryBuilder<T extends Model = any, S extends Record<string, any> = Record<string, any>> extends QueryBuilder<T, S> {
     constructor(model: typeof Model, sqlDataSource: SqlDataSource);
     many(): this;
     /**
@@ -4026,9 +3982,160 @@ declare class DryQueryBuilder extends QueryBuilder {
 }
 
 type PluckReturnType<T extends Model, K extends ModelKey<T>> = T[K] extends infer U ? U[] : never;
+/**
+ * Common SQL functions with intellisense support.
+ * Provides autocomplete for standard SQL aggregate and scalar functions,
+ * while still allowing any custom function name via string fallback.
+ *
+ * @example
+ * selectFunc("count", "*", "total")     // Intellisense suggests "count"
+ * selectFunc("custom_fn", "col", "res") // Custom functions still work
+ */
+type SqlFunction = "count" | "sum" | "avg" | "min" | "max" | "upper" | "lower" | "length" | "trim" | "abs" | "round" | "coalesce" | "ceil" | "floor" | "sqrt" | (string & {});
+/**
+ * Maps SQL function names to their return types.
+ * Used by selectFunc to auto-infer the result type.
+ *
+ * - Numeric functions (count, sum, avg, etc.) → number
+ * - String functions (upper, lower, trim) → string
+ * - Unknown functions → any
+ */
+type SqlFunctionReturnType<F extends string> = F extends "count" | "sum" | "avg" | "min" | "max" | "length" | "abs" | "round" | "ceil" | "floor" | "sqrt" ? number : F extends "upper" | "lower" | "trim" ? string : any;
+/**
+ * A tuple type for selecting a column with an alias.
+ * @example ["id", "userId"] selects "id" column as "userId"
+ */
+type SelectTuple<C extends string = string, A extends string = string> = readonly [column: C, alias: A];
+/**
+ * Input type for select() method in raw query builder.
+ * Accepts either a column string or a [column, alias] tuple.
+ *
+ * @example
+ * .select("id", "name")                    // Simple columns
+ * .select(["id", "userId"], ["name", "n"]) // Columns with aliases
+ * .select("id", ["name", "userName"])      // Mixed
+ */
+type Selectable = string | SelectTuple;
+/**
+ * Unique symbol used internally to mark that a raw select() has been called.
+ */
+declare const RAW_SELECT_BRAND: unique symbol;
+/**
+ * Marker type to indicate that a raw select() has been called.
+ * @internal
+ */
+type RawSelectBrand = {
+    [RAW_SELECT_BRAND]?: never;
+};
+/**
+ * Utility type to convert a union to an intersection.
+ * @internal
+ */
+type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Extracts the final property name from a column selection for raw queries.
+ * Supports both string columns and [column, alias] tuples.
+ *
+ * | Input                        | Output        |
+ * |------------------------------|---------------|
+ * | `"name"`                     | `"name"`      |
+ * | `"users.name"`               | `"name"`      |
+ * | `["name", "userName"]`       | `"userName"`  |
+ * | `["users.id", "id"]`         | `"id"`        |
+ * | `"*"`                        | `never`       |
+ * | `"users.*"`                  | `never`       |
+ */
+type ExtractRawColumnName<S> = S extends readonly [
+    string,
+    infer Alias extends string
+] ? Alias : S extends string ? S extends "*" ? never : S extends `${string}.*` ? never : S extends `${string}.${infer Column}` ? Column extends "*" ? never : Column : S : never;
+/**
+ * Builds the type for a single selected column in a raw query.
+ * All column types are `any` since we don't have model type information.
+ * Supports both string columns and [column, alias] tuples.
+ *
+ * | Selection              | Result Type                           |
+ * |------------------------|---------------------------------------|
+ * | `"*"`                  | `Record<string, any>`                 |
+ * | `"table.*"`            | `Record<string, any>`                 |
+ * | `"column"`             | `{ column: any }`                     |
+ * | `["col", "alias"]`     | `{ alias: any }`                      |
+ *
+ * @internal
+ */
+type BuildRawSingleSelectType<S> = S extends readonly [
+    string,
+    infer Alias extends string
+] ? {
+    [K in Alias]: any;
+} : S extends string ? S extends "*" ? Record<string, any> : S extends `${string}.*` ? Record<string, any> : ExtractRawColumnName<S> extends never ? {} : {
+    [K in ExtractRawColumnName<S> & string]: any;
+} : {};
+/**
+ * Checks if a column selection includes wildcards or is empty.
+ * @internal
+ */
+type HasRawStarOrEmpty<Columns extends readonly Selectable[]> = Columns["length"] extends 0 ? true : "*" extends Columns[number] ? true : false;
+/**
+ * Builds the combined TypeScript type for multiple selected columns in a raw query.
+ * Supports both string columns and [column, alias] tuples.
+ *
+ * ## Rules
+ *
+ * 1. **Empty selection or `*`**: Returns `Record<string, any>`
+ * 2. **Specific columns**: Returns intersection of all selected column types (all `any`)
+ * 3. **With `table.*`**: Adds `Record<string, any>` to allow unknown properties
+ *
+ * @example
+ * // .select("name", ["age", "userAge"])
+ * BuildRawSelectType<["name", ["age", "userAge"]]>
+ * // Result: { name: any; userAge: any } & RawSelectBrand
+ *
+ * @example
+ * // .select("*")
+ * BuildRawSelectType<["*"]>
+ * // Result: Record<string, any>
+ */
+type BuildRawSelectType<Columns extends readonly Selectable[]> = HasRawStarOrEmpty<Columns> extends true ? Record<string, any> : UnionToIntersection$1<{
+    [K in keyof Columns]: BuildRawSingleSelectType<Columns[K]>;
+}[number]> extends infer Result ? Result extends Record<string, any> ? keyof Result extends never ? Record<string, any> : Result & RawSelectBrand : Record<string, any> : Record<string, any>;
+/**
+ * Composes a new selection with the existing selection state for raw queries.
+ *
+ * - If S is the default Record<string, any> (no previous select), returns just the new selection
+ * - If S already has RawSelectBrand (from a previous select), composes with new selection
+ *
+ * @typeParam S - Current selection state
+ * @typeParam Added - New fields being added by the select
+ *
+ * @example
+ * // First selectRaw - creates new selection
+ * ComposeRawSelect<Record<string, any>, { count: number }>
+ * // Result: RawSelectBrand & { count: number }
+ *
+ * @example
+ * // Chained selectRaw - composes with previous
+ * ComposeRawSelect<{ count: number } & RawSelectBrand, { userName: string }>
+ * // Result: { count: number } & RawSelectBrand & { userName: string }
+ */
+type ComposeRawSelect<S extends Record<string, any>, Added extends Record<string, any>> = (typeof RAW_SELECT_BRAND extends keyof S ? S : RawSelectBrand) & Added;
+/**
+ * Composes a BuildRawSelectType result with the existing selection state.
+ *
+ * Similar to ComposeRawSelect but designed for use with BuildRawSelectType.
+ *
+ * @typeParam S - Current selection state
+ * @typeParam Columns - The columns being selected
+ */
+type ComposeBuildRawSelect<S extends Record<string, any>, Columns extends readonly Selectable[]> = (typeof RAW_SELECT_BRAND extends keyof S ? S : {}) & BuildRawSelectType<Columns>;
 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;
+/**
+ * Validates a column string for raw query builder select().
+ * Use [column, alias] tuple format for aliases instead of "column as alias".
+ * Use selectFunction() for SQL functions instead of embedding them in select().
+ */
+type SelectableColumn$1<T extends string = string> = T extends `${string}.${string}.${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`
  */
@@ -4061,9 +4168,37 @@ 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 DryQueryBuilderWithoutReadOperations = Omit<DryQueryBuilder, "many" | "one" | "oneOrFail" | "paginate" | "paginateWithCursor" | "exists" | "pluck" | "increment" | "decrement" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "stream" | "chunk" | "paginate" | "paginateWithCursor" | "exists">;
+type DryModelQueryBuilderWithoutReadOperations<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<DryModelQueryBuilder<T, A, R>, "many" | "one" | "oneOrFail" | "paginate" | "paginateWithCursor" | "exists" | "pluck" | "upsert" | "upsertMany" | "increment" | "decrement" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "stream" | "chunk" | "paginate" | "paginateWithCursor" | "exists">;
 type WriteQueryParam$1 = string | number | boolean | Date | RawNode | object | null | undefined;
+/**
+ * Simple paginated data type for raw query builders (without Model constraint)
+ */
+type RawPaginatedData<S extends Record<string, any>> = {
+    paginationMetadata: {
+        perPage: number;
+        currentPage: number;
+        firstPage: number;
+        isEmpty: boolean;
+        total: number;
+        lastPage: number;
+        hasMorePages: boolean;
+        hasPages: boolean;
+    };
+    data: S[];
+};
+/**
+ * Simple cursor paginated data type for raw query builders (without Model constraint)
+ */
+type RawCursorPaginatedData<S extends Record<string, any>> = {
+    paginationMetadata: {
+        perPage: number;
+        firstPage: number;
+        isEmpty: boolean;
+        total: number;
+    };
+    data: S[];
+};
 
 declare class SqlModelManagerUtils<T extends Model> {
     protected dbType: SqlDataSourceType;
@@ -4074,6 +4209,31 @@ declare class SqlModelManagerUtils<T extends Model> {
     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, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = {
+    paginationMetadata: PaginationMetadata;
+    data: ([keyof S] extends [never] ? T & R : SelectedModel<T, 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<T, S, R>)[];
+};
+
 type UpdateOptions = {
     ignoreBeforeUpdateHook?: boolean;
 };
@@ -4081,7 +4241,7 @@ type UpdateOptions = {
 /**
  * @description Due to query limitations some query builder methods may not be available in a RelationQueryBuilder
  */
-type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "first" | "firstOrFail" | "paginate" | "pluck" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
+type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "paginate" | "pluck" | "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;
@@ -4094,15 +4254,15 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     protected offsetValue?: number;
     performance: {
         many: (options?: ManyOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: SelectedModel<S, R>[];
+            data: SelectedModel<T, S, R>[];
             time: number;
         }>;
         one: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: SelectedModel<S, R> | null;
+            data: SelectedModel<T, S, R> | null;
             time: number;
         }>;
         oneOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: SelectedModel<S, R>;
+            data: SelectedModel<T, S, R>;
             time: number;
         }>;
         paginate: (page: number, perPage: number, options?: {
@@ -4150,20 +4310,15 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
      * @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>;
+    one(options?: OneOptions): Promise<SelectedModel<T, 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>>>;
+    }): Promise<SelectedModel<T, S, R>>;
+    many(options?: ManyOptions): Promise<SelectedModel<T, S, R>[]>;
+    chunk(chunkSize: number, options?: ManyOptions): AsyncGenerator<SelectedModel<T, S, R>[] | T[]>;
+    stream(options?: ManyOptions & StreamOptions): Promise<PassThrough & AsyncGenerator<SelectedModel<T, S, R> | T>>;
     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.
@@ -4196,21 +4351,22 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     }): 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 Supports formats: "column", "table.column", "*", "table.*", or [column, alias] tuples
      * @description When columns are selected, the return type reflects only those columns
+     * @warning This only allows selecting columns that are part of the model. For other columns, use `selectRaw`.
      * @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 with alias using tuple - return type includes the alias
+     * const users = await User.query().select(["id", "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>;
+    select<const Columns extends readonly ModelSelectableInput<T>[]>(...columns: Columns): ModelQueryBuilder<T, ComposeBuildSelect<S, T, Columns extends readonly (string | readonly [string, string])[] ? Columns : readonly (string | readonly [string, 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.
@@ -4231,6 +4387,30 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
      * ```
      */
     selectRaw<Added extends Record<string, any> = Record<string, any>>(statement: string): ModelQueryBuilder<T, ComposeSelect<S, Added>, R>;
+    /**
+     * @description Selects a SQL function applied to a column with a typed alias.
+     * @description Provides intellisense for common SQL functions while accepting any custom function.
+     * @description Return type is auto-inferred based on function name (number for count/sum/avg, string for upper/lower/trim, etc.)
+     * @param sqlFunc The SQL function name (count, sum, avg, min, max, upper, lower, etc.)
+     * @param column The column to apply the function to (use "*" for count(*))
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const users = await User.query()
+     *   .selectFunc("count", "*", "total")
+     *   .many();
+     * // users[0].total is typed as number - auto-inferred!
+     *
+     * const users = await User.query()
+     *   .select("id")
+     *   .selectFunc("upper", "name", "upperName")
+     *   .many();
+     * // users[0] is { id: number, upperName: string } - auto-inferred!
+     * ```
+     */
+    selectFunc<F extends SqlFunction, Alias extends string>(sqlFunc: F, column: ModelKey<T> | "*" | (string & {}), alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: SqlFunctionReturnType<F>;
+    }>, R>;
     /**
      * @description Selects a subquery with a typed alias
      * @param cbOrQueryBuilder A callback that receives a QueryBuilder or a QueryBuilder instance
@@ -4456,90 +4636,6 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     selectJsonRaw<ValueType = any, Alias extends string = string>(raw: string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
         [K in Alias]: ValueType;
     }>, R>;
-    /**
-     * @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();
-     * ```
-     */
-    selectCount<Alias extends string>(column: ModelKey<T> | "*" | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
-        [K in Alias]: number;
-    }>, R>;
-    /**
-     * @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();
-     * ```
-     */
-    selectSum<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
-        [K in Alias]: number;
-    }>, R>;
-    /**
-     * @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();
-     * ```
-     */
-    selectAvg<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
-        [K in Alias]: number;
-    }>, R>;
-    /**
-     * @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();
-     * ```
-     */
-    selectMin<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
-        [K in Alias]: number;
-    }>, R>;
-    /**
-     * @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();
-     * ```
-     */
-    selectMax<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
-        [K in Alias]: number;
-    }>, R>;
     /**
      * @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.
@@ -4602,8 +4698,8 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
      * @description Recursively processes all relations, including nested ones
      */
     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 mapRelatedModelsToModels<R extends SelectedModel<T, ModelWithoutRelations<T>, Record<string, any>>>(relation: Relation, modelsToFillWithRelations: T[], relatedModels: R[]): void;
+    protected getRelatedModelsForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): Promise<SelectedModel<T, ModelWithoutRelations<T>, R>[]>;
     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;
@@ -5123,13 +5219,29 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
      */
     dryQuery<S extends string>(table: TableFormat<S>, options?: RawModelOptions): DryQueryBuilderWithoutReadOperations;
     /**
-     * @description Return the query to alter the given table schema
-     */
-    alterTable(...args: Parameters<Schema["alterTable"]>): string[];
-    /**
-     * @description Return the query to create the given table schema
+     * @description Returns a SchemaBuilder instance for DDL operations
+     * @description The builder will execute queries when awaited or when .execute() is called
+     * @description Use .toQuery() or .toString() to get the SQL without executing
+     * @example
+     * ```ts
+     * // Execute on await
+     * await sql.schema().createTable("users", (table) => {
+     *   table.addColumn("id", "integer", { primaryKey: true });
+     * });
+     *
+     * // Get SQL without executing
+     * const sql = sql.schema().createTable("users", (table) => {
+     *   table.addColumn("id", "integer", { primaryKey: true });
+     * }).toQuery();
+     *
+     * // Multiple operations
+     * const builder = sql.schema();
+     * builder.createTable("users", (table) => { ... });
+     * builder.createTable("posts", (table) => { ... });
+     * await builder; // Executes all
+     * ```
      */
-    createTable(...args: Parameters<Schema["createTable"]>): string;
+    schema(): SchemaBuilder;
     /**
      * @description Starts a global transaction on the database
      * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
@@ -5290,7 +5402,130 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
     private connectWithoutSettingPrimary;
 }
 
-type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & Pick<Model, keyof Model>;
+/**
+ * Extracts only non-method keys from a type.
+ * Excludes any property that is a function.
+ */
+type ExcludeMethods<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;
+}[keyof T];
+/**
+ * Picks only non-method properties from the base Model class.
+ * This ensures that when selecting specific columns, instance methods
+ * like save(), delete(), refresh() are not incorrectly included.
+ */
+type ModelDataProperties = Pick<Model, ExcludeMethods<Model>>;
+/**
+ * Model instance methods available on query results.
+ * These methods enable CRUD operations on fetched models.
+ *
+ * All query results from Model static methods (find, findOne, findOneOrFail,
+ * findBy, findOneBy, findOneByPrimaryKey, all, first, insert, insertMany,
+ * upsert, upsertMany, updateRecord, softDelete) and from ModelQueryBuilder
+ * (one, many, oneOrFail) include these instance methods.
+ *
+ * @example
+ * ```typescript
+ * // Using instance methods on query results
+ * const user = await User.findOne({ where: { email: "test@example.com" } });
+ * if (user) {
+ *   user.mergeProps({ name: "Updated Name" });
+ *   await user.save();
+ *
+ *   // Or update directly
+ *   await user.update({ name: "Another Name" });
+ *
+ *   // Refresh from database
+ *   await user.refresh();
+ *
+ *   // Soft delete or hard delete
+ *   await user.softDelete();
+ *   // or: await user.delete();
+ * }
+ *
+ * // Works with query builder too
+ * const user2 = await User.query().where("id", 1).oneOrFail();
+ * await user2.update({ status: "inactive" });
+ *
+ * // Works with select projections
+ * const user3 = await User.query().select("id", "name").one();
+ * if (user3) {
+ *   await user3.delete(); // Still has access to instance methods
+ * }
+ * ```
+ *
+ * Note: These signatures are simplified versions that don't carry the
+ * `this: T extends Model` constraint, allowing them to work on selected
+ * model results without requiring full Model type compatibility.
+ */
+type ModelInstanceMethods<T extends Model> = {
+    /**
+     * Merges the provided data with the model instance.
+     * Does not persist to database - use save() or update() after merging.
+     */
+    mergeProps: (data: Partial<ModelWithoutRelations<T>>) => void;
+    /**
+     * Saves the model to the database (insert or update based on primary key).
+     * @throws {HysteriaError} If the model has no primary key defined
+     */
+    save: (options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<any>;
+    /**
+     * Updates the model in the database with the provided payload.
+     * @throws {HysteriaError} If the model has no primary key or primary key value
+     */
+    update: (payload: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
+    /**
+     * Soft deletes the model by setting the soft delete column.
+     * @throws {HysteriaError} If the model has no primary key or primary key value
+     */
+    softDelete: (softDeleteOptions?: {
+        column?: string;
+        value?: string | number | boolean | Date;
+    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
+    /**
+     * Hard deletes the model from the database.
+     * @throws {HysteriaError} If the model has no primary key or primary key value
+     */
+    delete: (options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
+    /**
+     * Refreshes the model from the database, updating all properties with current values.
+     * @throws {HysteriaError} If the model has no primary key or primary key value
+     */
+    refresh: (options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<any>;
+};
+/**
+ * Model data without relation properties.
+ * Includes only data columns from the model, excluding foreign keys and relation accessors.
+ */
+type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & ModelDataProperties;
+/**
+ * Return type for Model query/mutation methods.
+ * Combines data properties with instance methods for CRUD operations.
+ *
+ * This type is used as the return type for:
+ * - Static find methods: find, findOne, findOneOrFail, findBy, findOneBy, findOneByPrimaryKey
+ * - Static retrieval methods: all, first
+ * - Static mutation methods: insert, insertMany, upsert, upsertMany, updateRecord, softDelete
+ * - Static refresh method: refresh
+ *
+ * @example
+ * ```typescript
+ * // All these methods return ModelQueryResult<User> (or arrays/nullables thereof)
+ * const user1 = await User.findOne({ where: { id: 1 } });
+ * const user2 = await User.findOneOrFail({ where: { id: 1 } });
+ * const users = await User.find({});
+ * const allUsers = await User.all();
+ * const newUser = await User.insert({ name: "John" });
+ *
+ * // Each result has instance methods available
+ * if (user1) {
+ *   await user1.update({ name: "Jane" });
+ *   await user1.refresh();
+ *   await user1.delete();
+ * }
+ * ```
+ */
+type ModelQueryResult<T extends Model> = ModelWithoutRelations<T> & ModelInstanceMethods<T>;
 type NumberModelKey<T extends Model> = {
     [K in keyof T]: T[K] extends number | bigint ? K : never;
 }[keyof T];
@@ -5389,7 +5624,9 @@ type RelatedInstance<M extends Model, K extends ModelRelation<M>> = NonNullable<
  */
 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.
+ * Represents valid string column selection formats with intellisense support.
+ * Use [column, alias] tuple format for aliases instead of "column as alias".
+ * Use selectFunction() for SQL functions instead of embedding them in select().
  *
  * ## Supported Formats
  *
@@ -5397,7 +5634,6 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * |---------------------------|--------------------------|--------------------------------|
  * | 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 |
  *
@@ -5405,17 +5641,32 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  * 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}` | "*";
+type SelectableColumn<T extends Model> = ModelKey<T> | `${string}.${string | "*"}` | "*";
+/**
+ * A tuple type for selecting a column with an alias in ModelQueryBuilder.
+ * @example ["id", "userId"] selects "id" column as "userId"
+ */
+type ModelSelectTuple<T extends Model, C extends ModelKey<T> | `${string}.${string}` = ModelKey<T> | `${string}.${string}`, A extends string = string> = readonly [column: C, alias: A];
 /**
- * Extracts the final property name from a column selection string.
+ * Input type for select() method in ModelQueryBuilder.
+ * Accepts either a column string or a [column, alias] tuple for aliasing.
+ *
+ * @example
+ * .select("id", "name")                           // Simple columns
+ * .select(["id", "userId"], ["name", "userName"]) // Columns with aliases
+ * .select("id", ["name", "userName"])             // Mixed
+ */
+type ModelSelectableInput<T extends Model> = SelectableColumn<T> | ModelSelectTuple<T>;
+/**
+ * Extracts the final property name from a column selection.
+ * Supports both string columns and [column, alias] tuples.
  *
  * This type determines what property name will be available on the result:
  * - Plain columns use their name directly
- * - Aliased columns use the alias
+ * - Tuples use the alias (second element)
  * - Wildcards return `never` (handled specially to return full model)
  *
  * ## Extraction Rules
@@ -5424,12 +5675,26 @@ type SelectableColumn<T extends Model> = ModelKey<T> | `${string}.${string}` | `
  * |--------------------------|---------------|--------------------------------|
  * | `"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         |
+ * | `["name", "userName"]`   | `"userName"`  | Use alias from tuple           |
+ * | `["users.id", "id"]`     | `"id"`        | Use alias from tuple           |
  * | `"*"`                    | `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;
+type ExtractColumnName<S> = S extends readonly [
+    string,
+    infer Alias extends string
+] ? Alias : S extends string ? S extends "*" ? never : S extends `${string}.*` ? never : S extends `${string}.${infer Column}` ? Column extends "*" ? never : Column : S : never;
+/**
+ * Extracts the source column name from a selectable input.
+ * For strings, returns the column part (after last dot if qualified).
+ * For tuples, returns the first element (the column).
+ *
+ * @internal
+ */
+type ExtractSourceColumn<S> = S extends readonly [
+    infer Column extends string,
+    string
+] ? Column extends `${string}.${infer Col}` ? Col : Column : S extends string ? S extends `${string}.${infer Column}` ? Column : S : never;
 /**
  * Resolves the TypeScript type for a selected column.
  *
@@ -5444,28 +5709,34 @@ type ExtractColumnName<S extends string> = S extends `${string} as ${infer Alias
 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.
+ * Supports both string columns and [column, alias] tuples.
  *
  * ## Type Resolution
  *
- * | Selection          | Result Type                           |
- * |--------------------|---------------------------------------|
- * | `"*"`              | `ModelWithoutRelations<T>` (full)     |
- * | `"table.*"`        | `Record<string, any>` (unknown shape) |
- * | `"column"`         | `{ column: ColumnType }`              |
- * | `"col as alias"`   | `{ alias: ColumnType }`               |
+ * | Selection              | Result Type                           |
+ * |------------------------|---------------------------------------|
+ * | `"*"`                  | `ModelWithoutRelations<T>` (full)     |
+ * | `"table.*"`            | `Record<string, any>` (unknown shape) |
+ * | `"column"`             | `{ column: ColumnType }`              |
+ * | `["col", "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>>;
-};
+type BuildSingleSelectType<T extends Model, S> = S extends readonly [
+    infer Column extends string,
+    infer Alias extends string
+] ? {
+    [K in Alias]: GetColumnType<T, ExtractSourceColumn<S> & string>;
+} : S extends string ? S extends "*" ? ModelWithoutRelations<T> : S extends `${string}.*` ? Record<string, any> : ExtractColumnName<S> extends never ? {} : {
+    [K in ExtractColumnName<S> & string]: GetColumnType<T, ExtractColumnName<S> & string>;
+} : {};
 /**
  * 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;
+type HasStarOrEmpty<Columns extends readonly (string | readonly [string, string])[]> = Columns["length"] extends 0 ? true : "*" extends Columns[number] ? true : false;
 /**
  * Unique symbol used internally to mark that a select() has been called.
  */
@@ -5483,6 +5754,7 @@ type SelectBrand = {
 };
 /**
  * Builds the combined TypeScript type for multiple selected columns.
+ * Supports both string columns and [column, alias] tuples.
  *
  * 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
@@ -5496,8 +5768,8 @@ type SelectBrand = {
  * 4. **Always includes**: Base `Model` methods (save, delete, etc.)
  *
  * @example
- * // .select("name", "age as userAge")
- * BuildSelectType<User, ["name", "age as userAge"]>
+ * // .select("name", ["age", "userAge"])
+ * BuildSelectType<User, ["name", ["age", "userAge"]]>
  * // Result: { name: string; userAge: number } & Pick<Model, keyof Model>
  *
  * @example
@@ -5505,9 +5777,9 @@ type SelectBrand = {
  * 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>;
+type BuildSelectType<T extends Model, Columns extends readonly (string | readonly [string, string])[]> = HasStarOrEmpty<Columns> extends true ? ModelWithoutRelations<T> : UnionToIntersection<{
+    [K in keyof Columns]: BuildSingleSelectType<T, Columns[K]>;
+}[number]> extends infer Result ? Result extends Record<string, any> ? keyof Result extends never ? ModelWithoutRelations<T> : Result & ModelDataProperties & SelectBrand : ModelWithoutRelations<T> : ModelWithoutRelations<T>;
 /**
  * Composes a new selection with the existing selection state.
  *
@@ -5530,9 +5802,10 @@ type BuildSelectType<T extends Model, Columns extends readonly string[]> = HasSt
  * 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;
+type ComposeSelect<S extends Record<string, any>, Added extends Record<string, any>> = (typeof SELECT_BRAND extends keyof S ? S : ModelDataProperties & SelectBrand) & Added;
 /**
  * Composes a BuildSelectType result with the existing selection state.
+ * Supports both string columns and [column, alias] tuples.
  *
  * Similar to ComposeSelect but designed for use with BuildSelectType which already
  * includes Pick<Model, keyof Model> and SelectBrand in its result.
@@ -5555,21 +5828,24 @@ type ComposeSelect<S extends Record<string, any>, Added extends Record<string, a
  * 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>;
+type ComposeBuildSelect<S extends Record<string, any>, T extends Model, Columns extends readonly (string | readonly [string, 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.
+ * Combines selected columns (S) with loaded relations (R) and Model instance methods
+ * into a single type. This ensures query results have access to CRUD operations
+ * like save(), update(), delete(), etc.
  *
+ * @typeParam M - The Model 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[] }
+ * SelectedModel<User, { name: string }, { posts: Post[] }>
+ * // Result: { name: string; posts: Post[] } & ModelInstanceMethods
  */
-type SelectedModel<S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R;
+type SelectedModel<M extends Model, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R & ModelInstanceMethods<M>;
 
 type NullableAndUndefinable<T> = T | (T | null) | (T | undefined) | (T | null | undefined);
 type UpsertOptions<T extends Model> = {
@@ -5657,7 +5933,7 @@ type FindOneType<T extends Model, S extends ModelKey<T>[] = any[], R extends Mod
 type FindType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = Omit<FindOneType<T, S, R>, "throwErrorOnNull"> & {
     limit?: number;
 };
-type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = S extends readonly any[] ? S[number] extends never ? ModelWithoutRelations<T> & {
+type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = (S extends readonly any[] ? S[number] extends never ? ModelWithoutRelations<T> & {
     [K in R[number] & keyof T]: T[K];
 } : {
     [K in S[number] & keyof T]: T[K];
@@ -5665,7 +5941,7 @@ type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends
     [K in R[number] & keyof T]: T[K];
 } : ModelWithoutRelations<T> & {
     [K in R[number] & keyof T]: T[K];
-};
+}) & ModelInstanceMethods<T>;
 
 /**
  * @description Represents a Table in the Database
@@ -5701,7 +5977,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<ModelWithoutRelations<T>[]>;
+    static all<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<ModelQueryResult<T>[]>;
     /**
      * @description Gives a query sqlInstance for the given model
      */
@@ -5715,7 +5991,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<ModelWithoutRelations<T> | null>;
+    static first<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<ModelQueryResult<T> | null>;
     /**
      * @description Finds records for the given model
      */
@@ -5745,7 +6021,7 @@ 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<ModelWithoutRelations<T> | null>;
+    static refresh<T extends Model>(this: new () => T | typeof Model, model: T, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelQueryResult<T> | null>;
     /**
      * @description Saves a new record to the database
      * @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
@@ -5753,7 +6029,7 @@ declare abstract class Model extends Entity {
      * @sqlite If no Primary Key is present in the model definition, the model will be returned
      * @sqlite Returning Not supported and won't have effect
      */
-    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelWithoutRelations<T>>;
+    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelQueryResult<T>>;
     /**
      * @description Saves multiple records to the database
      * @warning If not using postgres and the model has no primary key, the models will be saved, but it won't be possible to retrieve them so at that point they will be returned as an empty array
@@ -5762,7 +6038,7 @@ declare abstract class Model extends Entity {
      * @sqlite Returning Not supported and won't have effect
      * @oracledb may do multiple inserts with auto-generated identity columns
      */
-    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelWithoutRelations<T>[]>;
+    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): Promise<ModelQueryResult<T>[]>;
     /**
      * @description Syncs in the through table the given models for the given relation
      * @param relation The many to many relation to sync, this is not type safe since many to many relations defined at a decorator level
@@ -5784,7 +6060,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<ModelWithoutRelations<T>>;
+    static updateRecord<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: Partial<T>, updatePayload?: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelQueryResult<T>>;
     /**
      * @description Finds the first record or creates a new one if it doesn't exist
      */
@@ -5797,12 +6073,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<ModelWithoutRelations<T>>;
+    static upsert<T extends Model>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, data: Partial<ModelWithoutRelations<T>>, options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<ModelQueryResult<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<ModelWithoutRelations<T>[]>;
+    static upsertMany<T extends Model>(this: new () => T | typeof Model, conflictColumns: ModelKey<T>[], data: Partial<ModelWithoutRelations<T>>[], options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<ModelQueryResult<T>[]>;
     /**
      * @description Deletes a record to the database
      */
@@ -5816,7 +6092,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<ModelWithoutRelations<T>>;
+    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelQueryResult<T>>;
     /**
      * @description Truncates the table for the given model
      */
@@ -7194,6 +7470,111 @@ declare class RedisDataSource {
     protected static getValue<T = RedisFetchable>(value: string | null): T | null;
 }
 
+declare class Schema {
+    queryStatements: string[];
+    sqlType: SqlDataSourceType;
+    constructor(sqlType?: SqlDataSourceType);
+    /**
+     * @description Adds a raw statement to define a default value as is
+     * @example
+     * ```ts
+     * schema.rawStatement("CURRENT_TIMESTAMP");
+     * schema.alterTable("users", (table) => {
+     *   table.timestamp("created_at").default(this.schema.rawStatement("CURRENT_TIMESTAMP"));
+     * });
+     * ```
+     */
+    rawStatement(value: string): RawNode;
+    /**
+     * @description Add raw query to the migration
+     */
+    rawQuery(query: string): void;
+    /**
+     * @description Executes the queries built by the schema
+     */
+    execute(): Promise<void>;
+    /**
+     * @description Runs the sql in the given file, throws error if file does not exist or is not .sql or .txt
+     * @description File is splitted by semicolons and each statement is executed separately and in order
+     */
+    runFile(filePath: string): void;
+    /**
+     * @description Create table constructor
+     * @mssql Does not support ifNotExists option
+     */
+    createTable(table: string, cb: (table: CreateTableBuilder) => void, options?: {
+        ifNotExists?: boolean;
+    }): void;
+    /**
+     * @description Alter table constructor
+     * @mssql Limited support - cannot modify columns with constraints; see AlterTableBuilder methods for details
+     */
+    alterTable(table: string, cb: (t: AlterTableBuilder) => void): void;
+    /**
+     * @description Drop table in the database
+     */
+    dropTable(table: string, ifExists?: boolean): void;
+    /**
+     * @description Rename table in the database
+     * @mssql Uses sp_rename procedure; does not update references in views/procedures/triggers
+     */
+    renameTable(oldTable: string, newTable: string): void;
+    /**
+     * @description Truncate table
+     */
+    truncateTable(table: string): void;
+    /**
+     * @description Create index on table
+     */
+    createIndex(table: string, columns: string[] | string, options?: CommonConstraintOptions): void;
+    /**
+     * @description Drop index on table
+     * @mysql requires table name for index drop
+     */
+    dropIndex(indexName: string, table?: string): void;
+    /**
+     * @description Adds a primary key to a table
+     */
+    addPrimaryKey(table: string, columns: string[]): void;
+    /**
+     * @description Adds a UNIQUE constraint to a table
+     */
+    addUnique(table: string, columns: string[] | string, options?: CommonConstraintOptions): void;
+    /**
+     * @description Drops a foreign key from a table, uses a standard constraint name pattern: fk_${table}_${leftColumn}_${rightColumn}
+     * @description If a custom constraint name was used to generate the foreign key, use `dropConstraint` instead
+     */
+    dropForeignKey(table: string, leftColumn: string, rightColumn: string): void;
+    /**
+     * @description Drops a UNIQUE constraint from a table
+     * @description If no constraintName is provided, it computes the default name using columns
+     */
+    dropUnique(table: string, columnsOrConstraintName: string | string[], options?: CommonConstraintOptions): void;
+    /**
+     * @description Drops a primary key from a table
+     */
+    dropPrimaryKey(table: string): void;
+    /**
+     * @description Adds a foreign key to a table
+     */
+    addConstraint(table: string, ...options: ConstructorParameters<typeof ConstraintNode>): void;
+    /**
+     * @description Drops a constraint from a table
+     */
+    dropConstraint(table: string, constraintName: string): void;
+    /**
+     * @description Create database extension, only supported for postgres
+     * @postgres Supports extensions like PostGIS, uuid-ossp, hstore, etc.
+     * @mysql Extensions are not supported - outputs a comment
+     * @sqlite Extensions are loaded dynamically - outputs a comment
+     * @mssql Extensions are not supported - outputs a comment
+     * @oracledb Extensions are not supported - outputs a comment
+     */
+    createExtension(extensionName: CommonPostgresExtensions, ifNotExists?: boolean): void;
+    createExtension(extensionName: string, ifNotExists?: boolean): void;
+    private generateAstInstance;
+}
+
 declare abstract class Migration {
     dbType: SqlDataSourceType;
     migrationName: string;
@@ -7303,4 +7684,4 @@ declare const generateOpenApiModelWithMetadata: <T extends new () => Model>(mode
     $id?: string;
 }>;
 
-export { type AbstractConstructor, type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, type BuildSelectType, type BuildSingleSelectType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, DryModelQueryBuilder, DryQueryBuilder, type 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 };
+export { type AbstractConstructor, type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, type BuildSelectType, type BuildSingleSelectType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, DryModelQueryBuilder, DryQueryBuilder, type ExcludeMethods, type ExtractColumnName, type ExtractSourceColumn, type FetchHooks, type GetColumnType, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IncrementFields, IncrementMixin, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, type MigrationConfig, type MigrationConfigBase, type MixinColumns, MixinFactory, Model, type ModelDataProperties, type ModelInstanceMethods, type ModelInstanceType, ModelQueryBuilder, type ModelQueryResult, type ModelSelectTuple, type ModelSelectableInput, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleDBDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type OracleDBDataSourceInput, type OracleDBPoolInstance, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type ReplicationType, Schema, SchemaBuilder, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type TableFormat, type ThroughModel, type TimestampFields, TimestampMixin, Transaction, type TransactionExecutionOptions, type UlidFields, UlidMixin, type UniqueType, type UseCacheReturnType, type UseConnectionInput, type UuidFields, UuidMixin, belongsTo, bigIntMixin, column, createMixin, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, incrementMixin, index, HysteriaLogger as logger, manyToMany, property, RedisDataSource as redis, timestampMixin, ulidMixin, unique, uuidMixin, view, withPerformance };