hysteria-orm 10.2.3 → 10.3.1

package/lib/index.d.cts

@@ -1,15 +1,18 @@
+import { PoolAttributes, Pool, Connection, Result } from 'oracledb';
 import * as mssql from 'mssql';
-import { config, Transaction as Transaction$1 } from 'mssql';
+import { config, Transaction as Transaction$1, IResult } from 'mssql';
 import * as mongodb from 'mongodb';
 import { Collection as Collection$1 } from 'mongodb';
 import * as sqlite3 from 'sqlite3';
+import { RunResult } from 'sqlite3';
 import * as pg from 'pg';
-import { ClientConfig, PoolClient } from 'pg';
+import { ClientConfig, PoolClient, QueryResult as QueryResult$1 } from 'pg';
 import * as mysql2_promise from 'mysql2/promise';
-import { PoolOptions, PoolConnection } from 'mysql2/promise';
+import { PoolOptions, PoolConnection, QueryResult } from 'mysql2/promise';
 import { RedisOptions, Redis } from 'ioredis';
 import { PassThrough } from 'node:stream';
 import { FormatOptionsWithLanguage } from 'sql-formatter';
+import express from 'express';
 
 type CaseConvention = "camel" | "snake" | "preserve" | RegExp | ((column: string) => string);
 
@@ -34,7 +37,7 @@ declare abstract class Entity {
 /**
  * @description Creates a datasource for the selected database type with the provided credentials
  */
-type DataSourceType = "cockroachdb" | "mysql" | "postgres" | "mariadb" | "sqlite" | "mssql" | "mongo";
+type DataSourceType = "oracledb" | "cockroachdb" | "mysql" | "postgres" | "mariadb" | "sqlite" | "mssql" | "mongo";
 interface MssqlDataSourceInput extends CommonDataSourceInput {
     readonly type: "mssql";
     readonly host?: string;
@@ -43,11 +46,19 @@ interface MssqlDataSourceInput extends CommonDataSourceInput {
     readonly password?: string;
     readonly database?: string;
 }
+interface OracleDBDataSourceInput extends CommonDataSourceInput {
+    readonly type: "oracledb";
+    readonly host?: string;
+    readonly port?: number;
+    readonly username?: string;
+    readonly password?: string;
+    readonly database?: string;
+}
 interface CommonDataSourceInput {
     readonly type?: DataSourceType;
     readonly logs?: boolean;
 }
-interface MongoDataSourceInput extends CommonDataSourceInput {
+interface MongoDataSourceInput$1 extends CommonDataSourceInput {
     readonly type: "mongo";
     readonly mongoOptions?: MongoConnectionOptions;
     readonly url?: string;
@@ -68,6 +79,22 @@ interface NotNullablePostgresSqlDataSourceInput extends PostgresSqlDataSourceInp
     readonly database: string;
     readonly port?: number;
 }
+interface NotNullableOracleMssqlDataSourceInput extends MssqlDataSourceInput {
+    readonly type: "mssql";
+    readonly host: string;
+    readonly username: string;
+    readonly password: string;
+    readonly database: string;
+    readonly port?: number;
+}
+interface NotNullableOracleDBDataSourceInput extends OracleDBDataSourceInput {
+    readonly type: "oracledb";
+    readonly host: string;
+    readonly username: string;
+    readonly password: string;
+    readonly database: string;
+    readonly port?: number;
+}
 interface MysqlSqlDataSourceInput extends CommonDataSourceInput {
     readonly type?: "mysql" | "mariadb";
     readonly host?: string;
@@ -95,20 +122,21 @@ interface NotNullableSqliteDataSourceInput extends SqliteDataSourceInput {
 /**
  * @description By default the connection details can be provided in the .env file, you can still override each prop with your actual connection details in the input
  */
-type DataSourceInput = MssqlDataSourceInput | MysqlSqlDataSourceInput | SqliteDataSourceInput | PostgresSqlDataSourceInput | MongoDataSourceInput;
+type DataSourceInput = OracleDBDataSourceInput | MssqlDataSourceInput | MysqlSqlDataSourceInput | SqliteDataSourceInput | PostgresSqlDataSourceInput | MongoDataSourceInput$1;
 
 type Mysql2Import = typeof mysql2_promise;
 type PgImport = typeof pg;
 type Sqlite3Import = typeof sqlite3;
 type MongoClientImport = typeof mongodb;
 type MssqlImport = typeof mssql;
+type OracleDBCreateConnectionOptions = PoolAttributes;
 type MysqlCreateConnectionOptions = PoolOptions;
 type PgClientOptions = ClientConfig;
 type MssqlConnectionOptions = Omit<config, "options"> & {
     options?: Omit<NonNullable<config["options"]>, "abortTransactionOnError" | "enableImplicitTransactions">;
 };
 type MongoConnectionOptions = NonNullable<ConstructorParameters<MongoClientImport["MongoClient"]>[1]>;
-type DriverSpecificOptions<T extends DataSourceType> = T extends "mongo" ? MongoConnectionOptions : T extends "cockroachdb" | "postgres" ? PgClientOptions : T extends "redis" ? RedisOptions : T extends "mysql" | "mariadb" ? MysqlCreateConnectionOptions : T extends "mssql" ? MssqlConnectionOptions : never;
+type DriverSpecificOptions<T extends DataSourceType> = T extends "mongo" ? MongoConnectionOptions : T extends "cockroachdb" | "postgres" ? PgClientOptions : T extends "redis" ? RedisOptions : T extends "mysql" | "mariadb" ? MysqlCreateConnectionOptions : T extends "mssql" ? MssqlConnectionOptions : T extends "oracledb" ? OracleDBCreateConnectionOptions : never;
 
 type MongoCollectionKey<T> = T extends Collection ? T : never;
 type BaseModelMethodOptions$1 = {
@@ -449,8 +477,9 @@ declare abstract class DataSource {
     protected handlePostgresSource(input?: PostgresSqlDataSourceInput): void;
     protected handleMysqlSource(input?: MysqlSqlDataSourceInput): void;
     protected handleSqliteSource(input?: SqliteDataSourceInput): void;
-    protected handleMongoSource(input?: MongoDataSourceInput): void;
+    protected handleMongoSource(input?: MongoDataSourceInput$1): void;
     protected handleMssqlSource(input?: MssqlDataSourceInput): void;
+    protected handleOracleDBSource(input?: MssqlDataSourceInput): void;
 }
 
 type MongoFindOneOptions<T extends Collection> = {
@@ -522,22 +551,34 @@ declare class CollectionManager<T extends Collection> {
 }
 
 type MongoClientInstance = InstanceType<MongoClientImport["MongoClient"]>;
+interface MongoDataSourceInput {
+    url?: string;
+    options?: MongoConnectionOptions;
+    logs?: boolean;
+}
 declare class MongoDataSource extends DataSource {
     url: string;
     isConnected: boolean;
     private mongoClient;
+    private mongoOptions?;
     private static instance;
-    private constructor();
+    constructor(input?: MongoDataSourceInput);
+    /**
+     * @description Establishes the connection to MongoDB and sets this as the primary instance
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Establishes the connection without setting this as the primary instance
+     */
+    private connectWithoutSettingPrimary;
     /**
      * @description Returns the current connection to the mongo client to execute direct statements using the mongo client from `mongodb` package
      */
     getCurrentConnection(): MongoClientInstance;
     /**
-     * @description Connects to the mongo database using the provided url and options
+     * @description Creates a secondary connection to MongoDB (does not become the primary instance)
      */
-    static connect(url?: string, options?: Partial<MongoConnectionOptions> & {
-        logs?: boolean;
-    }, cb?: (mongoDataSource: MongoDataSource) => Promise<void> | void): Promise<MongoDataSource>;
+    static connectToSecondarySource(input: MongoDataSourceInput): Promise<MongoDataSource>;
     static getInstance(): MongoDataSource;
     /**
      * @description Starts a new session and transaction using the current connection
@@ -562,12 +603,9 @@ declare class MongoDataSource extends DataSource {
      */
     static closeConnection(): Promise<void>;
     /**
-     * @description Executes a callback function with the provided connection details
+     * @description Executes a callback function with the provided connection details, automatically closing the connection when done
      */
-    static useConnection(this: typeof MongoDataSource, connectionDetails: {
-        url: string;
-        options?: MongoConnectionOptions;
-    }, cb: (mongoDataSource: MongoDataSource) => Promise<void>): Promise<void>;
+    static useConnection(this: typeof MongoDataSource, input: MongoDataSourceInput, cb: (mongoDataSource: MongoDataSource) => Promise<void>): Promise<void>;
     static query(collection: string): MongoQueryBuilder<Collection>;
     query(collection: string): MongoQueryBuilder<Collection>;
     getModelManager<T extends Collection>(model: typeof Collection, mongoDataSource: MongoDataSource, session?: InstanceType<MongoClientImport["ClientSession"]>): CollectionManager<T>;
@@ -1031,7 +1069,7 @@ type AdminJsInstance = {
     /**
      * @description Express router for AdminJS (if using express adapter)
      */
-    router?: unknown;
+    router?: ReturnType<typeof express.Router>;
 };
 
 interface CacheAdapter {
@@ -1041,23 +1079,158 @@ interface CacheAdapter {
     disconnect?(): Promise<void>;
 }
 
-type CacheKeys = Record<string, (...args: any[]) => Promise<any>>;
+type CacheKeys = Record<string, (...args: any[]) => Promise<any> | any>;
 type UseCacheReturnType<C extends CacheKeys, K extends keyof C> = K extends never ? never : Awaited<ReturnType<C[K]>>;
 
-type OpenApiModelType = {
-    type: "object";
-    properties: Record<string, OpenApiModelPropertyType>;
-    required?: string[];
+type Sqlite3ConnectionOptions = {
+    mode: number;
 };
-type OpenApiModelPropertyType = {
-    type: string;
-    items?: OpenApiModelType;
-    enum?: string[];
-    format?: string;
-    description?: string;
-    example?: any;
-    default?: any;
-    nullable?: boolean;
+type SqlDriverSpecificOptions<T extends DataSourceType> = Omit<DriverSpecificOptions<T>, "mongoOptions" | "redisOptions">;
+type MysqlConnectionInstance = Awaited<ReturnType<Mysql2Import["createPool"]>>;
+type PgPoolClientInstance = InstanceType<PgImport["Pool"]>;
+type SqliteConnectionInstance = InstanceType<Sqlite3Import["Database"]>;
+type OracleDBPoolInstance = Pool;
+type MssqlPoolInstance = InstanceType<MssqlImport["ConnectionPool"]>;
+type MssqlConnectionInstance = Awaited<ReturnType<MssqlPoolInstance["connect"]>>;
+type SqlPoolType = OracleDBPoolInstance | MysqlConnectionInstance | PgPoolClientInstance | SqliteConnectionInstance | MssqlPoolInstance;
+/**
+ * @description The connection policies for the sql data source
+ * @default the connection policies are not set, so no query will be retried
+ */
+type ConnectionPolicies = {
+    /**
+     * @description The retry policy for the sql data source, it allows to retry a query if it fails
+     */
+    retry?: {
+        maxRetries?: number;
+        delay?: number;
+    };
+};
+type SqlDataSourceModel = typeof Model;
+/**
+ * @description Common input properties shared across all SqlDataSource types
+ */
+type SqlDataSourceInputBase<T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> = {
+    /**
+     * @description Whether to log the sql queries and other debug information
+     */
+    readonly logs?: boolean;
+    /**
+     * @description The connection policies to use for the sql data source that are not configured in the driverOptions
+     */
+    connectionPolicies?: ConnectionPolicies;
+    /**
+     * @description The query format options to use for the sql data source, it tells how the sql queries should be formatted before being executed and logged
+     */
+    queryFormatOptions?: FormatOptionsWithLanguage;
+    /**
+     * @description The models to use for the sql data source, if used models will be registered in the sql data source instance and will be available for the models to use
+     * @description Models can still be used as standalone entities, but they won't be available for the sql data source instance
+     */
+    models?: T;
+    /**
+     * @description The path to the migrations folder for the sql data source, it's used to configure the migrations path for the sql data source
+     * @default "database/migrations"
+     */
+    migrationsPath?: string;
+    /**
+     * @description The cache strategy to use for the sql data source, it's used to configure the cache strategy for the sql data source
+     */
+    cacheStrategy?: {
+        cacheAdapter?: CacheAdapter;
+        keys: C;
+    };
+    /**
+     * @description AdminJS configuration for the admin panel
+     * @description To use AdminJS, install: `npm install adminjs`
+     */
+    adminJs?: AdminJsOptions;
+};
+/**
+ * @description Maps a SqlDataSourceType to its corresponding input interface
+ */
+type MapSqlDataSourceTypeToInput<D extends SqlDataSourceType> = D extends "mysql" | "mariadb" ? MysqlSqlDataSourceInput : D extends "postgres" | "cockroachdb" ? PostgresSqlDataSourceInput : D extends "sqlite" ? SqliteDataSourceInput : D extends "mssql" ? MssqlDataSourceInput : D extends "oracledb" ? OracleDBDataSourceInput : never;
+/**
+ * @description The input type for the SqlDataSource constructor
+ * @description The connectionPolicies object is used to configure the connection policies for the sql data source
+ */
+type SqlDataSourceInput<D extends SqlDataSourceType = SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> = SqlDataSourceInputBase<T, C> & {
+    /**
+     * @description The type of the database to connect to
+     */
+    readonly type: D;
+    /**
+     * @description The driver specific options to use for the sql data source, it's used to configure the driver specific options for the sql data source
+     * @warning For usage with types, you must have driver types installed if the driver handles types in a type package like e.g. `@types/pg`
+     */
+    driverOptions?: SqlDriverSpecificOptions<D>;
+    /**
+     * @description The replication configuration for the sql data source, it's used to configure the replication for the sql data source
+     */
+    replication?: {
+        /**
+         * @description The slaves data sources to use for the sql data source, slaves are automatically used for read operations unless specified otherwise
+         */
+        slaves?: Omit<UseConnectionInput<D, T, C>, "slaves" | "models" | "cacheStrategy" | "adminJs" | "logs" | "queryFormatOptions" | "migrationsPath">[];
+        /**
+         * @description The algorithm to use for selecting the slave for read operations
+         * @default "roundRobin" - Distributes requests evenly across all slaves in sequence
+         * @option "random" - Randomly selects a slave for each request
+         */
+        slaveAlgorithm?: SlaveAlgorithm;
+    };
+} & Omit<MapSqlDataSourceTypeToInput<D>, "type">;
+/**
+ * @description Maps a SqlDataSourceType to its corresponding non-nullable input interface
+ */
+type MapSqlDataSourceTypeToNotNullableInput<D extends SqlDataSourceType> = D extends "mysql" | "mariadb" ? NotNullableMysqlSqlDataSourceInput : D extends "postgres" | "cockroachdb" ? NotNullablePostgresSqlDataSourceInput : D extends "sqlite" ? NotNullableSqliteDataSourceInput : D extends "mssql" ? NotNullableOracleMssqlDataSourceInput : D extends "oracledb" ? NotNullableOracleDBDataSourceInput : never;
+type UseConnectionInput<D extends SqlDataSourceType = SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> = {
+    /**
+     * @description The type of the database to connect to
+     */
+    readonly type: D;
+    readonly logs?: boolean;
+    readonly models?: T;
+    readonly driverOptions?: SqlDriverSpecificOptions<D>;
+    connectionPolicies?: ConnectionPolicies;
+    queryFormatOptions?: FormatOptionsWithLanguage;
+    cacheStrategy?: {
+        cacheAdapter: CacheAdapter;
+        keys: C;
+    };
+    /**
+     * @description AdminJS configuration for the admin panel
+     * @description AdminJS is completely optional - dependencies are loaded at runtime via dynamic import()
+     */
+    adminJs?: AdminJsOptions;
+} & Omit<MapSqlDataSourceTypeToNotNullableInput<D>, "type">;
+type SqlDataSourceType = Exclude<DataSourceType, "mongo">;
+type SqlCloneOptions = {
+    /**
+     * @description Whether to recreate the pool of connections for the given driver, by default it's false
+     * @warning If false, the pool of connections will be reused from the caller instance
+     */
+    shouldRecreatePool?: boolean;
+};
+type getPoolReturnType<T = SqlDataSourceType> = T extends "mysql" ? MysqlConnectionInstance : T extends "mariadb" ? MysqlConnectionInstance : T extends "postgres" ? PgPoolClientInstance : T extends "cockroachdb" ? PgPoolClientInstance : T extends "sqlite" ? SqliteConnectionInstance : T extends "mssql" ? MssqlPoolInstance : T extends "oracledb" ? OracleDBPoolInstance : never;
+type GetConnectionReturnType<T = SqlDataSourceType> = T extends "mysql" ? PoolConnection : T extends "mariadb" ? PoolConnection : T extends "postgres" ? PoolClient : T extends "cockroachdb" ? PoolClient : T extends "sqlite" ? InstanceType<Sqlite3Import["Database"]> : T extends "mssql" ? Transaction$1 : T extends "oracledb" ? Connection : never;
+/** Only accepts formats `string` e `string as string` */
+type NoSpace<S extends string> = S extends `${infer _} ${infer _}` ? never : S;
+type TableFormat<S extends string> = NoSpace<S> | (S extends `${infer L} as ${infer R}` ? `${NoSpace<L>} as ${NoSpace<R>}` : never);
+type ReplicationType = "master" | "slave";
+/**
+ * @description Algorithm for selecting a slave database for read operations
+ * @option "roundRobin" - Distributes requests evenly across all slaves in sequence
+ * @option "random" - Randomly selects a slave for each request
+ */
+type SlaveAlgorithm = "roundRobin" | "random";
+type RawQueryOptions = {
+    replicationMode?: ReplicationType;
+};
+
+type AstParserType = {
+    sql: string;
+    bindings: any[];
 };
 
 declare abstract class QueryNode {
@@ -1092,6 +1265,48 @@ declare abstract class QueryNode {
     constructor(keyword: string, isRawValue?: boolean);
 }
 
+declare class AstParser {
+    private readonly dbType;
+    private readonly model;
+    constructor(model: typeof Model, dbType: SqlDataSourceType);
+    parse(nodes: (QueryNode | null)[], startBindingIndex?: number, isNestedCondition?: boolean): AstParserType;
+    /**
+     * Map the database type to a common type if shares the same driver (e.g. mysql and mariadb)
+     */
+    private mapCommonDbType;
+    /**
+     * @description Generates MSSQL table hints from lock node
+     * MSSQL uses WITH (UPDLOCK), WITH (HOLDLOCK), etc. as table hints
+     * READPAST is the MSSQL equivalent of SKIP LOCKED
+     */
+    private getMssqlTableHints;
+}
+
+declare class ColumnTypeNode extends QueryNode {
+    column: string | (() => string);
+    dataType: string;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    enumValues?: readonly string[];
+    autoIncrement?: boolean;
+    withTimezone?: boolean;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    isRawValue: boolean;
+    constructor(column: string, dataType: string, opts?: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+        enumValues?: readonly string[];
+        withTimezone?: boolean;
+        autoIncrement?: boolean;
+        isRawValue?: boolean;
+    });
+}
+
 declare class RawNode extends QueryNode {
     rawValue: string;
     canKeywordBeSeenMultipleTimes: boolean;
@@ -1134,31 +1349,6 @@ declare class ConstraintNode extends QueryNode {
     }, isRawValue?: boolean);
 }
 
-declare class ColumnTypeNode extends QueryNode {
-    column: string | (() => string);
-    dataType: string;
-    length?: number;
-    precision?: number;
-    scale?: number;
-    enumValues?: readonly string[];
-    autoIncrement?: boolean;
-    withTimezone?: boolean;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    isRawValue: boolean;
-    constructor(column: string, dataType: string, opts?: {
-        length?: number;
-        precision?: number;
-        scale?: number;
-        enumValues?: readonly string[];
-        withTimezone?: boolean;
-        autoIncrement?: boolean;
-        isRawValue?: boolean;
-    });
-}
-
 type LockType = "for_update" | "for_share" | "for_no_key_update" | "for_key_share";
 declare class LockNode extends QueryNode {
     lockType: LockType;
@@ -1192,45 +1382,145 @@ declare class WithNode extends QueryNode {
     constructor(clause: string, alias: string, body: QueryNode | QueryNode[]);
 }
 
-declare abstract class BaseBuilder {
-    protected nodes: QueryNode[];
-    constructor(nodes: QueryNode[]);
-    getNodes(): QueryNode[];
+declare class FromNode extends QueryNode {
+    table: string | QueryNode | QueryNode[];
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    alias?: string;
+    constructor(table: string | QueryNode | QueryNode[], alias?: string);
 }
 
-declare class ConstraintBuilder extends BaseBuilder {
-    private readonly columnNode;
-    private readonly tableName?;
-    private namedConstraints;
-    private context;
-    private sqlType;
-    constructor(sqlType: SqlDataSourceType, nodes: QueryNode[], columnNode: ColumnTypeNode, tableName?: string, namedConstraints?: QueryNode[], context?: CreateTableContext);
-    /**
-     * @description Adds a primary key constraint to the column, if no constraint name is provided, it will be generated using the standard pattern: pk_${table}_${column}
-     * @param options is the options for the primary key constraint
-     */
-    primaryKey(options?: PrimaryKeyOptions): this;
-    /**
-     * @description Adds a foreign key constraint to the column, if no constraint name is provided, it will be generated using the standard pattern: fk_${table}_${leftColumn}_${rightColumn}
-     * @param references is the table and column name to reference, e.g. "users.id"
-     * @param options is the options for the foreign key constraint
-     */
-    foreignKey(references: `${string}.${string}`, options?: ForeignKeyOptions): this;
-    /**
-     * @description Sets the column to auto increment
-     */
-    increment(): this;
-    /**
-     * @description Sets the column to not nullable
-     */
-    notNullable(): this;
-    /**
-     * @description Sets the column to nullable, by default it already is nullable, this method is only used for alter table
-     */
-    nullable(): this;
+declare class DeleteNode extends QueryNode {
+    fromNode: FromNode;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(fromNode: FromNode, isRawValue?: boolean);
+}
+
+declare class InsertNode extends QueryNode {
+    fromNode: FromNode;
+    records: Record<string, any>[];
+    returning?: string[];
+    disableReturning: boolean;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(fromNode: FromNode, records?: Record<string, any>[], returning?: string[], disableReturning?: boolean, isRawValue?: boolean);
+}
+
+declare class OnDuplicateNode extends QueryNode {
+    table: string;
+    conflictColumns: string[];
+    columnsToUpdate: string[];
+    returning?: string[];
+    mode: "update" | "ignore";
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(table: string, conflictColumns: string[], columnsToUpdate: string[], mode?: "update" | "ignore", returning?: string[], isRawValue?: boolean);
+}
+
+declare class TruncateNode extends QueryNode {
+    fromNode: FromNode | string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(fromNode: FromNode | string, isRawValue?: boolean);
+}
+
+declare class UpdateNode extends QueryNode {
+    fromNode: FromNode;
+    columns: string[];
+    values: (any | RawNode)[];
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(fromNode: FromNode, columns?: string[], values?: (any | RawNode)[], isRawValue?: boolean);
+}
+
+declare class InterpreterUtils {
+    private readonly model;
+    private readonly modelColumnsMap;
+    constructor(model: typeof Model);
+    formatStringColumn(dbType: SqlDataSourceType, column: string): string;
+    /**
+     * @description Formats the table name for the database type, idempotent for quoting
+     */
+    formatStringTable(dbType: SqlDataSourceType, table: string): string;
+    prepareColumns(columns: string[], values: any[], mode?: "insert" | "update"): Promise<{
+        columns: string[];
+        values: any[];
+    }>;
+    /**
+     * @description Formats the from node for write operations removing the "from" keyword
+     */
+    getFromForWriteOperations(dbType: SqlDataSourceType, fromNode: FromNode): string;
+}
+
+type OpenApiModelType = {
+    type: "object";
+    properties: Record<string, OpenApiModelPropertyType>;
+    required?: string[];
+};
+type OpenApiModelPropertyType = {
+    type: string;
+    items?: OpenApiModelType;
+    enum?: string[];
+    format?: string;
+    description?: string;
+    example?: any;
+    default?: any;
+    nullable?: boolean;
+};
+
+declare abstract class BaseBuilder {
+    protected nodes: QueryNode[];
+    constructor(nodes: QueryNode[]);
+    getNodes(): QueryNode[];
+}
+
+declare class ConstraintBuilder extends BaseBuilder {
+    private readonly columnNode;
+    private readonly tableName?;
+    private namedConstraints;
+    private context;
+    private sqlType;
+    constructor(sqlType: SqlDataSourceType, nodes: QueryNode[], columnNode: ColumnTypeNode, tableName?: string, namedConstraints?: QueryNode[], context?: CreateTableContext);
+    /**
+     * @description Adds a primary key constraint to the column, if no constraint name is provided, it will be generated using the standard pattern: pk_${table}_${column}
+     * @param options is the options for the primary key constraint
+     */
+    primaryKey(options?: PrimaryKeyOptions): this;
+    /**
+     * @description Adds a foreign key constraint to the column, if no constraint name is provided, it will be generated using the standard pattern: fk_${table}_${leftColumn}_${rightColumn}
+     * @param references is the table and column name to reference, e.g. "users.id"
+     * @param options is the options for the foreign key constraint
+     */
+    foreignKey(references: `${string}.${string}`, options?: ForeignKeyOptions): this;
+    /**
+     * @description Sets the column to auto increment
+     */
+    increment(): this;
+    /**
+     * @description Sets the column to not nullable
+     */
+    notNullable(): this;
+    /**
+     * @description Sets the column to nullable, by default it already is nullable, this method is only used for alter table
+     */
+    nullable(): this;
     /**
      * @description Sets the default value for the column
      * @param value is the default value for the column
+     * @oracle not supported must be defined manually in a separate statement
      */
     default(value: string | number | boolean | null | RawNode): this;
     /**
@@ -1704,35 +1994,6 @@ declare class Schema {
     private generateAstInstance;
 }
 
-declare class FromNode extends QueryNode {
-    table: string | QueryNode | QueryNode[];
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    alias?: string;
-    constructor(table: string | QueryNode | QueryNode[], alias?: string);
-}
-
-declare class InterpreterUtils {
-    private readonly model;
-    private readonly modelColumnsMap;
-    constructor(model: typeof Model);
-    formatStringColumn(dbType: SqlDataSourceType, column: string): string;
-    /**
-     * @description Formats the table name for the database type, idempotent for quoting
-     */
-    formatStringTable(dbType: SqlDataSourceType, table: string): string;
-    prepareColumns(columns: string[], values: any[], mode?: "insert" | "update"): Promise<{
-        columns: string[];
-        values: any[];
-    }>;
-    /**
-     * @description Formats the from node for write operations removing the "from" keyword
-     */
-    getFromForWriteOperations(dbType: SqlDataSourceType, fromNode: FromNode): string;
-}
-
 type DeleteOptions = {
     ignoreBeforeDeleteHook?: boolean;
 };
@@ -2885,223 +3146,82 @@ type UpdateOptions = {
     ignoreBeforeUpdateHook?: boolean;
 };
 
-type TransactionIsolationLevel = "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
-type StartTransactionOptions = {
-    isolationLevel?: TransactionIsolationLevel;
-};
 /**
- * @description Options for the transaction execution
+ * @description Due to query limitations some query builder methods may not be available in a RelationQueryBuilder
  */
-type TransactionExecutionOptions = {
+type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "first" | "firstOrFail" | "paginate" | "pluck" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
+
+declare class ModelQueryBuilder<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> extends QueryBuilder<T> {
+    relation: Relation;
+    protected sqlModelManagerUtils: SqlModelManagerUtils<T>;
+    protected relationQueryBuilders: ModelQueryBuilder<any>[];
+    protected modelSelectedColumns: string[];
+    private modelColumnsMap;
+    private modelColumnsDatabaseNames;
+    protected limitValue?: number;
+    protected offsetValue?: number;
+    performance: {
+        many: (options?: ManyOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, A, R>[];
+            time: number;
+        }>;
+        one: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, A, R> | null;
+            time: number;
+        }>;
+        oneOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, A, R>;
+            time: number;
+        }>;
+        first: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, A, R> | null;
+            time: number;
+        }>;
+        firstOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, A, R>;
+            time: number;
+        }>;
+        paginate: (page: number, perPage: number, options?: {
+            ignoreHooks?: boolean;
+        }, returnType?: "millis" | "seconds") => Promise<{
+            data: PaginatedData<T, A, R>;
+            time: number;
+        }>;
+        exists: (returnType?: "millis" | "seconds") => Promise<{
+            data: boolean;
+            time: number;
+        }>;
+        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
+            data: [CursorPaginatedData<T, A, R>, Cursor<T, ModelKey<T>>];
+            time: number;
+        }>;
+        truncate: (returnType?: "millis" | "seconds") => Promise<{
+            data: void;
+            time: number;
+        }>;
+        delete: (returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        update: (data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions, returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        softDelete: (options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">, returnType?: "millis" | "seconds") => Promise<{
+            data: number;
+            time: number;
+        }>;
+        pluck: (key: ModelKey<T>, returnType?: "millis" | "seconds") => Promise<{
+            data: PluckReturnType<T, ModelKey<T>>;
+            time: number;
+        }>;
+    };
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
     /**
-     * @description If true, the transaction will throw an error if it is inactive
+     * @description Returns true if the query builder is a relation query builder, this changes the behavior of the query builder like limit, offset, etc.
+     * @internal
      */
-    throwErrorOnInactiveTransaction?: boolean;
-};
-type TransactionOptionsOrCallback = StartTransactionOptions | ((trx: Transaction) => Promise<void>);
-type StartTransactionReturnType<T extends TransactionOptionsOrCallback> = T extends StartTransactionOptions ? Transaction : T extends (trx: Transaction) => Promise<void> ? void : Transaction;
-
-/**
- * @description Transaction class, not meant to be used directly, use sql.startTransaction() instead
- */
-declare class Transaction {
-    /**
-     * @description The sql data source instance that the transaction is running on here you can both query or execute raw queries
-     * @example
-     * ```ts
-     * import { sql } from "hysteria-orm";
-     * import { User } from "./models/user";
-     *
-     * // Raw queries
-     * const trx = await sql.startTransaction();
-     * await trx.rawQuery("SELECT * FROM users");
-     *
-     * // Model manager
-     * const modelManager = trx.sql.getModelManager(User);
-     * await modelManager.insert({ name: "John Doe" });
-     *
-     * // Query builder
-     * await trx.query(User.table).insert({ name: "John Doe" });
-     *
-     * await trx.commit();
-     * ```
-     */
-    sql: SqlDataSourceWithoutTransaction;
-    /**
-     * @description Whether the transaction is active
-     */
-    isActive: boolean;
-    /**
-     * @description The transaction unique identifier
-     */
-    transactionId: string;
-    private connectionReleased;
-    private isolationLevel?;
-    private isNested;
-    private nestingDepth;
-    constructor(sql: SqlDataSource, isolationLevel?: TransactionIsolationLevel, isNested?: boolean, nestingDepth?: number);
-    /**
-     * @description Creates a new transaction with the same isolation level and same connection using save points
-     * @description If a callback is provided, it will execute the callback and commit or rollback the nested transaction save points based on the callback's success or failure
-     */
-    nestedTransaction(): Promise<Transaction>;
-    nestedTransaction(cb: (trx: Transaction) => Promise<void>): Promise<void>;
-    /**
-     * @description Starts a transaction, automatically handled from the sql data source instance in the `startTransaction` method
-     */
-    startTransaction(): Promise<void>;
-    /**
-     * @description Commit the transaction releasing the connection
-     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
-     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
-     */
-    commit(options?: TransactionExecutionOptions): Promise<void>;
-    /**
-     * @description Rollback the transaction releasing the connection
-     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
-     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
-     */
-    rollback(options?: TransactionExecutionOptions): Promise<void>;
-    /**
-     * @description Release the connection, does nothing if the connection is already released
-     */
-    private releaseConnection;
-    private getIsolationLevelQuery;
-    private getSavePointName;
-    private getMssqlTransactionLevel;
-}
-
-type ModelWithoutRelations<T extends Model> = Pick<T, ExcludeRelations<Omit<T, "*">>>;
-type NumberModelKey<T extends Model> = {
-    [K in keyof T]: T[K] extends number | bigint ? K : never;
-}[keyof T];
-type BaseModelMethodOptions = {
-    /**
-     * @description The connection to use for the model, by default the main connection will be used
-     * @description The main connection is the one created by the `sql.connect` method
-     * @example
-     * ```ts
-     * import { sql } from "hysteria-orm";
-     * const customConnection = await sql.connectToSecondarySource({
-     *   type: "postgres",
-     *   host: "localhost",
-     *   username: "root",
-     *   password: "root",
-     *   database: "test",
-     *   port: 5432,
-     * });
-     *
-     * const user = await User.query({ connection: customConnection }).first();
-     * ```
-     */
-    connection?: SqlDataSource | AugmentedSqlDataSource;
-    /**
-     * @description The transaction instance to use for the model
-     */
-    trx?: Transaction;
-    /**
-     * @description Whether to ignore the hooks for the model
-     */
-    ignoreHooks?: boolean;
-};
-/**
- * @description Options that can be provided to a raw sql operation (like the raw QueryBuilder)
- */
-type RawModelOptions = {
-    /**
-     * Alias for the table
-     */
-    alias?: string;
-    /**
-     * @description Convert the column casing before making a Database query, by default preserves what is provided
-     */
-    databaseCaseConvention?: CaseConvention;
-    /**
-     * Column to use for soft deleted, by default is `deleted_at`
-     */
-    softDeleteColumn?: string;
-    /**
-     * Column to use for soft deleted, by default is date in format: "YYYY-MM-DD HH:mm:ss" in UTC timezone
-     */
-    softDeleteValue?: string | boolean;
-};
-
-/**
- * @description Due to query limitations some query builder methods may not be available in a RelationQueryBuilder
- */
-type RelationQueryBuilderType<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> = Omit<ModelQueryBuilder<T, A, R>, "increment" | "decrement" | "first" | "firstOrFail" | "paginate" | "pluck" | "truncate" | "many" | "one" | "oneOrFail" | "insert" | "insertMany" | "update" | "delete" | "softDelete" | "getSum" | "getAvg" | "getMin" | "getMax" | "getCount" | "getMin" | "getMax" | "getCount">;
-
-declare class ModelQueryBuilder<T extends Model, A extends Record<string, any> = {}, R extends Record<string, any> = {}> extends QueryBuilder<T> {
-    relation: Relation;
-    protected sqlModelManagerUtils: SqlModelManagerUtils<T>;
-    protected relationQueryBuilders: ModelQueryBuilder<any>[];
-    protected modelSelectedColumns: string[];
-    private modelColumnsMap;
-    private modelColumnsDatabaseNames;
-    protected limitValue?: number;
-    protected offsetValue?: number;
-    performance: {
-        many: (options?: ManyOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R>[];
-            time: number;
-        }>;
-        one: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R> | null;
-            time: number;
-        }>;
-        oneOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R>;
-            time: number;
-        }>;
-        first: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R> | null;
-            time: number;
-        }>;
-        firstOrFail: (options?: OneOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: AnnotatedModel<T, A, R>;
-            time: number;
-        }>;
-        paginate: (page: number, perPage: number, options?: {
-            ignoreHooks?: boolean;
-        }, returnType?: "millis" | "seconds") => Promise<{
-            data: PaginatedData<T, A, R>;
-            time: number;
-        }>;
-        exists: (returnType?: "millis" | "seconds") => Promise<{
-            data: boolean;
-            time: number;
-        }>;
-        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
-            data: [CursorPaginatedData<T, A, R>, Cursor<T, ModelKey<T>>];
-            time: number;
-        }>;
-        truncate: (returnType?: "millis" | "seconds") => Promise<{
-            data: void;
-            time: number;
-        }>;
-        delete: (returnType?: "millis" | "seconds") => Promise<{
-            data: number;
-            time: number;
-        }>;
-        update: (data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions, returnType?: "millis" | "seconds") => Promise<{
-            data: number;
-            time: number;
-        }>;
-        softDelete: (options?: Omit<SoftDeleteOptions<T>, "ignoreBeforeDeleteHook">, returnType?: "millis" | "seconds") => Promise<{
-            data: number;
-            time: number;
-        }>;
-        pluck: (key: ModelKey<T>, returnType?: "millis" | "seconds") => Promise<{
-            data: PluckReturnType<T, ModelKey<T>>;
-            time: number;
-        }>;
-    };
-    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
-    /**
-     * @description Returns true if the query builder is a relation query builder, this changes the behavior of the query builder like limit, offset, etc.
-     * @internal
-     */
-    protected get isRelationQueryBuilder(): boolean;
+    protected get isRelationQueryBuilder(): boolean;
     /**
      * @description Creates a new ModelQueryBuilder instance from a model. Will use the main connection to the database by default.
      */
@@ -3316,10 +3436,15 @@ declare class ModelManager<T extends Model> {
     protected modelInstance: T;
     protected astParser: AstParser;
     protected interpreterUtils: InterpreterUtils;
+    protected replicationMode: "master" | "slave" | null;
     /**
      * @description Constructor for ModelManager class.
      */
     constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Sets the replication mode for queries created by this model manager
+     */
+    setReplicationMode(mode: "master" | "slave"): this;
     /**
      * @description Finds all records that match the input
      */
@@ -3380,6 +3505,12 @@ declare class ModelManager<T extends Model> {
      * @description Mysql does not return the inserted model, so we need to get the inserted model from the database
      */
     private handleMysqlInsert;
+    /**
+     * @description Oracle with identity columns doesn't support INSERT ALL properly.
+     * This method inserts records one at a time to avoid duplicate ID issues.
+     * After each insert, it queries the row back using unique columns to get the generated ID.
+     */
+    private handleOracleIdentityInsert;
 }
 
 type TableColumnInfo = {
@@ -3417,163 +3548,203 @@ type TableForeignKeyInfo = {
 };
 
 /**
- * @description The SqlDataSource class is the main class for interacting with the database, it's used to create connections, execute queries, and manage transactions
+ * @description Maps a SqlDataSourceType to the raw driver response type
  */
-declare class SqlDataSource extends DataSource {
-    private static instance;
-    private globalTransaction;
-    private sqlType;
-    private models;
-    private ownsPool;
+type RawQueryResponseType<D extends SqlDataSourceType> = D extends "mysql" | "mariadb" ? QueryResult : D extends "postgres" | "cockroachdb" ? QueryResult$1 : D extends "sqlite" ? RunResult : D extends "mssql" ? IResult<any> : D extends "oracledb" ? Result<any> : any;
+
+type TransactionIsolationLevel = "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+type StartTransactionOptions = {
+    isolationLevel?: TransactionIsolationLevel;
+};
+/**
+ * @description Options for the transaction execution
+ */
+type TransactionExecutionOptions = {
     /**
-     * @description The pool of connections for the database
+     * @description If true, the transaction will throw an error if it is inactive
      */
-    sqlPool: SqlPoolType | null;
+    throwErrorOnInactiveTransaction?: boolean;
+};
+
+/**
+ * @description Transaction class, not meant to be used directly, use sql.startTransaction() instead
+ */
+declare class Transaction {
     /**
-     * @description Only used in transaction context to specify the connection, not meant to be used directly
-     * @private
+     * @description The sql data source instance that the transaction is running on here you can both query or execute raw queries
+     * @example
+     * ```ts
+     * import { sql } from "hysteria-orm";
+     * import { User } from "./models/user";
+     *
+     * // Raw queries
+     * const trx = await sql.startTransaction();
+     * await trx.rawQuery("SELECT * FROM users");
+     *
+     * // Model manager
+     * const modelManager = trx.sql.getModelManager(User);
+     * await modelManager.insert({ name: "John Doe" });
+     *
+     * // Query builder
+     * await trx.query(User.table).insert({ name: "John Doe" });
+     *
+     * await trx.commit();
+     * ```
      */
-    sqlConnection: GetConnectionReturnType<SqlDataSourceType> | null;
+    sql: Omit<SqlDataSource, "transaction" | "startGlobalTransaction" | "startTransaction">;
     /**
-     * @description Options provided in the sql data source initialization
+     * @description Whether the transaction is active
      */
-    inputDetails: SqlDataSourceInput<SqlDataSourceType>;
+    isActive: boolean;
     /**
-     * @description Adapter for `useCache`, uses an in memory strategy by default
+     * @description The transaction unique identifier
      */
-    cacheAdapter: CacheAdapter;
+    transactionId: string;
+    private connectionReleased;
+    private isolationLevel?;
+    private isNested;
+    private nestingDepth;
+    constructor(sql: SqlDataSource, isolationLevel?: TransactionIsolationLevel, isNested?: boolean, nestingDepth?: number);
     /**
-     * @description Maps global keys to specific handlers for cache handling
+     * @description Creates a new transaction with the same isolation level and same connection using save points
+     * @description If a callback is provided, it will execute the callback and commit or rollback the nested transaction save points based on the callback's success or failure
      */
-    cacheKeys: CacheKeys;
+    nestedTransaction(): Promise<Transaction>;
+    nestedTransaction(cb: (trx: Transaction) => Promise<void>): Promise<void>;
     /**
-     * @description The path to the migrations folder for the sql data source, it's used to configure the migrations path for the sql data source
+     * @description Starts a transaction, automatically handled from the sql data source instance in the `startTransaction` method
      */
-    migrationsPath: string;
+    startTransaction(): Promise<void>;
     /**
-     * @description AdminJS configuration options
+     * @description Commit the transaction releasing the connection
+     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
+     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
      */
-    private adminJsOptions?;
+    commit(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @description Cached AdminJS instance
-     */
-    private adminJsInstance?;
+     * @description Rollback the transaction releasing the connection
+     * @throws {HysteriaError} if the transaction is not active and options.throwErrorOnInactiveTransaction is true
+     * @logs if the transaction is not active and options.throwErrorOnInactiveTransaction is false
+     */
+    rollback(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @description Establishes the default singleton connection used by default by all the Models, if not configuration is passed, env variables will be used instead
-     * @description You can continue to use the global sql class exported by hysteria after the connection without having to rely on the return of this function
-     * @throws {HysteriaError} If using models in input, and the model key is already used by the sql data source instance e.g. a model called `connect` is already used by the sql data source instance and will throw an error
-     * @example
-     * ```ts
-     * import { sql } from "hysteria-orm";
-     * const connection = await sql.connect();
-     * // You can use both connection and sql from now own, since `sql` will use the default connection after being connected
-     * connection.query();
-     * sql.query();
-     *
-     * // Models will use the default connection after being connected
-     * User.query(); // Will use the default connection
-     * ```
+     * @description Release the connection, does nothing if the connection is already released
      */
-    static connect<U extends SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}>(input: SqlDataSourceInput<U, T, C>, cb?: (sqlDataSource: AugmentedSqlDataSource<T, C>) => Promise<void> | void): Promise<AugmentedSqlDataSource<T, C>>;
-    static connect<T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}>(cb?: (sqlDataSource: AugmentedSqlDataSource<T, C>) => Promise<void> | void): Promise<AugmentedSqlDataSource<T, C>>;
+    private releaseConnection;
+    private getIsolationLevelQuery;
+    private getSavePointName;
+    private getMssqlTransactionLevel;
+}
+
+/**
+ * @description The SqlDataSource class is the main class for interacting with the database, it's used to create connections, execute queries, and manage transactions
+ * @example
+ * ```ts
+ * // Create and connect to a database
+ * const sql = new SqlDataSource({
+ *   type: "mysql",
+ *   host: "localhost",
+ *   username: "root",
+ *   password: "password",
+ *   database: "mydb",
+ *   models: { User, Post }
+ * });
+ * await sql.connect();
+ *
+ * // Now you can use the connection
+ * const users = await sql.query("users").many();
+ * ```
+ */
+declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> extends DataSource {
+    #private;
+    private globalTransaction;
+    private sqlType;
+    private _models;
+    private ownsPool;
     /**
-     * @description Get's another database connection and return it, this won't be marked as the default connection used by the Models, for that use the static method `connect`
-     * @description By default not used by the Models, you have to pass it as a parameter to the Models to use it
-     * @throws {HysteriaError} If using models in input, and the model key is already used by the sql data source instance e.g. a model called `connect` is already used by the sql data source instance and will throw an error
-     * @example
-     * ```ts
-     * const anotherSql = await Sql.connectToSecondarySource({
-     *    ...connectionData
-     * });
-     *
-     * const user = await User.query({ connection: anotherSql }).many();
-     * ```
+     * @description The slaves data sources to use for the sql data source, slaves are automatically used for read operations unless specified otherwise
      */
-    static connectToSecondarySource<U extends SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}>(input: SqlDataSourceInput<U, T, C>, cb?: (sqlDataSource: AugmentedSqlDataSource<T, C>) => Promise<void> | void): Promise<AugmentedSqlDataSource<T, C>>;
-    static connectToSecondarySource<T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}>(cb?: (sqlDataSource: AugmentedSqlDataSource<T, C>) => Promise<void> | void): Promise<AugmentedSqlDataSource<T, C>>;
+    slaves: SqlDataSource<D, T, C>[];
     /**
-     * @description Creates a new connection and executes a callback with the new instance, the connection is automatically closed after the callback is executed, so it's lifespan is only inside the callback
-     * @description By default not used by the Models, you have to pass it as a parameter to the Models to use it
-     * @throws {HysteriaError} If using models in input, and the model key is already used by the sql data source instance e.g. a model called `connect` is already used by the sql data source instance and will throw an error
-     * @example
-     * ```ts
-     * await Sql.useConnection({
-     *    ...connectionData
-     * }, (sql) => {
-     *    const user = await User.query({ connection: sql }).many();
-     * });
-     * ```
+     * @description The algorithm to use for selecting the slave for read operations
+     * @default "roundRobin" - Distributes requests evenly across all slaves in sequence
+     * @option "random" - Randomly selects a slave for each request
      */
-    static useConnection<U extends SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}>(connectionDetails: UseConnectionInput<U, T, C>, cb: (sqlDataSource: AugmentedSqlDataSource<T, C>) => Promise<void>): Promise<void>;
+    slaveAlgorithm: SlaveAlgorithm;
     /**
-     * @description Returns the instance of the SqlDataSource
-     * @throws {HysteriaError} If the connection is not established
+     * @description The current index for round-robin slave selection
+     * @private
      */
-    static getInstance(): SqlDataSource;
+    private roundRobinIndex;
     /**
-     * @description Returns a QueryBuilder instance
-     * @description Query builder from the SqlDataSource instance returns raw data from the database, the data is not parsed or serialized in any way
-     * @description Optimal for performance-critical operations
-     * @description Use Models to have type safety and serialization
-     * @description Default soft delete column is "deleted_at" with stringed date value
-     * @param table The table name to query from, must be in valid sql format `table` or `table as alias`
+     * @description The pool of connections for the database
      */
-    static query<S extends string>(table: TableFormat<S>, options?: RawModelOptions): QueryBuilder;
+    sqlPool: SqlPoolType | null;
     /**
-     * @description Returns a dry query builder instance
-     * @description The dry query builder instance will not execute the query, it will return the query statement
-     * @returns The dry query builder instance
+     * @description Only used in transaction context to specify the connection, not meant to be used directly
+     * @private
      */
-    static dryQuery<S extends string>(table: TableFormat<S>, options?: RawModelOptions): DryQueryBuilderWithoutReadOperations;
+    sqlConnection: GetConnectionReturnType<D> | null;
     /**
-     * @description Creates a table on the database, return the query to be executed to create the table
+     * @description Options provided in the sql data source initialization
      */
-    static createTable(...args: Parameters<Schema["createTable"]>): string;
+    inputDetails: SqlDataSourceInput<D, T, C>;
     /**
-     * @description Alters a table on the database, return the queries to be executed in order to alter the table
+     * @description Adapter for `useCache`, uses an in memory strategy by default
      */
-    static alterTable(...args: Parameters<Schema["alterTable"]>): string[];
+    cacheAdapter: CacheAdapter;
     /**
-     * @description Starts a global transaction on the database
+     * @description Maps global keys to specific handlers for cache handling
      */
-    static startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
+    cacheKeys: C;
     /**
-     * @description Commits a global transaction on the database
-     * @throws {HysteriaError} If the global transaction is not started
+     * @description The path to the migrations folder for the sql data source, it's used to configure the migrations path for the sql data source
      */
-    static commitGlobalTransaction(): Promise<void>;
+    migrationsPath: string;
     /**
-     * @description Rolls back a global transaction on the database
-     * @throws {HysteriaError} If the global transaction is not started
+     * @description AdminJS configuration options
      */
-    static rollbackGlobalTransaction(): Promise<void>;
+    private adminJsOptions?;
     /**
-     * @description Starts a transaction on a dedicated connection from the pool and returns a Transaction instance
-     * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
-     * @param options.isolationLevel The isolation level to use for the transaction
-     * @param options.throwErrorOnInactiveTransaction Whether to throw an error if the transaction is not active
-     * @param options.endConnection Whether to end the connection after the transaction is committed or rolled back (Default is true, better to leave it this way)
-     * @sqlite ignores the isolation level
+     * @description Cached AdminJS instance
      */
-    static startTransaction(options?: StartTransactionOptions): Promise<Transaction>;
-    static startTransaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
+    private adminJsInstance?;
     /**
-     * @alias startTransaction
-     * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
-     * @param options.isolationLevel The isolation level to use for the transaction
-     * @param options.throwErrorOnInactiveTransaction Whether to throw an error if the transaction is not active
-     * @param options.endConnection Whether to end the connection after the transaction is committed or rolled back (Default is true, better to leave it this way)
-     * @sqlite ignores the isolation level
+     * @description Returns the primary instance of the SqlDataSource (set via connect with setPrimary: true)
+     * All models by default will use this instance to execute queries unless you pass a different connection/transaction in the query options
      */
-    static transaction(options?: StartTransactionOptions): Promise<Transaction>;
-    static transaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
-    static transaction(optionsOrCb?: StartTransactionOptions | ((trx: Transaction) => Promise<void>), maybeOptions?: StartTransactionOptions): Promise<StartTransactionReturnType<TransactionOptionsOrCallback>>;
+    static get instance(): SqlDataSource;
     /**
-     * @description Retrieves informations from the database for the given table
+     * @description Creates a secondary database connection that won't be set as the primary instance
+     * @description By default not used by the Models, you have to pass it as a parameter to the Models to use it
+     * @example
+     * ```ts
+     * const secondaryDb = await SqlDataSource.connectToSecondarySource({
+     *   type: "postgres",
+     *   host: "replica.db.com",
+     *   ...
+     * });
+     *
+     * const user = await User.query({ connection: secondaryDb }).many();
+     * ```
      */
-    static getTableSchema(table: string): Promise<TableSchemaInfo>;
+    static connectToSecondarySource<U extends SqlDataSourceType, M extends Record<string, SqlDataSourceModel> = {}, K extends CacheKeys = {}>(input: Omit<SqlDataSourceInput<U, M, K>, "slaves">, cb?: (sqlDataSource: SqlDataSource<U, M, K>) => Promise<void> | void): Promise<SqlDataSource<U, M, K>>;
     /**
-     * @description Closes the current connection
+     * @description Creates a temporary connection that is automatically closed after the callback is executed
+     * @example
+     * ```ts
+     * await SqlDataSource.useConnection({
+     *   type: "mysql",
+     *   ...connectionData
+     * }, async (sql) => {
+     *   const user = await User.query({ connection: sql }).many();
+     * });
+     * // Connection is automatically closed here
+     * ```
+     */
+    static useConnection<U extends SqlDataSourceType, M extends Record<string, SqlDataSourceModel> = {}, K extends CacheKeys = {}>(connectionDetails: UseConnectionInput<U, M, K>, cb: (sqlDataSource: SqlDataSource<U, M, K>) => Promise<void>): Promise<void>;
+    /**
+     * @description Closes the primary connection (singleton instance)
      */
     static closeConnection(): Promise<void>;
     /**
@@ -3581,69 +3752,93 @@ declare class SqlDataSource extends DataSource {
      */
     static disconnect(): Promise<void>;
     /**
-     * @description Executes a raw query on the database
+     * @description Starts a global transaction on the primary database connection
+     * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
      */
-    static rawQuery<T = any>(query: string, params?: any[]): Promise<T>;
+    static startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
     /**
-     * @description Adds a raw statement to an operation like where or update, those raw values won't be used as bindings and will be used as the are
+     * @description Commits a global transaction on the primary database connection
+     * @throws {HysteriaError} If the global transaction is not started
+     */
+    static commitGlobalTransaction(): Promise<void>;
+    /**
+     * @description Rolls back a global transaction on the primary database connection
+     * @throws {HysteriaError} If the global transaction is not started
+     */
+    static rollbackGlobalTransaction(): Promise<void>;
+    /**
+     * @description Returns true if the primary instance is in a global transaction
+     */
+    static get isInGlobalTransaction(): boolean;
+    /**
+     * @description Creates a new SqlDataSource instance. Call `.connect()` to establish the connection.
+     * @param input Configuration options for the database connection. If not provided, uses env variables.
      * @example
      * ```ts
-     * import { sql } from "hysteria-orm";
+     * // With explicit config
+     * const sql = new SqlDataSource({
+     *   type: "mysql",
+     *   host: "localhost",
+     *   username: "root",
+     *   password: "password",
+     *   database: "mydb",
+     *   models: { User, Post }
+     * });
+     * await sql.connect();
      *
-     * await User.query().where("name", sql.rawStatement("LOWER(name)"));
+     * // Using env variables
+     * const sql = new SqlDataSource();
+     * await sql.connect();
      * ```
      */
-    static rawStatement(value: string): RawNode;
+    constructor(input?: SqlDataSourceInput<D, T, C>);
     /**
-     * @description Initializes AdminJS with the configured options
-     * @description All AdminJS dependencies are loaded at runtime via dynamic import() to keep the plugin optional
-     * @description To use AdminJS, install: npm install adminjs
-     * @throws {HysteriaError} If AdminJS is not enabled or connection not established
-     * @returns The AdminJS instance
+     * @description Establishes the database connection and sets this instance as the primary connection, it also connects to the slaves if any are configured
+     * @throws {HysteriaError} If the connection is already established, use `SqlDataSource.useConnection` or `SqlDataSource.connectToSecondarySource` for auxiliary connections
+     * @example
+     * ```ts
+     * const sql = new SqlDataSource({ type: "mysql", ... });
+     * await sql.connect();
+     * ```
      */
-    static initializeAdminJs(): Promise<AdminJsAdminInstance>;
+    connect(): Promise<void>;
     /**
-     * @description Initializes AdminJS with Express router
-     * @description All AdminJS dependencies are loaded at runtime via dynamic import() to keep the plugin optional
-     * @description To use AdminJS with Express, install: npm install adminjs @adminjs/express express express-formidable --save-dev
-     * @throws {HysteriaError} If AdminJS is not enabled or connection not established
-     * @returns The AdminJS instance with Express router
+     * @description Returns true if the connection is established
      */
-    static initializeAdminJsExpress(): Promise<AdminJsInstance>;
+    get isConnected(): boolean;
     /**
-     * @description Returns the AdminJS instance if initialized
-     * @returns The AdminJS instance or undefined if not initialized
+     * @description Returns true if this instance is in a global transaction
      */
-    static getAdminJs(): AdminJsInstance | undefined;
+    get isInGlobalTransaction(): boolean;
     /**
-     * @description Checks if AdminJS is enabled
-     * @returns True if AdminJS is enabled
+     * @description Returns the models configured on this SqlDataSource instance
      */
-    static isAdminJsEnabled(): boolean;
-    private constructor();
+    get models(): T;
+    /**
+     * @description Selects a slave from the pool using the configured algorithm
+     * @returns A slave SqlDataSource instance or null if no slaves are available
+     */
+    getSlave(): SqlDataSource<D, T, C> | null;
     /**
      * @description Uses the cache adapter to get a value from the cache
      * @param key The key to get the value from
      * @param args The arguments to pass to the key handler
      */
-    useCache<M extends Record<string, typeof Model>, C extends CacheKeys, K extends keyof C>(this: AugmentedSqlDataSource<M, C>, key: K, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
+    useCache<K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
     /**
      * @description Uses the cache adapter to get a value from the cache
      * @param key The key to get the value from
      * @param ttl The time to live for the value in milliseconds
      * @param args The arguments to pass to the key handler
      */
-    useCache<M extends Record<string, typeof Model>, C extends CacheKeys, K extends keyof C>(this: AugmentedSqlDataSource<M, C>, key: K, ttl: number, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
+    useCache<K extends keyof C>(key: K, ttl: number, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
     /**
      * @description Invalidates a value from the cache
      * @param key The key to invalidate the value from
-     * @param args The arguments to pass to the key handler
-     */
-    invalidCache<M extends Record<string, typeof Model>, C extends CacheKeys, K extends keyof C>(this: AugmentedSqlDataSource<M, C>, key: K, ...args: Parameters<C[K]>): Promise<void>;
-    /**
-     * @description Returns true if the connection is established
+     * @param args The arguments to pass to the key handler (required if the handler expects arguments)
      */
-    get isConnected(): boolean;
+    invalidCache<K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<void>;
+    invalidCache<K extends keyof C>(key: K): Promise<void>;
     /**
      * @description Clones the SqlDataSource instance
      * @param options.shouldRecreatePool Whether to recreate the pool of connections for the given driver, by default it's false
@@ -3654,20 +3849,15 @@ declare class SqlDataSource extends DataSource {
     /**
      * @description Returns the type of the database
      */
-    getDbType(): SqlDataSourceType;
+    getDbType(): D;
     /**
-     * @description Returns a QueryBuilder instance
-     * @description Query builder from the SqlDataSource instance uses raw data from the database so the data is not parsed or serialized in any way
-     * @description Optimal for performance-critical operations
-     * @description Use Models to have type safety and serialization
-     * @description Default soft delete column is "deleted_at" with stringed date value
-     * @param table The table name to query from, must be in valid sql format `table` or `table as alias`
+     * @description Returns a QueryBuilder instance for raw queries
+     * @description Query builder from the SqlDataSource instance returns raw data from the database
+     * @param table The table name to query from
      */
     query<S extends string>(table: TableFormat<S>, options?: RawModelOptions): QueryBuilder;
     /**
-     * @description Returns a DryQueryBuilder instance
-     * @description The dry query builder instance will not execute the query, it will return the query statement
-     * @returns The dry query builder instance
+     * @description Returns a DryQueryBuilder instance that returns the query statement without executing
      */
     dryQuery<S extends string>(table: TableFormat<S>, options?: RawModelOptions): DryQueryBuilderWithoutReadOperations;
     /**
@@ -3679,94 +3869,78 @@ declare class SqlDataSource extends DataSource {
      */
     createTable(...args: Parameters<Schema["createTable"]>): string;
     /**
-     * @description Starts a global transaction on the database on the main connection pool, intended to for testing purposes only, don't use it in production
+     * @description Starts a global transaction on the database
+     * @description Intended for testing purposes - wraps all operations in a transaction that can be rolled back
      */
     startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
     /**
-     * @description Commits a global transaction on the database on the main connection pool, intended to for testing purposes only, don't use it in production
+     * @description Commits a global transaction on the database
      * @throws {HysteriaError} If the global transaction is not started
      */
     commitGlobalTransaction(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @description Rolls back a global transaction on the database on the main connection pool, intended to for testing purposes only, don't use it in production
-     * @throws {HysteriaError} If the global transaction is not started and options.throwErrorOnInactiveTransaction is true
+     * @description Rolls back a global transaction on the database
      */
     rollbackGlobalTransaction(options?: TransactionExecutionOptions): Promise<void>;
     /**
-     * @description Get's a connection from the pool and starts a transaction on the database and returns an already started transaction instance
+     * @description Starts a transaction on a dedicated connection from the pool
      * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
      * @param options.isolationLevel The isolation level to use for the transaction
-     * @param options.throwErrorOnInactiveTransaction Whether to throw an error if the transaction is not active
-     * @param options.endConnection Whether to end the connection after the transaction is committed or rolled back (Default is true, better to leave it this way)
      * @sqlite ignores the isolation level
      */
     startTransaction(options?: StartTransactionOptions): Promise<Transaction>;
     startTransaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
     /**
      * @alias startTransaction
-     * @description Get's a connection from the pool and starts a transaction on the database and returns an already started transaction instance
-     * @param cb if a callback is provided, it will execute the callback and commit or rollback the transaction based on the callback's success or failure
-     * @param options.isolationLevel The isolation level to use for the transaction
-     * @param options.throwErrorOnInactiveTransaction Whether to throw an error if the transaction is not active
-     * @param options.endConnection Whether to end the connection after the transaction is committed or rolled back (Default is true, better to leave it this way)
-     * @sqlite ignores the isolation level
      */
     transaction(options?: StartTransactionOptions): Promise<Transaction>;
     transaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
     /**
-     * @description Returns a ModelManager instance for the given model, it's advised to use Model static methods instead.
-     * @description This is intended to use only if you do not want to use active record pattern
+     * @description Returns a ModelManager instance for the given model
      */
-    getModelManager<T extends Model>(model: {
-        new (): T;
-    } | typeof Model): ModelManager<T>;
+    getModelManager<M extends Model>(model: {
+        new (): M;
+    } | typeof Model): ModelManager<M>;
     /**
-     * @description Returns the current raw driver Pool, you can specify the type of connection you want to get to have better type safety
+     * @description Returns the current raw driver Pool
      * @throws {HysteriaError} If the connection pool is not established
-     * @example
-     * const mysqlConnection = sql.getPool("mysql"); // mysql2 Pool
-     * const pgConnection = sql.getPool("postgres"); // pg Pool
-     * const sqliteConnection = sql.getPool("sqlite"); // sqlite3 Database
      */
-    getPool<T extends SqlDataSourceType = typeof this.sqlType>(_specificType?: T): getPoolReturnType<T>;
+    getPool(): getPoolReturnType<D>;
     /**
-     * @description Returns a connection from the pool, you can specify the type of connection you want to get to have better type safety
+     * @description Returns a connection from the pool
      * @throws {HysteriaError} If the connection is not established
-     * @example
-     * const mysqlConnection = sql.getConnection("mysql"); // mysql2 PoolConnection
-     * const pgConnection = sql.getConnection("postgres"); // pg PoolClient
-     * const sqliteConnection = sql.getConnection("sqlite"); // sqlite3 Database
      */
-    getConnection<T extends SqlDataSourceType = typeof this.sqlType>(_specificType?: T): Promise<GetConnectionReturnType<T>>;
+    getConnection(): Promise<GetConnectionReturnType<D>>;
     /**
      * @description Closes the current connection
      * @description If there is an active global transaction, it will be rolled back
+     * @description Also disconnects all slave connections if any are configured
      */
     closeConnection(): Promise<void>;
-    getConnectionDetails(): SqlDataSourceInput<SqlDataSourceType>;
+    /**
+     * @description Returns the connection details
+     */
+    getConnectionDetails(): SqlDataSourceInput<D, T, C>;
     /**
      * @alias closeConnection
      */
     disconnect(): Promise<void>;
     /**
      * @description Syncs the schema of the database with the models metadata
-     * @warning This will drop and recreate all the indexes and constraints, use with caution and not in production environments
-     * @param options.transactional Whether to use a transaction to sync the schema, if true it will use a transaction for the entire sync operation, defaults to false
+     * @warning This will drop and recreate all the indexes and constraints, use with caution
      * @sqlite Not supported but won't throw an error
      */
     syncSchema(options?: {
         transactional: boolean;
     }): Promise<void>;
     /**
-     * @description Executes a raw query on the database
+     * @description Executes a raw query on the database and returns the raw driver result
      */
-    rawQuery<T = any>(query: string, params?: any[]): Promise<T>;
+    rawQuery<R = RawQueryResponseType<D>>(query: string, params?: any[], options?: RawQueryOptions): Promise<R>;
     /**
-     * @description Adds a raw statement to an operation like where or update, those raw values won't be used as bindings and will be used as the are
+     * @description Adds a raw statement to an operation like where or update
      * @example
      * ```ts
-     * import { sql } from "hysteria-orm";
-     *
      * await User.query().where("name", sql.rawStatement("LOWER(name)"));
      * ```
      */
@@ -3785,33 +3959,24 @@ declare class SqlDataSource extends DataSource {
     })[];
     /**
      * @description Initializes AdminJS with the configured options
-     * @description All AdminJS dependencies are loaded at runtime via dynamic import() to keep the plugin optional
-     * @description To use AdminJS, install: npm install adminjs
      * @throws {HysteriaError} If AdminJS is not enabled in the configuration
-     * @returns The AdminJS instance
      */
     initializeAdminJs(): Promise<AdminJsAdminInstance>;
     /**
      * @description Initializes AdminJS with Express router
-     * @description All AdminJS dependencies are loaded at runtime via dynamic import() to keep the plugin optional
-     * @description To use AdminJS with Express, install: npm install adminjs @adminjs/express express express-formidable --save-dev
      * @throws {HysteriaError} If AdminJS is not enabled in the configuration
-     * @returns The AdminJS instance with Express router
      */
-    initializeAdminJsExpress(): Promise<AdminJsInstance>;
+    initializeAdminJsExpress(): Promise<Required<AdminJsInstance>>;
     /**
      * @description Returns the AdminJS instance if initialized
-     * @returns The AdminJS instance or undefined if not initialized
      */
     getAdminJs(): AdminJsInstance | undefined;
     /**
      * @description Returns the AdminJS configuration options
-     * @returns The AdminJS configuration options or undefined if not configured
      */
     getAdminJsOptions(): AdminJsOptions | undefined;
     /**
      * @description Checks if AdminJS is enabled
-     * @returns True if AdminJS is enabled
      */
     isAdminJsEnabled(): boolean;
     /**
@@ -3819,217 +3984,86 @@ declare class SqlDataSource extends DataSource {
      */
     getTableInfo(table: string): Promise<TableColumnInfo[]>;
     /**
-     * @description Introspects table indexes metadata using AST-driven queries
+     * @description Introspects table indexes metadata
      */
     getIndexInfo(table: string): Promise<TableIndexInfo[]>;
+    /**
+     * @description Introspects table foreign keys metadata
+     */
     getForeignKeyInfo(table: string): Promise<TableForeignKeyInfo[]>;
     /**
      * @description Introspects table primary key from the database
      */
     getPrimaryKeyInfo(table: string): Promise<TablePrimaryKeyInfo | undefined>;
-    private testConnectionQuery;
-    private sanitizeModelKeys;
-    static get isInGlobalTransaction(): boolean;
-    get isInGlobalTransaction(): boolean;
     /**
-     * @description Returns the models registered on this SqlDataSource instance (as provided in connect input)
+     * @description Internal method to establish connection without setting as primary instance
+     * @description Used by connectToSecondarySource and useConnection
      */
-    get registeredModels(): Record<string, typeof Model>;
+    private connectWithoutSettingPrimary;
 }
 
-type Sqlite3ConnectionOptions = {
-    mode: number;
-};
-type SqlDriverSpecificOptions<T extends DataSourceType> = Omit<DriverSpecificOptions<T>, "mongoOptions" | "redisOptions">;
-type MysqlConnectionInstance = Awaited<ReturnType<Mysql2Import["createPool"]>>;
-type PgPoolClientInstance = InstanceType<PgImport["Pool"]>;
-type SqliteConnectionInstance = InstanceType<Sqlite3Import["Database"]>;
-type MssqlPoolInstance = InstanceType<MssqlImport["ConnectionPool"]>;
-type MssqlConnectionInstance = Awaited<ReturnType<MssqlPoolInstance["connect"]>>;
-type SqlPoolType = MysqlConnectionInstance | PgPoolClientInstance | SqliteConnectionInstance | MssqlPoolInstance;
-/**
- * @description The connection policies for the sql data source
- * @default By default, the connection policies are not set, so no query will be retried
- */
-type ConnectionPolicies = {
-    /**
-     * @description The retry policy for the sql data source, it allows to retry a query if it fails
-     */
-    retry?: {
-        maxRetries?: number;
-        delay?: number;
-    };
-};
-type SqlDataSourceModel = typeof Model;
-/**
- * @description The input type for the SqlDataSource constructor
- * @description The connectionPolicies object is used to configure the connection policies for the sql data source
- */
-type SqlDataSourceInput<D extends SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> = {
-    readonly type?: D;
-    /**
-     * @description Whether to log the sql queries and other debug information
-     */
-    readonly logs?: boolean;
-    /**
-     * @description The connection policies to use for the sql data source that are not configured in the driverOptions
-     */
-    connectionPolicies?: ConnectionPolicies;
+type ModelWithoutRelations<T extends Model> = Pick<T, ExcludeRelations<Omit<T, "*">>>;
+type NumberModelKey<T extends Model> = {
+    [K in keyof T]: T[K] extends number | bigint ? K : never;
+}[keyof T];
+type BaseModelMethodOptions = {
     /**
-     * @description The query format options to use for the sql data source, it tells how the sql queries should be formatted before being executed and logged
+     * @description The connection to use for the model, by default the main connection will be used
+     * @description The main connection is the one created via `new SqlDataSource().connect()`
+     * @example
+     * ```ts
+     * import { SqlDataSource } from "hysteria-orm";
+     * const customConnection = await SqlDataSource.connectToSecondarySource({
+     *   type: "postgres",
+     *   host: "localhost",
+     *   username: "root",
+     *   password: "root",
+     *   database: "test",
+     *   port: 5432,
+     * });
+     *
+     * const user = await User.query({ connection: customConnection }).first();
+     * ```
      */
-    queryFormatOptions?: FormatOptionsWithLanguage;
+    connection?: SqlDataSource;
     /**
-     * @description The models to use for the sql data source, if used models will be registered in the sql data source instance and will be available for the models to use
-     * @description Models can still be used as standalone entities, but they won't be available for the sql data source instance
+     * @description The transaction instance to use for the model
      */
-    models?: T;
+    trx?: Transaction;
     /**
-     * @description The driver specific options to use for the sql data source, it's used to configure the driver specific options for the sql data source
-     * @warning For usage with types, you must have driver types installed if the driver handles types in a type package like e.g. `@types/pg`
+     * @description Whether to ignore the hooks for the model
      */
-    driverOptions?: SqlDriverSpecificOptions<D>;
+    ignoreHooks?: boolean;
     /**
-     * @description The path to the migrations folder for the sql data source, it's used to configure the migrations path for the sql data source
-     * @default "database/migrations"
+     * @description The replication mode to use for the model
+     * @description If not specified, read operations will use slave (if available) else master, and write operations will always use master
+     * @description If set to "master", all operations will use master
+     * @description If set to "slave", read operations will use slave and write operations will use master
      */
-    migrationsPath?: string;
+    replicationMode?: ReplicationType;
+};
+/**
+ * @description Options that can be provided to a raw sql operation (like the raw QueryBuilder)
+ */
+type RawModelOptions = {
     /**
-     * @description The cache strategy to use for the sql data source, it's used to configure the cache strategy for the sql data source
+     * Alias for the table
      */
-    cacheStrategy?: {
-        cacheAdapter?: CacheAdapter;
-        keys: C;
-    };
+    alias?: string;
     /**
-     * @description AdminJS configuration for the admin panel
-     * @description To use AdminJS, install: `npm install adminjs`
+     * @description Convert the column casing before making a Database query, by default preserves what is provided
      */
-    adminJs?: AdminJsOptions;
-} & (MysqlSqlDataSourceInput | MssqlDataSourceInput | PostgresSqlDataSourceInput | SqliteDataSourceInput);
-type UseConnectionInput<D extends SqlDataSourceType, T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> = {
-    readonly type: Exclude<DataSourceType, "mongo">;
-    readonly logs?: boolean;
-    readonly models?: T;
-    readonly driverOptions?: SqlDriverSpecificOptions<D>;
-    connectionPolicies?: ConnectionPolicies;
-    queryFormatOptions?: FormatOptionsWithLanguage;
-    cacheStrategy?: {
-        cacheAdapter: CacheAdapter;
-        keys: C;
-    };
+    databaseCaseConvention?: CaseConvention;
     /**
-     * @description AdminJS configuration for the admin panel
-     * @description AdminJS is completely optional - dependencies are loaded at runtime via dynamic import()
+     * Column to use for soft deleted, by default is `deleted_at`
      */
-    adminJs?: AdminJsOptions;
-} & (NotNullableMysqlSqlDataSourceInput | NotNullablePostgresSqlDataSourceInput | NotNullableSqliteDataSourceInput);
-type SqlDataSourceType = Exclude<DataSourceType, "mongo">;
-type SqlCloneOptions = {
+    softDeleteColumn?: string;
     /**
-     * @description Whether to recreate the pool of connections for the given driver, by default it's false
-     * @warning If false, the pool of connections will be reused from the caller instance
+     * Column to use for soft deleted, by default is date in format: "YYYY-MM-DD HH:mm:ss" in UTC timezone
      */
-    shouldRecreatePool?: boolean;
-};
-type getPoolReturnType<T = SqlDataSourceType> = T extends "mysql" ? MysqlConnectionInstance : T extends "mariadb" ? MysqlConnectionInstance : T extends "postgres" ? PgPoolClientInstance : T extends "cockroachdb" ? PgPoolClientInstance : T extends "sqlite" ? SqliteConnectionInstance : T extends "mssql" ? MssqlPoolInstance : never;
-type GetConnectionReturnType<T = SqlDataSourceType> = T extends "mysql" ? PoolConnection : T extends "mariadb" ? PoolConnection : T extends "postgres" ? PoolClient : T extends "cockroachdb" ? PoolClient : T extends "sqlite" ? InstanceType<Sqlite3Import["Database"]> : T extends "mssql" ? Transaction$1 : never;
-type UseCacheOverloads<C extends CacheKeys> = {
-    <K extends keyof C>(key: K, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
-    <K extends keyof C>(key: K, ttl: number, ...args: Parameters<C[K]>): Promise<UseCacheReturnType<C, K>>;
-};
-type UseCacheType<C extends CacheKeys> = keyof C extends never ? SqlDataSource["useCache"] : UseCacheOverloads<C>;
-type InvalidCacheType<C extends CacheKeys> = keyof C extends never ? SqlDataSource["invalidCache"] : <K extends keyof C>(key: K) => Promise<void>;
-type AugmentedSqlDataSource<T extends Record<string, SqlDataSourceModel> = {}, C extends CacheKeys = {}> = Omit<SqlDataSource, "useCache" | "invalidCache" | "clone"> & {
-    useCache: UseCacheType<C>;
-    invalidCache: InvalidCacheType<C>;
-    clone(options?: SqlCloneOptions): Promise<AugmentedSqlDataSource<T, C>>;
-} & {
-    [key in keyof T]: T[key];
-};
-type SqlDataSourceWithoutTransaction<T extends Record<string, SqlDataSourceModel> = {}> = Pick<SqlDataSource, "sqlPool" | "sqlConnection" | "inputDetails" | "isConnected" | "getDbType" | "clone" | "getModelManager" | "getPool" | "getConnection" | "closeConnection" | "getConnectionDetails" | "disconnect" | "syncSchema" | "rawQuery" | "rawStatement" | "getTableSchema" | "getModelOpenApiSchema" | "getTableInfo" | "getIndexInfo" | "getForeignKeyInfo" | "getPrimaryKeyInfo" | "registeredModels" | "type" | "host" | "port" | "username" | "password" | "database" | "logs" | "query"> & {
-    [key in keyof T]: T[key];
-};
-/** Only accepts formats `string` e `string as string` */
-type NoSpace<S extends string> = S extends `${infer _} ${infer _}` ? never : S;
-type TableFormat<S extends string> = NoSpace<S> | (S extends `${infer L} as ${infer R}` ? `${NoSpace<L>} as ${NoSpace<R>}` : never);
-
-type AstParserType = {
-    sql: string;
-    bindings: any[];
+    softDeleteValue?: string | boolean;
 };
 
-declare class AstParser {
-    private readonly dbType;
-    private readonly model;
-    constructor(model: typeof Model, dbType: SqlDataSourceType);
-    parse(nodes: (QueryNode | null)[], startBindingIndex?: number, isNestedCondition?: boolean): AstParserType;
-    /**
-     * Map the database type to a common type if shares the same driver (e.g. mysql and mariadb)
-     */
-    private mapCommonDbType;
-    /**
-     * @description Generates MSSQL table hints from lock node
-     * MSSQL uses WITH (UPDLOCK), WITH (HOLDLOCK), etc. as table hints
-     * READPAST is the MSSQL equivalent of SKIP LOCKED
-     */
-    private getMssqlTableHints;
-}
-
-declare class DeleteNode extends QueryNode {
-    fromNode: FromNode;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode, isRawValue?: boolean);
-}
-
-declare class InsertNode extends QueryNode {
-    fromNode: FromNode;
-    records: Record<string, any>[];
-    returning?: string[];
-    disableReturning: boolean;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode, records?: Record<string, any>[], returning?: string[], disableReturning?: boolean, isRawValue?: boolean);
-}
-
-declare class OnDuplicateNode extends QueryNode {
-    table: string;
-    conflictColumns: string[];
-    columnsToUpdate: string[];
-    returning?: string[];
-    mode: "update" | "ignore";
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(table: string, conflictColumns: string[], columnsToUpdate: string[], mode?: "update" | "ignore", returning?: string[], isRawValue?: boolean);
-}
-
-declare class TruncateNode extends QueryNode {
-    fromNode: FromNode | string;
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode | string, isRawValue?: boolean);
-}
-
-declare class UpdateNode extends QueryNode {
-    fromNode: FromNode;
-    columns: string[];
-    values: (any | RawNode)[];
-    chainsWith: string;
-    canKeywordBeSeenMultipleTimes: boolean;
-    folder: string;
-    file: string;
-    constructor(fromNode: FromNode, columns?: string[], values?: (any | RawNode)[], isRawValue?: boolean);
-}
-
 declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
     model: typeof Model;
     protected astParser: AstParser;
@@ -4044,6 +4078,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
     protected updateNode: UpdateNode | null;
     protected deleteNode: DeleteNode | null;
     protected truncateNode: TruncateNode | null;
+    protected replicationMode: ReplicationType | null;
     /**
      * @description Performance methods that return the time that took to execute the query with the result
      */
@@ -4110,6 +4145,14 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
         }>;
     };
     constructor(model: typeof Model, sqlDataSource?: SqlDataSource);
+    /**
+     * @description Sets the replication mode for the query builder
+     * @param replicationMode - The replication mode to use for the query builder
+     * @description If not specified, read operations will use slave (if available) else master, and write operations will always use master
+     * @description If set to "master", all operations will use master
+     * @description If set to "slave", read operations will use slave and write operations will use master
+     */
+    setReplicationMode(replicationMode: ReplicationType): this;
     /**
      * @description Executes the query and returns true if the query returns at least one result, false otherwise.
      */
@@ -4294,6 +4337,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      * @description Insert multiple records into a table
      * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
      * @returns raw driver response
+     * @oracledb may do multiple inserts with auto-generated identity columns
      */
     insertMany(data: Record<string, any>[], returning?: string[]): Promise<T[]>;
     /**
@@ -4411,6 +4455,7 @@ declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
      * @description Executes pagination queries, serializing them for MSSQL transactions
      */
     protected executePaginateQueries<M, C>(modelsQuery: () => Promise<M>, countQuery: () => Promise<C>): Promise<[M, C]>;
+    protected getSqlDataSource(mode: "read" | "write"): Promise<SqlDataSource>;
 }
 
 type UnionCallBack<T extends Model> = (queryBuilder: QueryBuilder<T>) => QueryBuilder<T>;
@@ -4591,6 +4636,7 @@ declare abstract class Model extends Entity {
      * @mysql If no Primary Key is present in the model definition, the model will be returned
      * @sqlite If no Primary Key is present in the model definition, the model will be returned
      * @sqlite Returning Not supported and won't have effect
+     * @oracledb may do multiple inserts with auto-generated identity columns
      */
     static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): Promise<AnnotatedModel<T, {}>[]>;
     /**
@@ -5810,7 +5856,7 @@ declare abstract class Migration {
     /**
      * @description This method is called after the migration has been run
      */
-    afterMigration?(sqlDataSource: SqlDataSource | AugmentedSqlDataSource): Promise<void>;
+    afterMigration?(sqlDataSource: SqlDataSource): Promise<void>;
 }
 
 /**
@@ -5863,7 +5909,7 @@ type WithPerformanceResult<R = any> = [string, R];
  */
 declare const withPerformance: <A extends any[], R>(fn: (...args: A) => Promise<R>, returnType?: "millis" | "seconds", fix?: number) => (...args: A) => Promise<WithPerformanceResult<R>>;
 
-type HysteriaErrorCode = `UNSUPPORTED_ISOLATION_LEVEL_${string}` | "ROW_NOT_FOUND" | `UNSUPPORTED_DATABASE_TYPE_${string}` | `RELATION_TYPE_NOT_SUPPORTED_${string}` | `NOT_SUPPORTED_IN_${string}` | `RELATION_NOT_FOUND_IN_MODEL_${string}` | `UNKNOWN_RELATION_TYPE_${string}` | `DISTINCT_ON_NOT_SUPPORTED_IN_${string}` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_HAS_ONE_RELATION_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_BELONGS_TO_RELATION_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_HAS_MANY_RELATION_${string}` | `MANY_TO_MANY_RELATION_NOT_FOUND_FOR_RELATED_MODEL_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_MANY_TO_MANY_RELATION_${string}` | `RELATED_MODEL_DOES_NOT_HAVE_A_PRIMARY_KEY_${string}` | `FOR_SHARE_NOT_SUPPORTED_IN_${string}` | `SKIP_LOCKED_NOT_SUPPORTED_IN_${string}` | `LOCK_FOR_UPDATE_NOT_SUPPORTED_${string}` | `KEY_${string}_HAS_NO_HANDLER_IN_CACHE_KEYS_CONFIG` | `CACHE_ADAPTER_NOT_CONFIGURED` | `SQLITE_NOT_SUPPORTED` | `COCKROACHDB_NOT_SUPPORTED` | `RELATION_NOT_FOUND` | `POSTGRES_TABLE_REQUIRED` | `MODEL_HAS_NO_PRIMARY_KEY_VALUE` | `RELATION_NOT_MANY_TO_MANY` | "MATERIALIZED_CTE_NOT_SUPPORTED" | "DUPLICATE_MODEL_KEYS_WHILE_INSTANTIATING_MODELS" | "INVALID_ONE_PARAMETER_WHERE_CONDITION" | "INVALID_PAGINATION_PARAMETERS" | "MISSING_ALIAS_FOR_SUBQUERY" | "MODEL_HAS_NO_PRIMARY_KEY" | "PRIMARY_KEY_NOT_FOUND" | "SQLITE_ONLY_SUPPORTS_SERIALIZABLE_ISOLATION_LEVEL" | "MUST_CALL_BUILD_CTE_AT_LEAST_ONCE" | "REGEXP_NOT_SUPPORTED_IN_SQLITE" | "MANY_TO_MANY_RELATION_MUST_HAVE_A_THROUGH_MODEL" | "INSERT_FAILED" | "MULTIPLE_PRIMARY_KEYS_NOT_ALLOWED" | "FILE_NOT_A_SQL_OR_TXT_FILE" | "CONNECTION_NOT_ESTABLISHED" | "TRANSACTION_NOT_ACTIVE" | "DEVELOPMENT_ERROR" | "MIGRATION_MODULE_NOT_FOUND" | "DRIVER_NOT_FOUND" | "FILE_NOT_FOUND_OR_NOT_ACCESSIBLE" | "ENV_NOT_SET" | "REQUIRED_VALUE_NOT_SET" | "SET_FAILED" | "GET_FAILED" | "REFERENCES_OPTION_REQUIRED" | "DELETE_FAILED" | "INVALID_DEFAULT_VALUE" | "DISCONNECT_FAILED" | "FLUSH_FAILED" | "LEFT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "RIGHT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "MODEL_HAS_NO_PRIMARY_KEY" | "GLOBAL_TRANSACTION_ALREADY_STARTED" | "GLOBAL_TRANSACTION_NOT_STARTED" | "MYSQL_REQUIRES_TABLE_NAME_FOR_INDEX_DROP" | "INVALID_DATE_OBJECT" | "INVALID_DATE_STRING" | "FAILED_TO_PARSE_DATE" | "MIGRATION_MODULE_REQUIRES_TS_NODE" | "FAILED_TO_ENCRYPT_SYMMETRICALLY" | "FAILED_TO_DECRYPT_SYMMETRICALLY" | "FAILED_TO_ENCRYPT_ASYMMETRICALLY" | "FAILED_TO_DECRYPT_ASYMMETRICALLY" | "UNSUPPORTED_RELATION_TYPE" | "LPUSH_FAILED" | "RPUSH_FAILED" | "LPOP_FAILED" | "RPOP_FAILED" | "LRANGE_FAILED" | "LLEN_FAILED" | "HSET_FAILED" | "HMSET_FAILED" | "HGET_FAILED" | "HGETALL_FAILED" | "HMGET_FAILED" | "HDEL_FAILED" | "HEXISTS_FAILED" | "HKEYS_FAILED" | "HLEN_FAILED" | "SADD_FAILED" | "SMEMBERS_FAILED" | "SREM_FAILED" | "SISMEMBER_FAILED" | "SCARD_FAILED" | "SINTER_FAILED" | "SUNION_FAILED" | "SDIFF_FAILED" | "ZADD_FAILED" | "ZRANGE_FAILED" | "ZREVRANGE_FAILED" | "ZREM_FAILED" | "ZSCORE_FAILED" | "ZCARD_FAILED" | "SUBSCRIBE_FAILED" | "UNSUBSCRIBE_FAILED" | "PUBLISH_FAILED" | "PSUBSCRIBE_FAILED" | "PUNSUBSCRIBE_FAILED" | "EXISTS_FAILED" | "EXPIRE_FAILED" | "EXPIREAT_FAILED" | "PEXPIRE_FAILED" | "TTL_FAILED" | "PTTL_FAILED" | "PERSIST_FAILED" | "KEYS_FAILED" | "RENAME_FAILED" | "TYPE_FAILED" | "SCAN_FAILED" | "ADMINJS_NOT_ENABLED" | "ADMINJS_INITIALIZATION_FAILED" | "ADMINJS_NO_MODELS_PROVIDED";
+type HysteriaErrorCode = "CONNECTION_ALREADY_ESTABLISHED" | `UNSUPPORTED_ISOLATION_LEVEL_${string}` | "ROW_NOT_FOUND" | `UNSUPPORTED_DATABASE_TYPE_${string}` | `RELATION_TYPE_NOT_SUPPORTED_${string}` | `NOT_SUPPORTED_IN_${string}` | `RELATION_NOT_FOUND_IN_MODEL_${string}` | `UNKNOWN_RELATION_TYPE_${string}` | `DISTINCT_ON_NOT_SUPPORTED_IN_${string}` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA` | `CONFLICT_COLUMNS_NOT_PRESENT_IN_DATA_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_HAS_ONE_RELATION_${string}` | `FOREIGN_KEY_VALUES_MISSING_FOR_BELONGS_TO_RELATION_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_HAS_MANY_RELATION_${string}` | `MANY_TO_MANY_RELATION_NOT_FOUND_FOR_RELATED_MODEL_${string}` | `PRIMARY_KEY_VALUES_MISSING_FOR_MANY_TO_MANY_RELATION_${string}` | `RELATED_MODEL_DOES_NOT_HAVE_A_PRIMARY_KEY_${string}` | `FOR_SHARE_NOT_SUPPORTED_IN_${string}` | `SKIP_LOCKED_NOT_SUPPORTED_IN_${string}` | `LOCK_FOR_UPDATE_NOT_SUPPORTED_${string}` | `KEY_${string}_HAS_NO_HANDLER_IN_CACHE_KEYS_CONFIG` | `CACHE_ADAPTER_NOT_CONFIGURED` | `SQLITE_NOT_SUPPORTED` | `COCKROACHDB_NOT_SUPPORTED` | `RELATION_NOT_FOUND` | `POSTGRES_TABLE_REQUIRED` | `MODEL_HAS_NO_PRIMARY_KEY_VALUE` | `RELATION_NOT_MANY_TO_MANY` | "MATERIALIZED_CTE_NOT_SUPPORTED" | "DUPLICATE_MODEL_KEYS_WHILE_INSTANTIATING_MODELS" | "INVALID_ONE_PARAMETER_WHERE_CONDITION" | "INVALID_PAGINATION_PARAMETERS" | "MISSING_ALIAS_FOR_SUBQUERY" | "MODEL_HAS_NO_PRIMARY_KEY" | "PRIMARY_KEY_NOT_FOUND" | "SQLITE_ONLY_SUPPORTS_SERIALIZABLE_ISOLATION_LEVEL" | "MUST_CALL_BUILD_CTE_AT_LEAST_ONCE" | "REGEXP_NOT_SUPPORTED_IN_SQLITE" | "MANY_TO_MANY_RELATION_MUST_HAVE_A_THROUGH_MODEL" | "INSERT_FAILED" | "MULTIPLE_PRIMARY_KEYS_NOT_ALLOWED" | "FILE_NOT_A_SQL_OR_TXT_FILE" | "CONNECTION_NOT_ESTABLISHED" | "TRANSACTION_NOT_ACTIVE" | "DEVELOPMENT_ERROR" | "MIGRATION_MODULE_NOT_FOUND" | "DRIVER_NOT_FOUND" | "FILE_NOT_FOUND_OR_NOT_ACCESSIBLE" | "ENV_NOT_SET" | "REQUIRED_VALUE_NOT_SET" | "SET_FAILED" | "GET_FAILED" | "REFERENCES_OPTION_REQUIRED" | "DELETE_FAILED" | "INVALID_DEFAULT_VALUE" | "DISCONNECT_FAILED" | "FLUSH_FAILED" | "LEFT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "RIGHT_COLUMN_NOT_PROVIDED_FOR_JOIN" | "MODEL_HAS_NO_PRIMARY_KEY" | "GLOBAL_TRANSACTION_ALREADY_STARTED" | "GLOBAL_TRANSACTION_NOT_STARTED" | "MYSQL_REQUIRES_TABLE_NAME_FOR_INDEX_DROP" | "INVALID_DATE_OBJECT" | "INVALID_DATE_STRING" | "FAILED_TO_PARSE_DATE" | "MIGRATION_MODULE_REQUIRES_TS_NODE" | "FAILED_TO_ENCRYPT_SYMMETRICALLY" | "FAILED_TO_DECRYPT_SYMMETRICALLY" | "FAILED_TO_ENCRYPT_ASYMMETRICALLY" | "FAILED_TO_DECRYPT_ASYMMETRICALLY" | "UNSUPPORTED_RELATION_TYPE" | "LPUSH_FAILED" | "RPUSH_FAILED" | "LPOP_FAILED" | "RPOP_FAILED" | "LRANGE_FAILED" | "LLEN_FAILED" | "HSET_FAILED" | "HMSET_FAILED" | "HGET_FAILED" | "HGETALL_FAILED" | "HMGET_FAILED" | "HDEL_FAILED" | "HEXISTS_FAILED" | "HKEYS_FAILED" | "HLEN_FAILED" | "SADD_FAILED" | "SMEMBERS_FAILED" | "SREM_FAILED" | "SISMEMBER_FAILED" | "SCARD_FAILED" | "SINTER_FAILED" | "SUNION_FAILED" | "SDIFF_FAILED" | "ZADD_FAILED" | "ZRANGE_FAILED" | "ZREVRANGE_FAILED" | "ZREM_FAILED" | "ZSCORE_FAILED" | "ZCARD_FAILED" | "SUBSCRIBE_FAILED" | "UNSUBSCRIBE_FAILED" | "PUBLISH_FAILED" | "PSUBSCRIBE_FAILED" | "PUNSUBSCRIBE_FAILED" | "EXISTS_FAILED" | "EXPIRE_FAILED" | "EXPIREAT_FAILED" | "PEXPIRE_FAILED" | "TTL_FAILED" | "PTTL_FAILED" | "PERSIST_FAILED" | "KEYS_FAILED" | "RENAME_FAILED" | "TYPE_FAILED" | "SCAN_FAILED" | "ADMINJS_NOT_ENABLED" | "ADMINJS_INITIALIZATION_FAILED" | "ADMINJS_NO_MODELS_PROVIDED";
 
 declare class HysteriaError extends Error {
     code: HysteriaErrorCode;
@@ -5888,4 +5934,4 @@ declare const generateOpenApiModelWithMetadata: <T extends new () => Model>(mode
     $id?: string;
 }>;
 
-export { type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnnotatedModel, type AsymmetricEncryptionOptions, type AugmentedSqlDataSource, AutogeneratedModel, type BaseModelMethodOptions, type BaseModelRelationType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type CommonSqlMethodReturnType, type ConnectionPolicies, type DataSourceInput, type DataSourceType, type DateColumnOptions, DryModelQueryBuilder, DryQueryBuilder, type FetchHooks, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, Model, type ModelInstanceType, ModelQueryBuilder, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RawModelOptions, RawNode, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type SqlCloneOptions, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDataSourceWithoutTransaction, type SqlDriverSpecificOptions, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type TableFormat, type ThroughModel, TimestampedModel, Transaction, type TransactionExecutionOptions, type UniqueType, type UseCacheReturnType, type UseConnectionInput, UserMixin, UuidModel, belongsTo, column, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, index, HysteriaLogger as logger, manyToMany, MongoDataSource as mongo, property, RedisDataSource as redis, SqlDataSource as sql, unique, view, withPerformance };
+export { type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnnotatedModel, type AsymmetricEncryptionOptions, AutogeneratedModel, type BaseModelMethodOptions, type BaseModelRelationType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type CommonSqlMethodReturnType, type ConnectionPolicies, type DataSourceInput, type DataSourceType, type DateColumnOptions, DryModelQueryBuilder, DryQueryBuilder, type FetchHooks, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, 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 SlaveAlgorithm, 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, TimestampedModel, Transaction, type TransactionExecutionOptions, type UniqueType, type UseCacheReturnType, type UseConnectionInput, UserMixin, UuidModel, belongsTo, column, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, index, HysteriaLogger as logger, manyToMany, property, RedisDataSource as redis, unique, view, withPerformance };