hysteria-orm 10.5.0 → 10.5.1

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;
@@ -2954,28 +2970,19 @@ 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.*"
-     * @example
-     * ```ts
-     * const user = await User.query().select("name", "age").one(); // SELECT name, age FROM users
-     * const user = await User.query().select("name", "users.age").one(); // SELECT name, users.age FROM users
-     * const user = await User.query().select("name as userName").one(); // SELECT name as userName FROM users
-     * ```
      */
-    select<S extends string>(...columns: SelectableColumn$1<S>[]): this;
+    select<C extends string>(...columns: SelectableColumn$1<C>[]): this;
     select(...columns: (ModelKey<T> | "*")[]): this;
     /**
      * @description Parses a column string that may contain an alias (e.g., "column as alias")
      * @returns The column part and optional alias part
      */
-    private parseColumnAlias;
+    protected parseColumnAlias(column: string): {
+        columnPart: string;
+        aliasPart: string | undefined;
+    };
     /**
      * @description Adds a raw SELECT statement to the query
-     * @description Useful for SQL functions, expressions, or complex selections
-     * @example
-     * ```ts
-     * const result = await User.query().selectRaw("count(*) as total").one();
-     * const result = await User.query().selectRaw("sum(amount) as total_amount").one();
-     * ```
      */
     selectRaw(statement: string): this;
     /**
@@ -2996,13 +3003,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 +3015,120 @@ 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;
+    /**
+     * @description Selects COUNT(DISTINCT column) with an alias
+     */
+    selectCountDistinct<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectCountDistinct<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects UPPER(column) with an alias
+     */
+    selectUpper<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectUpper<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects LOWER(column) with an alias
+     */
+    selectLower<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectLower<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects LENGTH(column) with an alias
+     * @note MSSQL uses LEN() instead of LENGTH()
+     */
+    selectLength<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectLength<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects TRIM(column) with an alias
+     */
+    selectTrim<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectTrim<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects ABS(column) with an alias
+     */
+    selectAbs<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectAbs<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects ROUND(column, decimals) with an alias
+     */
+    selectRound<A extends string>(column: ModelKey<T>, decimals: number, alias: A): this;
+    selectRound<A extends string>(column: string, decimals: number, alias: A): this;
+    /**
+     * @description Selects COALESCE(column, defaultValue) with an alias
+     */
+    selectCoalesce<A extends string>(column: ModelKey<T>, defaultValue: string | number, alias: A): this;
+    selectCoalesce<A extends string>(column: string, defaultValue: string | number, alias: A): this;
+    /**
+     * @description Selects CEIL(column) with an alias
+     * @mssql Uses CEILING instead of CEIL
+     */
+    selectCeil<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectCeil<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects FLOOR(column) with an alias
+     */
+    selectFloor<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectFloor<A extends string>(column: string, alias: A): this;
+    /**
+     * @description Selects SQRT(column) with an alias
+     */
+    selectSqrt<A extends string>(column: ModelKey<T>, alias: A): this;
+    selectSqrt<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 +3465,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 +3554,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 +3573,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 +3634,105 @@ 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", "column as alias", "*", "table.*"
+     * @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 as userName").one();
+     * // user type: { userName: any } | null
+     * ```
+     */
+    select<Columns extends readonly string[]>(...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 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;
+    }>>;
+    selectCount<Alias extends string = string>(column: ModelKey<T> | "*" | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectSum<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectAvg<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectMin<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: any;
+    }>>;
+    selectMax<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: any;
+    }>>;
+    selectCountDistinct<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectUpper<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: string;
+    }>>;
+    selectLower<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: string;
+    }>>;
+    selectLength<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectTrim<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: string;
+    }>>;
+    selectAbs<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectRound<Alias extends string = string>(column: ModelKey<T> | string, decimals: number, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectCoalesce<ValueType = any, Alias extends string = string>(column: ModelKey<T> | string, defaultValue: string | number, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: ValueType;
+    }>>;
+    selectCeil<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectFloor<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
+    selectSqrt<Alias extends string = string>(column: ModelKey<T> | string, alias: Alias): QueryBuilder<T, ComposeRawSelect<S, {
+        [K in Alias]: number;
+    }>>;
     /**
      * @description Executes the query and returns true if the query returns at least one result, false otherwise.
      */
@@ -3676,7 +3740,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 +3749,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 +3790,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 +3804,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 +3874,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 +3961,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 +4032,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,6 +4086,107 @@ declare class DryQueryBuilder extends QueryBuilder {
 }
 
 type PluckReturnType<T extends Model, K extends ModelKey<T>> = T[K] extends infer U ? U[] : never;
+/**
+ * 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 string for raw queries.
+ *
+ * | Input                    | Output        |
+ * |--------------------------|---------------|
+ * | `"name"`                 | `"name"`      |
+ * | `"users.name"`           | `"name"`      |
+ * | `"name as userName"`     | `"userName"`  |
+ * | `"count(*) as total"`    | `"total"`     |
+ * | `"*"`                    | `never`       |
+ * | `"users.*"`              | `never`       |
+ */
+type ExtractRawColumnName<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;
+/**
+ * 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.
+ *
+ * | Selection          | Result Type                           |
+ * |--------------------|---------------------------------------|
+ * | `"*"`              | `Record<string, any>`                 |
+ * | `"table.*"`        | `Record<string, any>`                 |
+ * | `"column"`         | `{ column: any }`                     |
+ * | `"col as alias"`   | `{ alias: any }`                      |
+ *
+ * @internal
+ */
+type BuildRawSingleSelectType<S extends string> = S extends "*" ? Record<string, any> : S extends `${string}.*` ? Record<string, any> : ExtractRawColumnName<S> extends never ? {} : {
+    [K in ExtractRawColumnName<S>]: any;
+};
+/**
+ * Checks if a column selection includes wildcards or is empty.
+ * @internal
+ */
+type HasRawStarOrEmpty<Columns extends readonly string[]> = Columns["length"] extends 0 ? true : "*" extends Columns[number] ? true : false;
+/**
+ * Builds the combined TypeScript type for multiple selected columns in a raw query.
+ *
+ * ## 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 as userAge")
+ * BuildRawSelectType<["name", "age as userAge"]>
+ * // Result: { name: any; userAge: any } & RawSelectBrand
+ *
+ * @example
+ * // .select("*")
+ * BuildRawSelectType<["*"]>
+ * // Result: Record<string, any>
+ */
+type BuildRawSelectType<Columns extends readonly string[]> = HasRawStarOrEmpty<Columns> extends true ? Record<string, any> : UnionToIntersection$1<{
+    [K in keyof Columns]: Columns[K] extends string ? 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 string[]> = (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;
@@ -4061,9 +4222,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 +4263,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 +4295,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 +4308,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 +4364,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.
@@ -4198,6 +4407,7 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
      * @description Adds columns to the SELECT clause with full type safety.
      * @description Supports formats: "column", "table.column", "column as alias", "*", "table.*"
      * @description When columns are selected, the return type reflects only those columns
+     * @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 }
@@ -4540,6 +4750,157 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
     selectMax<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
         [K in Alias]: number;
     }>, R>;
+    /**
+     * @description Selects COUNT(DISTINCT column) with a typed alias
+     * @param column The column to count distinct values (supports "table.column" format)
+     * @param alias The alias for the count result
+     * @example
+     * ```ts
+     * const result = await User.query().selectCountDistinct("email", "uniqueEmails").one();
+     * console.log(result?.uniqueEmails); // Typed as number
+     * ```
+     */
+    selectCountDistinct<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
+    /**
+     * @description Selects UPPER(column) with a typed alias
+     * @param column The column to convert to uppercase
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await User.query().selectUpper("name", "upperName").one();
+     * console.log(result?.upperName); // Typed as string
+     * ```
+     */
+    selectUpper<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: string;
+    }>, R>;
+    /**
+     * @description Selects LOWER(column) with a typed alias
+     * @param column The column to convert to lowercase
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await User.query().selectLower("name", "lowerName").one();
+     * console.log(result?.lowerName); // Typed as string
+     * ```
+     */
+    selectLower<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: string;
+    }>, R>;
+    /**
+     * @description Selects LENGTH(column) with a typed alias
+     * @param column The column to get length of
+     * @param alias The alias for the result
+     * @note MSSQL uses LEN() instead of LENGTH(), handled automatically
+     * @example
+     * ```ts
+     * const result = await User.query().selectLength("name", "nameLength").one();
+     * console.log(result?.nameLength); // Typed as number
+     * ```
+     */
+    selectLength<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
+    /**
+     * @description Selects TRIM(column) with a typed alias
+     * @param column The column to trim whitespace from
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await User.query().selectTrim("name", "trimmedName").one();
+     * console.log(result?.trimmedName); // Typed as string
+     * ```
+     */
+    selectTrim<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: string;
+    }>, R>;
+    /**
+     * @description Selects ABS(column) with a typed alias
+     * @param column The column to get absolute value of
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await Order.query().selectAbs("balance", "absoluteBalance").one();
+     * console.log(result?.absoluteBalance); // Typed as number
+     * ```
+     */
+    selectAbs<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
+    /**
+     * @description Selects ROUND(column, decimals) with a typed alias
+     * @param column The column to round
+     * @param decimals Number of decimal places
+     * @param alias The alias for the result
+     * @postgres Not fully supported - ROUND with precision requires NUMERIC type, not REAL/FLOAT
+     * @cockroachdb Not fully supported - ROUND with precision requires NUMERIC type, not REAL/FLOAT
+     * @example
+     * ```ts
+     * const result = await Order.query().selectRound("price", 2, "roundedPrice").one();
+     * console.log(result?.roundedPrice); // Typed as number
+     * ```
+     */
+    selectRound<Alias extends string>(column: ModelKey<T> | string, decimals: number, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
+    /**
+     * @description Selects COALESCE(column, defaultValue) with a typed alias
+     * @param column The column to check for NULL
+     * @param defaultValue The value to use if column is NULL
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await User.query().selectCoalesce("nickname", "'Unknown'", "displayName").one();
+     * console.log(result?.displayName); // Typed as any (depends on column type)
+     * ```
+     */
+    selectCoalesce<Alias extends string>(column: ModelKey<T> | string, defaultValue: string | number, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: any;
+    }>, R>;
+    /**
+     * @description Selects CEIL(column) with a typed alias (rounds up to nearest integer)
+     * @param column The column to round up
+     * @param alias The alias for the result
+     * @sqlite Not supported - SQLite does not have a native CEIL function
+     * @mssql Uses CEILING instead of CEIL (handled automatically)
+     * @example
+     * ```ts
+     * const result = await Order.query().selectCeil("price", "ceilPrice").one();
+     * console.log(result?.ceilPrice); // Typed as number
+     * ```
+     */
+    selectCeil<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
+    /**
+     * @description Selects FLOOR(column) with a typed alias (rounds down to nearest integer)
+     * @param column The column to round down
+     * @param alias The alias for the result
+     * @sqlite Not supported - SQLite does not have a native FLOOR function
+     * @example
+     * ```ts
+     * const result = await Order.query().selectFloor("price", "floorPrice").one();
+     * console.log(result?.floorPrice); // Typed as number
+     * ```
+     */
+    selectFloor<Alias extends string>(column: ModelKey<T> | string, alias: Alias): ModelQueryBuilder<T, ComposeSelect<S, {
+        [K in Alias]: number;
+    }>, R>;
+    /**
+     * @description Selects SQRT(column) with a typed alias (square root)
+     * @param column The column to get square root of
+     * @param alias The alias for the result
+     * @example
+     * ```ts
+     * const result = await Data.query().selectSqrt("value", "sqrtValue").one();
+     * console.log(result?.sqrtValue); // Typed as number
+     * ```
+     */
+    selectSqrt<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 +4963,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 +5484,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 +5667,20 @@ 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>>;
+type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & ModelDataProperties;
 type NumberModelKey<T extends Model> = {
     [K in keyof T]: T[K] extends number | bigint ? K : never;
 }[keyof T];
@@ -5409,7 +5799,7 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  *   "*"                        // 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 | "*"}` | `${ModelKey<T> & string} as ${string}` | `${string}(${string}) as ${string}` | "*";
 /**
  * Extracts the final property name from a column selection string.
  *
@@ -5507,7 +5897,7 @@ type SelectBrand = {
  */
 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>;
+}[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,7 +5920,7 @@ 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.
  *
@@ -5569,7 +5959,7 @@ type ComposeBuildSelect<S extends Record<string, any>, T extends Model, Columns
  * SelectedModel<{ name: string }, { posts: Post[] }>
  * // Result: { name: string; posts: Post[] }
  */
-type SelectedModel<S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R;
+type SelectedModel<M extends Model, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R;
 
 type NullableAndUndefinable<T> = T | (T | null) | (T | undefined) | (T | null | undefined);
 type UpsertOptions<T extends Model> = {
@@ -7194,6 +7584,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 +7798,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 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 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, 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 };