hysteria-orm 10.0.0

package/lib/index.d.ts

@@ -0,0 +1,4374 @@
+import * as mongodb from 'mongodb';
+import * as sqlite3 from 'sqlite3';
+import * as pg from 'pg';
+import { PoolClient } from 'pg';
+import * as mysql2_promise from 'mysql2/promise';
+import { PoolConnection } from 'mysql2/promise';
+import { PassThrough } from 'node:stream';
+import { FormatOptionsWithLanguage } from 'sql-formatter';
+import { Redis, RedisOptions } from 'ioredis';
+
+type CaseConvention = "camel" | "snake" | "preserve" | RegExp | ((column: string) => string);
+
+/**
+ * @description The most basic class for all models for both SQL and NoSQL databases
+ * @internal Not meant to be used outside of the library
+ */
+declare abstract class Entity {
+    /**
+     * @description Defines the case convention for the model
+     * @description Useful in raw queries, better to leave it as none in Model definition so it will respect the exact column name from the model, else it will convert the column name to the case convention you choose (default is camel case)
+     * @type {CaseConvention}
+     */
+    static modelCaseConvention: CaseConvention;
+    /**
+     * @description Defines the case convention for the database, this should be the case convention you use in your database
+     * @type {CaseConvention}
+     */
+    static databaseCaseConvention: CaseConvention;
+}
+
+type Mysql2Import = typeof mysql2_promise;
+type PgImport = typeof pg;
+type Sqlite3Import = typeof sqlite3;
+type MongoClientImport = typeof mongodb;
+type ExcludeStringFromOptions<T> = T extends string ? never : T;
+type MysqlCreateConnectionOptions = Parameters<Mysql2Import["createPool"]>[0];
+type PgClientOptions = ExcludeStringFromOptions<ConstructorParameters<PgImport["Pool"]>[0]>;
+type MongoConnectionOptions = NonNullable<ConstructorParameters<MongoClientImport["MongoClient"]>[1]>;
+type DriverSpecificOptions = {
+    mysqlOptions?: MysqlCreateConnectionOptions;
+    pgOptions?: PgClientOptions;
+    mongoOptions?: MongoConnectionOptions;
+};
+
+type MongoCollectionKey<T> = T extends Collection ? T : never;
+type BaseModelMethodOptions$1 = {
+    useConnection?: MongoDataSource;
+    session?: ReturnType<MongoDataSource["startSession"]>;
+};
+/**
+ * @descriptionAllows Allows a type safe way to make a Partial of T, while keeping the keys that are not in T for unstructured data
+ */
+type ModelKeyOrAny<T> = {
+    [key in keyof T]?: T[key];
+} & {
+    [key: string]: any;
+};
+/**
+ * @description Allows a type-safe way to make a Partial of T, while keeping the keys that are not in T for unstructured data, with values restricted to 1 or -1
+ */
+type ModelKeyOrAnySort<T> = {
+    [key in keyof T]?: 1 | -1;
+} & {
+    [key: string]: 1 | -1;
+};
+
+type FetchHooks$1 = "beforeFetch" | "afterFetch";
+type BinaryOperatorType$2 = "$eq" | "$ne" | "$gt" | "$gte" | "$lt" | "$lte";
+type BaseValues$2 = string | number | boolean | Date | Array<string | number | boolean | Date>;
+type OneOptions$1 = {
+    throwErrorOnNull?: boolean;
+    ignoreHooks?: FetchHooks$1[];
+};
+type ManyOptions$1 = {
+    ignoreHooks?: FetchHooks$1[];
+};
+declare class MongoQueryBuilder<T extends Collection> {
+    protected idObject: MongoClientImport["Collection"]["prototype"]["find"]["prototype"]["filter"];
+    protected selectObject?: Record<string, 1>;
+    protected selectFields?: string[];
+    protected whereObject: MongoClientImport["Collection"]["prototype"]["find"]["prototype"]["filter"];
+    protected sortObject?: MongoClientImport["Collection"]["prototype"]["find"]["prototype"]["sort"];
+    protected limitNumber?: number;
+    protected offsetNumber?: number;
+    protected mongoDataSource: MongoDataSource;
+    protected collection: MongoClientImport["Collection"]["prototype"];
+    protected model: typeof Collection;
+    protected logs: boolean;
+    protected session?: ReturnType<MongoDataSource["startSession"]>;
+    constructor(model: typeof Collection, mongoDataSource: MongoDataSource, _session?: ReturnType<MongoDataSource["startSession"]>, logs?: boolean);
+    one(options?: OneOptions$1): Promise<T | null>;
+    oneOrFail(options?: OneOptions$1): Promise<T>;
+    many(options?: ManyOptions$1): Promise<T[]>;
+    /**
+     * @description Inserts a new document into the collection
+     * @param options.returning - If true, the inserted document will be returned, else only the inserted id from mongodb will be returned
+     */
+    insert<O extends ModelKeyOrAny<T>>(modelData: O, options?: {
+        ignoreHooks?: boolean;
+        returning?: boolean;
+    }): Promise<O & {
+        id: string;
+    }>;
+    /**
+     * @description Inserts multiple documents into the collection
+     * @param modelData
+     * @param options
+     * @returns
+     */
+    insertMany<O extends ModelKeyOrAny<T>>(modelData: O[], options?: {
+        ignoreHooks?: boolean;
+        returning?: boolean;
+    }): Promise<(O & {
+        id: string;
+    })[]>;
+    /**
+     * @Massive Updates all the documents that match the query
+     * @param modelData
+     * @returns
+     */
+    update(modelData: ModelKeyOrAny<T>, options?: {
+        ignoreHooks?: boolean;
+    }): Promise<T[]>;
+    /**
+     * @Massive Deletes all the documents that match the query
+     * @returns
+     */
+    delete(options?: {
+        ignoreHooks?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Fetches the count of the query
+     * @returns - The count of the query
+     */
+    count(options?: {
+        ignoreHooks?: boolean;
+    }): Promise<number>;
+    /**
+     * @description Only fetches the provided fields
+     * @param fields - Fields to select
+     */
+    select(fields: MongoCollectionKey<T>[]): this;
+    select(fields: string[]): this;
+    /**
+     * @description Adds a where clause to the query
+     */
+    where(property: MongoCollectionKey<T>, operator: BinaryOperatorType$2, value: BaseValues$2): this;
+    where(property: string, operator: BinaryOperatorType$2, value: BaseValues$2): this;
+    where(property: MongoCollectionKey<T> | string, value: BaseValues$2): this;
+    /**
+     * @description Adds a where clause to the query - alias for where
+     */
+    andWhere(property: MongoCollectionKey<T>, operator: BinaryOperatorType$2, value: BaseValues$2): this;
+    andWhere(property: string, operator: BinaryOperatorType$2, value: BaseValues$2): this;
+    andWhere(property: MongoCollectionKey<T> | string, value: BaseValues$2): this;
+    /**
+     * @description Adds an or where clause to the query
+     */
+    orWhere(property: MongoCollectionKey<T>, operator: BinaryOperatorType$2, value: BaseValues$2): this;
+    orWhere(property: string, operator: BinaryOperatorType$2, value: BaseValues$2): this;
+    orWhere(property: MongoCollectionKey<T> | string, value: BaseValues$2): this;
+    /**
+     * @description Adds a where exists clause to the query
+     */
+    whereExists(property: MongoCollectionKey<T>): this;
+    whereExists(property: string): this;
+    /**
+     * @description Adds an and where exists clause to the query
+     */
+    andWhereExists(property: MongoCollectionKey<T>): this;
+    andWhereExists(property: string): this;
+    /**
+     * @description Adds an or where exists clause to the query
+     */
+    orWhereExists(property: MongoCollectionKey<T>): this;
+    orWhereExists(property: string): this;
+    /**
+     * @description Adds a where not exists clause to the query
+     */
+    whereNotExists(property: MongoCollectionKey<T>): this;
+    whereNotExists(property: string): this;
+    /**
+     * @description Adds an and where not exists clause to the query
+     */
+    andWhereNotExists(property: MongoCollectionKey<T>): this;
+    andWhereNotExists(property: string): this;
+    /**
+     * @description Adds an or where not exists clause to the query
+     */
+    orWhereNotExists(property: MongoCollectionKey<T>): this;
+    orWhereNotExists(property: string): this;
+    /**
+     * @description Adds a where not clause to the query
+     */
+    whereNot(property: MongoCollectionKey<T>, value: BaseValues$2): this;
+    whereNot(property: string, value: BaseValues$2): this;
+    /**
+     * @description Adds an and where not clause to the query
+     */
+    andWhereNot(property: MongoCollectionKey<T>, value: BaseValues$2): this;
+    andWhereNot(property: string, value: BaseValues$2): this;
+    /**
+     * @description Adds an or where not clause to the query
+     */
+    orWhereNot(property: MongoCollectionKey<T>, value: BaseValues$2): this;
+    orWhereNot(property: string, value: BaseValues$2): this;
+    /**
+     * @description Adds a where like clause to the query
+     */
+    whereLike(property: MongoCollectionKey<T>, value: string): this;
+    whereLike(property: string, value: string): this;
+    /**
+     * @description Adds an and where like clause to the query
+     */
+    andWhereLike(property: MongoCollectionKey<T>, value: string): this;
+    andWhereLike(property: string, value: string): this;
+    /**
+     * @description Adds an or where like clause to the query
+     */
+    orWhereLike(property: MongoCollectionKey<T>, value: string): this;
+    orWhereLike(property: string, value: string): this;
+    /**
+     * @description Adds a where not like clause to the query
+     */
+    whereNotLike(property: MongoCollectionKey<T>, value: string): this;
+    whereNotLike(property: string, value: string): this;
+    /**
+     * @description Adds an and where not like clause to the query
+     */
+    andWhereNotLike(property: MongoCollectionKey<T>, value: string): this;
+    andWhereNotLike(property: string, value: string): this;
+    /**
+     * @description Adds an or where not like clause to the query
+     */
+    orWhereNotLike(property: MongoCollectionKey<T>, value: string): this;
+    orWhereNotLike(property: string, value: string): this;
+    /**
+     * @description Adds a where in clause to the query
+     */
+    whereIn(property: MongoCollectionKey<T>, values: BaseValues$2[]): this;
+    whereIn(property: string, values: BaseValues$2[]): this;
+    /**
+     * @description Adds an and where in clause to the query
+     */
+    andWhereIn(property: MongoCollectionKey<T>, values: BaseValues$2[]): this;
+    andWhereIn(property: string, values: BaseValues$2[]): this;
+    /**
+     * @description Adds an or where in clause to the query
+     */
+    orWhereIn(property: MongoCollectionKey<T>, values: BaseValues$2[]): this;
+    orWhereIn(property: string, values: BaseValues$2[]): this;
+    /**
+     * @description Adds a where not in clause to the query
+     */
+    whereNotIn(property: MongoCollectionKey<T>, values: BaseValues$2[]): this;
+    whereNotIn(property: string, values: BaseValues$2[]): this;
+    /**
+     * @description Adds an and where not in clause to the query
+     */
+    andWhereNotIn(property: MongoCollectionKey<T>, values: BaseValues$2[]): this;
+    andWhereNotIn(property: string, values: BaseValues$2[]): this;
+    /**
+     * @description Adds an or where not in clause to the query
+     */
+    orWhereNotIn(property: MongoCollectionKey<T>, values: BaseValues$2[]): this;
+    orWhereNotIn(property: string, values: BaseValues$2[]): this;
+    /**
+     * @description Adds a where null clause to the query
+     */
+    whereNull(property: MongoCollectionKey<T>): this;
+    whereNull(property: string): this;
+    /**
+     * @description Adds an and where null clause to the query
+     */
+    andWhereNull(property: MongoCollectionKey<T>): this;
+    andWhereNull(property: string): this;
+    /**
+     * @description Adds an or where null clause to the query
+     */
+    orWhereNull(property: MongoCollectionKey<T>): this;
+    orWhereNull(property: string): this;
+    /**
+     * @description Adds a where not null clause to the query
+     */
+    whereNotNull(property: MongoCollectionKey<T>): this;
+    whereNotNull(property: string): this;
+    /**
+     * @description Adds an and where not null clause to the query
+     */
+    andWhereNotNull(property: MongoCollectionKey<T>): this;
+    andWhereNotNull(property: string): this;
+    /**
+     * @description Adds an or where not null clause to the query
+     */
+    orWhereNotNull(property: MongoCollectionKey<T>): this;
+    orWhereNotNull(property: string): this;
+    /**
+     * @description Adds a where between clause to the query
+     */
+    whereBetween(property: MongoCollectionKey<T>, values: [BaseValues$2, BaseValues$2]): this;
+    whereBetween(property: string, values: [BaseValues$2, BaseValues$2]): this;
+    /**
+     * @description Adds an and where between clause to the query
+     */
+    andWhereBetween(property: MongoCollectionKey<T>, values: [BaseValues$2, BaseValues$2]): this;
+    andWhereBetween(property: string, values: [BaseValues$2, BaseValues$2]): this;
+    /**
+     * @description Adds an or where between clause to the query
+     */
+    orWhereBetween(property: MongoCollectionKey<T>, values: [BaseValues$2, BaseValues$2]): this;
+    orWhereBetween(property: string, values: [BaseValues$2, BaseValues$2]): this;
+    /**
+     * @description Adds a where not between clause to the query
+     */
+    whereNotBetween(property: MongoCollectionKey<T>, values: [BaseValues$2, BaseValues$2]): this;
+    whereNotBetween(property: string, values: [BaseValues$2, BaseValues$2]): this;
+    /**
+     * @description Adds an and where not between clause to the query
+     */
+    andWhereNotBetween(property: MongoCollectionKey<T>, values: [BaseValues$2, BaseValues$2]): this;
+    andWhereNotBetween(property: string, values: [BaseValues$2, BaseValues$2]): this;
+    /**
+     * @description Adds an or where not between clause to the query
+     */
+    orWhereNotBetween(property: MongoCollectionKey<T>, values: [BaseValues$2, BaseValues$2]): this;
+    orWhereNotBetween(property: string, values: [BaseValues$2, BaseValues$2]): this;
+    /**
+     * @description Gives the possibility to add a raw where clause using the mongodb.Filter type
+     */
+    whereRaw(whereObject: MongoClientImport["Collection"]["prototype"]["find"]["prototype"]["filter"]): this;
+    /**
+     * @description Gives the possibility to add a raw where clause using the mongodb.Filter type
+     */
+    andRawWhere(whereObject: MongoClientImport["Collection"]["prototype"]["find"]["prototype"]["filter"]): this;
+    /**
+     * @description Gives the possibility to add a raw where clause using the mongodb.Filter type
+     */
+    orRawWhere(whereObject: MongoClientImport["Collection"]["prototype"]["find"]["prototype"]["filter"]): this;
+    /**
+     * @description Adds a sort to the query for the id
+     * @param sortBy - The sort criteria, which can be a number, string, object, or array of these types
+     * @returns
+     */
+    sortById(sortBy: 1 | -1): this;
+    /**
+     * @description Adds a sort to the query, do not use this method if you want to sort by id use the sortById method
+     * @param sortBy - The sort criteria, which can be a number, string, object, or array of these types
+     * @returns The current instance for chaining
+     */
+    sort(sortBy: 1 | -1): this;
+    sort(sortBy: MongoCollectionKey<T>): this;
+    sort(sortBy: MongoCollectionKey<T>[]): this;
+    sort(sortBy: string): this;
+    sort(sortBy: string[]): this;
+    sort(sortBy: ModelKeyOrAnySort<T>): this;
+    /**
+     * @description Adds a limit to the query
+     * @param limit - The limit to set
+     * @returns
+     */
+    limit(limit: number): this;
+    /**
+     * @description Adds an offset to the query
+     * @param offset - The offset to set
+     * @returns
+     */
+    offset(offset: number): this;
+}
+
+/**
+ * @description Creates a datasource for the selected database type with the provided credentials
+ */
+type DataSourceType = "cockroachdb" | "mysql" | "postgres" | "mariadb" | "sqlite" | "mongo";
+interface CommonDataSourceInput {
+    readonly type?: DataSourceType;
+    readonly logs?: boolean;
+}
+interface MongoDataSourceInput extends CommonDataSourceInput {
+    readonly type: "mongo";
+    readonly mongoOptions?: MongoConnectionOptions;
+    readonly url?: string;
+}
+interface PostgresSqlDataSourceInput extends CommonDataSourceInput {
+    readonly type?: "postgres" | "cockroachdb";
+    readonly host?: string;
+    readonly port?: number;
+    readonly username?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly driverOptions?: PgClientOptions;
+}
+interface NotNullablePostgresSqlDataSourceInput extends PostgresSqlDataSourceInput {
+    readonly type?: "postgres" | "cockroachdb";
+    readonly host: string;
+    readonly username: string;
+    readonly password: string;
+    readonly database: string;
+    readonly port?: number;
+    readonly driverOptions?: PgClientOptions;
+}
+interface MysqlSqlDataSourceInput extends CommonDataSourceInput {
+    readonly type?: "mysql" | "mariadb";
+    readonly host?: string;
+    readonly port?: number;
+    readonly username?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly driverOptions?: MysqlCreateConnectionOptions;
+}
+interface NotNullableMysqlSqlDataSourceInput extends MysqlSqlDataSourceInput {
+    readonly type?: "mysql" | "mariadb";
+    readonly host: string;
+    readonly username: string;
+    readonly password: string;
+    readonly database: string;
+    readonly port?: number;
+    readonly driverOptions?: MysqlCreateConnectionOptions;
+}
+interface SqliteDataSourceInput extends CommonDataSourceInput {
+    readonly type?: "sqlite";
+    readonly database?: string;
+}
+interface NotNullableSqliteDataSourceInput extends SqliteDataSourceInput {
+    readonly type?: "sqlite";
+    readonly database: string;
+}
+/**
+ * @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 = MysqlSqlDataSourceInput | SqliteDataSourceInput | PostgresSqlDataSourceInput | MongoDataSourceInput;
+
+declare abstract class DataSource {
+    type: DataSourceType;
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    database: string;
+    url: string;
+    logs: boolean;
+    protected constructor(input?: DataSourceInput);
+    protected handleCockroachdbSource(input?: PostgresSqlDataSourceInput): void;
+    protected handlePostgresSource(input?: PostgresSqlDataSourceInput): void;
+    protected handleMysqlSource(input?: MysqlSqlDataSourceInput): void;
+    protected handleSqliteSource(input?: SqliteDataSourceInput): void;
+    protected handleMongoSource(input?: MongoDataSourceInput): void;
+}
+
+type MongoFindOneOptions<T extends Collection> = {
+    ignoreHooks?: FetchHooks$1[];
+    select?: MongoCollectionKey<T>[];
+    where?: ModelKeyOrAny<T>;
+};
+type UnrestrictedMongoFindOneOptions<T extends Collection> = {
+    ignoreHooks?: FetchHooks$1[];
+    select?: string[];
+    where?: ModelKeyOrAny<T>;
+};
+type MongoFindManyOptions<T extends Collection> = MongoFindOneOptions<T> & {
+    sort?: ModelKeyOrAnySort<T>;
+    limit?: number;
+    offset?: number;
+};
+type MongoUnrestrictedFindManyOptions<T extends Collection> = UnrestrictedMongoFindOneOptions<T> & {
+    sort?: Record<string, 1 | -1>;
+    limit?: number;
+    offset?: number;
+};
+declare class CollectionManager<T extends Collection> {
+    protected logs: boolean;
+    protected collection: typeof Collection;
+    protected mongoClient: ReturnType<MongoDataSource["getCurrentConnection"]>;
+    protected mongoDataSource: MongoDataSource;
+    protected collectionInstance: MongoClientImport["Collection"]["prototype"];
+    protected session?: ReturnType<MongoDataSource["startSession"]>;
+    constructor(_collection: typeof Collection, mongoDataSource: MongoDataSource, session?: ReturnType<MongoDataSource["startSession"]>, logs?: boolean);
+    /**
+     * @description Finds all records that match the input
+     */
+    find(options?: MongoUnrestrictedFindManyOptions<T> | MongoFindManyOptions<T>): Promise<T[]>;
+    /**
+     * @description Finds the first record that matches the input
+     */
+    findOne(options: UnrestrictedMongoFindOneOptions<T> | MongoFindOneOptions<T>): Promise<T | null>;
+    /**
+     * @description Finds the first record that matches the input or throws an error
+     */
+    findOneOrFail(options: (UnrestrictedMongoFindOneOptions<T> | MongoFindOneOptions<T>) & {
+        customError?: Error;
+    }): Promise<T>;
+    /**
+     * @description Starts a query builder chain
+     */
+    query<T extends Collection>(): MongoQueryBuilder<T>;
+    /**
+     * @description Finds a record by its primary key
+     */
+    insert(modelData: ModelKeyOrAny<T>, options?: {
+        ignoreHooks?: boolean;
+    }): Promise<T>;
+    /**
+     * @description Creates multiple records
+     */
+    insertMany(modelData: ModelKeyOrAny<T>[], options?: {
+        ignoreHooks?: boolean;
+    }): Promise<T[]>;
+    /**
+     * @description Updates a record
+     */
+    updateRecord(modelData: T): Promise<T>;
+    /**
+     * @description Deletes a record
+     */
+    deleteRecord(model: T): Promise<T>;
+}
+
+type MongoClientInstance = InstanceType<MongoClientImport["MongoClient"]>;
+declare class MongoDataSource extends DataSource {
+    url: string;
+    isConnected: boolean;
+    private mongoClient;
+    private static instance;
+    private constructor();
+    /**
+     * @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
+     */
+    static connect(url?: string, options?: Partial<MongoConnectionOptions> & {
+        logs?: boolean;
+    }, cb?: (mongoDataSource: MongoDataSource) => Promise<void> | void): Promise<MongoDataSource>;
+    static getInstance(): MongoDataSource;
+    /**
+     * @description Starts a new session and transaction using the current connection
+     */
+    startSession(): InstanceType<MongoClientImport["ClientSession"]>;
+    /**
+     * @description Disconnects from the mongo database using the current connection established by the `connect` method
+     */
+    static disconnect(): Promise<void>;
+    /**
+     * @description Disconnects from the mongo database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @description Closes the current connection to the mongo database
+     * @alias disconnect
+     */
+    closeConnection(): Promise<void>;
+    /**
+     * @description Executes a callback function with the provided connection details
+     * @alias disconnect
+     */
+    static closeConnection(): Promise<void>;
+    /**
+     * @description Executes a callback function with the provided connection details
+     */
+    static useConnection(this: typeof MongoDataSource, connectionDetails: {
+        url: string;
+        options?: MongoConnectionOptions;
+    }, 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>;
+}
+
+declare class Collection extends Entity {
+    $annotations: Record<string, any>;
+    /**
+     * @description The sql sqlInstance generated by SqlDataSource.connect
+     */
+    static mongoInstance: MongoDataSource;
+    /**
+     * @description Used in order to override the table collection name
+     */
+    static _collection: string;
+    /**
+     * @description Table name for the collection, default will be the plural snake case of the collection name given that is in PascalCase (es. User -> users)
+     * @description If you want to override the table name, you can set the table property in the collection
+     * @warning This is a getter you cannot override it, if you want to override it use the table property
+     */
+    static get collection(): string;
+    /**
+     * @description The id of the record, this will be used to interact with the _id field in the database, every model has an id by default
+     */
+    id: string;
+    /**
+     * @description Gets the main query builder for the model
+     * @param options - The options to get the model manager
+     * @returns {MongoQueryBuilder<T>}
+     */
+    static query<T extends Collection>(this: new () => T | typeof Collection, options?: BaseModelMethodOptions$1): MongoQueryBuilder<T>;
+    /**
+     * @description Finds records in the collection, to use for simple queries
+     * @param this
+     * @param options
+     */
+    static find<T extends Collection>(this: new () => T | typeof Collection, options?: MongoFindManyOptions<T> & BaseModelMethodOptions$1): Promise<T[]>;
+    static find<T extends Collection>(this: new () => T | typeof Collection, options?: MongoUnrestrictedFindManyOptions<T> & BaseModelMethodOptions$1): Promise<T[]>;
+    /**
+     * @description Finds a record in the collection, to use for simple queries
+     * @param this
+     * @param options
+     */
+    static findOne<T extends Collection>(this: new () => T | typeof Collection, options: MongoFindOneOptions<T> & BaseModelMethodOptions$1): Promise<T | null>;
+    static findOne<T extends Collection>(this: new () => T | typeof Collection, options: UnrestrictedMongoFindOneOptions<T> & BaseModelMethodOptions$1): Promise<T | null>;
+    /**
+     * @description Finds a record in the collection, to use for simple queries
+     * @param this
+     * @param options
+     * @throws {Error} - If the record could not be found
+     * @returns {Promise<T>}
+     */
+    static findOneOrFail<T extends Collection>(this: new () => T | typeof Collection, options: MongoFindOneOptions<T> & BaseModelMethodOptions$1): Promise<T>;
+    static findOneOrFail<T extends Collection>(this: new () => T | typeof Collection, options: UnrestrictedMongoFindOneOptions<T> & BaseModelMethodOptions$1): Promise<T>;
+    /**
+     * @description Saves a new record to the collection
+     * @param model
+     * @param {Model} modelData - The data to be saved
+     * @param {BaseModelMethodOptions} options - The options to get the model manager
+     * @returns {Promise<T>}
+     */
+    static insert<T extends Collection>(this: new () => T | typeof Collection, modelData: ModelKeyOrAny<T>, options?: BaseModelMethodOptions$1): Promise<T>;
+    /**
+     * @description Saves multiple records to the collection
+     * @param {Model} modelData - The data to be fetched
+     * @param {BaseModelMethodOptions} options - The options to get the model manager
+     * @returns {Promise<T>}
+     */
+    static insertMany<T extends Collection>(this: new () => T | typeof Collection, modelData: ModelKeyOrAny<T>[], options?: BaseModelMethodOptions$1): Promise<T[]>;
+    /**
+     * @description Updates a record in the collection using it's id
+     * @param {Model} modelData - The data to be updated
+     * @param {BaseModelMethodOptions} options - The options to get the model manager
+     * @returns {Promise<T>} - The updated record refreshed from the database
+     */
+    static updateRecord<T extends Collection>(this: new () => T | typeof Collection, model: T, options?: BaseModelMethodOptions$1): Promise<T>;
+    /**
+     * @description Deletes a record in the collection using it's id
+     * @param {BaseModelMethodOptions} options - The options to get the model manager
+     * @returns {Promise<void>}
+     * @throws {Error} - If the record could not be deleted
+     */
+    static deleteRecord<T extends Collection>(this: new () => T | typeof Collection, model: T, options?: BaseModelMethodOptions$1): Promise<void>;
+    /**
+     * @description Gets the main connection from the mongoInstance
+     */
+    private static establishConnection;
+    /**
+     * @description Gives the correct model manager with the correct connection based on the options provided
+     * @param this
+     * @param options - The options to get the model manager
+     * @returns
+     */
+    private static dispatchModelManager;
+    /**
+     * @description Adds a beforeFetch clause to the model, adding the ability to modify the query before fetching the data
+     * @param queryBuilder
+     */
+    static beforeFetch(queryBuilder: MongoQueryBuilder<any>): void;
+    /**
+     * @description Adds a beforeInsert clause to the model, adding the ability to modify the data after fetching the data
+     * @param data
+     * @returns {T}
+     */
+    static beforeInsert(data: any): void;
+    /**
+     * @description Adds a beforeUpdate clause to the model, adding the ability to modify the query before updating the data
+     * @param data
+     */
+    static beforeUpdate(queryBuilder: MongoQueryBuilder<any>): void;
+    /**
+     * @description Adds a beforeDelete clause to the model, adding the ability to modify the query before deleting the data
+     * @param data
+     */
+    static beforeDelete(queryBuilder: MongoQueryBuilder<any>): void;
+    /**
+     * @description Adds a property to the model, adding the ability to modify the data after fetching the data
+     * @javascript
+     */
+    static property(propertyName: string): void;
+    /**
+     * @description Adds a afterFetch clause to the model, adding the ability to modify the data after fetching the data
+     * @param data
+     * @returns {T}
+     */
+    static afterFetch(data: any[]): Promise<Collection[]>;
+}
+
+/**
+ * @description Defines a property that will be used in the model
+ */
+declare function property(): PropertyDecorator;
+/**
+ * @description Returns the properties of the model, properties must be decorated with the property decorator
+ */
+declare function getCollectionProperties(target: typeof Collection): string[];
+
+type CommonConstraintOptions = {
+    constraintName?: string;
+};
+type OnUpdateOrDelete = "cascade" | "restrict" | "set null" | "no action";
+type PrimaryKeyOptions = CommonConstraintOptions;
+type ForeignKeyOptions = CommonConstraintOptions & {
+    onDelete?: OnUpdateOrDelete;
+    onUpdate?: OnUpdateOrDelete;
+};
+type CreateTableContext = "alter_table" | "create_table";
+
+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 QueryNode {
+    /**
+     * Sql keyword to use for the query e.g. "select"
+     */
+    keyword: string;
+    /**
+     * The current parameter index to use for the query
+     */
+    currParamIndex: number;
+    /**
+     * Whether the query node is a raw value and should not be parsed by the interpreter
+     */
+    isRawValue: boolean;
+    /**
+     * Whether the keyword can be seen multiple times in the query, e.g. "join" can be seen multiple times in a query
+     */
+    abstract canKeywordBeSeenMultipleTimes: boolean;
+    /**
+     * The string to use to chain the keyword with the next keyword
+     */
+    abstract chainsWith: string;
+    /**
+     * The folder to use for the query node, e.g. "select" is in the "select" folder inside the interpreter map
+     */
+    abstract folder: string;
+    /**
+     * The file to use for the query node, e.g. "select" is in the "select" file inside the interpreter map
+     */
+    abstract file: string;
+    constructor(keyword: string, isRawValue?: boolean);
+}
+
+declare class RawNode extends QueryNode {
+    rawValue: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    chainsWith: string;
+    currParamIndex: number;
+    isRawValue: boolean;
+    folder: string;
+    file: string;
+    constructor(value: string);
+}
+
+type ConstraintType = "primary_key" | "foreign_key" | "unique" | "not_null" | "null" | "default";
+declare class ConstraintNode extends QueryNode {
+    constraintType: ConstraintType;
+    columns?: (string | (() => string))[];
+    references?: {
+        table: string;
+        columns: (string | (() => string))[];
+    };
+    constraintName?: string;
+    onDelete?: "cascade" | "restrict" | "set null" | "no action";
+    onUpdate?: "cascade" | "restrict" | "set null" | "no action";
+    defaultValue?: string;
+    checkExpression?: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(constraintType: ConstraintType, args?: {
+        columns?: string[];
+        references?: {
+            table: string;
+            columns: string[];
+        };
+        constraintName?: string;
+        onDelete?: "cascade" | "restrict" | "set null" | "no action";
+        onUpdate?: "cascade" | "restrict" | "set null" | "no action";
+        defaultValue?: string;
+        checkExpression?: string;
+    }, 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;
+    skipLocked: boolean;
+    noWait: boolean;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(lockType: LockType, skipLocked?: boolean, noWait?: boolean);
+}
+
+declare class UnionNode extends QueryNode {
+    query: QueryNode | QueryNode[] | string;
+    isAll: boolean;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(query: QueryNode | QueryNode[] | string, isAll?: boolean);
+}
+
+declare class WithNode extends QueryNode {
+    alias: string;
+    body: QueryNode | QueryNode[];
+    clause: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(clause: string, alias: string, body: QueryNode | QueryNode[]);
+}
+
+declare abstract class BaseBuilder {
+    protected nodes: QueryNode[];
+    constructor(nodes: QueryNode[]);
+    getNodes(): QueryNode[];
+}
+
+declare class ConstraintBuilder extends BaseBuilder {
+    private readonly columnNode;
+    private readonly tableName?;
+    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
+     */
+    default(value: string | number | boolean | null): this;
+    /**
+     * @description Sets the column to unique
+     * @param options is the options for the unique constraint
+     */
+    unique(options?: CommonConstraintOptions): this;
+    /**
+     * @description Sets the column to be after another column
+     * @param columnName is the name of the column to be after
+     * @mysql only
+     */
+    after(columnName: string): this;
+    private handleSqliteAutoIncrement;
+}
+
+declare class CreateTableBuilder extends BaseBuilder {
+    private tableName?;
+    private namedConstraints;
+    private context;
+    private sqlType;
+    constructor(sqlType: SqlDataSourceType, nodes: QueryNode[], tableName?: string, context?: "alter_table" | "create_table");
+    private build;
+    /**
+     * Fixed-length character string
+     * @mysql Supported as CHAR(length)
+     * @postgres Supported as CHAR(length)
+     * @sqlite Supported as TEXT (length ignored)
+     */
+    char(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Variable-length character string
+     * @mysql Supported as VARCHAR(length)
+     * @postgres Supported as VARCHAR(length)
+     * @sqlite Supported as TEXT (length ignored)
+     */
+    varchar(name: string, length?: number): ConstraintBuilder;
+    /**
+     * @alias varchar
+     */
+    string(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Text types with various sizes
+     * @mysql Supported as TEXT, MEDIUMTEXT, LONGTEXT, TINYTEXT
+     * @postgres All mapped to TEXT
+     * @sqlite All mapped to TEXT
+     */
+    text(name: string, type?: "longtext" | "mediumtext" | "tinytext"): ConstraintBuilder;
+    /**
+     * @mysql LONGTEXT
+     * @postgres TEXT
+     * @sqlite TEXT
+     */
+    longtext(name: string): ConstraintBuilder;
+    /**
+     * @mysql MEDIUMTEXT
+     * @postgres TEXT
+     * @sqlite TEXT
+     */
+    mediumtext(name: string): ConstraintBuilder;
+    /**
+     * @mysql TINYTEXT
+     * @postgres TEXT
+     * @sqlite TEXT
+     */
+    tinytext(name: string): ConstraintBuilder;
+    /**
+     * UUID identifier
+     * @mysql VARCHAR(36)
+     * @postgres UUID (native type)
+     * @sqlite VARCHAR(36)
+     */
+    uuid(name: string): ConstraintBuilder;
+    /**
+     * ULID (Universally Unique Lexicographically Sortable Identifier)
+     * @mysql VARCHAR(26)
+     * @postgres VARCHAR(26)
+     * @sqlite VARCHAR(26)
+     */
+    ulid(name: string): ConstraintBuilder;
+    /**
+     * Integer type
+     * @mysql INT (with optional auto_increment)
+     * @postgres INTEGER (with optional SERIAL for auto_increment)
+     * @sqlite INTEGER (with optional autoincrement)
+     */
+    integer(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Small integer type
+     * @mysql TINYINT
+     * @postgres SMALLINT
+     * @sqlite INTEGER
+     */
+    tinyint(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Small integer type
+     * @mysql SMALLINT
+     * @postgres SMALLINT
+     * @sqlite INTEGER
+     */
+    smallint(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Medium integer type
+     * @mysql MEDIUMINT
+     * @postgres INTEGER
+     * @sqlite INTEGER
+     */
+    mediumint(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Large integer type
+     * @mysql BIGINT (with optional auto_increment)
+     * @postgres BIGINT (with optional BIGSERIAL for auto_increment)
+     * @sqlite INTEGER
+     */
+    biginteger(name: string, length?: number): ConstraintBuilder;
+    /**
+     * @alias biginteger
+     */
+    bigint(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Single precision floating point
+     * @mysql FLOAT
+     * @postgres REAL
+     * @sqlite REAL
+     */
+    float(name: string, precision?: number): ConstraintBuilder;
+    /**
+     * Double precision floating point
+     * @mysql DOUBLE
+     * @postgres DOUBLE PRECISION
+     * @sqlite REAL
+     */
+    double(name: string, precision?: number): ConstraintBuilder;
+    /**
+     * Real number type
+     * @mysql DOUBLE (alias)
+     * @postgres REAL
+     * @sqlite REAL
+     */
+    real(name: string, precision?: number): ConstraintBuilder;
+    /**
+     * Exact decimal number
+     * @mysql DECIMAL(precision, scale)
+     * @postgres NUMERIC(precision, scale)
+     * @sqlite NUMERIC(precision, scale)
+     */
+    decimal(name: string, precision?: number, scale?: number): ConstraintBuilder;
+    /**
+     * Exact numeric type (alias for decimal)
+     * @mysql NUMERIC(precision, scale)
+     * @postgres NUMERIC(precision, scale)
+     * @sqlite NUMERIC(precision, scale)
+     */
+    numeric(name: string, precision?: number, scale?: number): ConstraintBuilder;
+    /**
+     * @description Short for integer.increment
+     * @mysql INTEGER (with auto_increment)
+     * @postgres INTEGER (with SERIAL for auto_increment)
+     * @sqlite INTEGER (with autoincrement)
+     */
+    increment(name: string, length?: number): Omit<ConstraintBuilder, "increment">;
+    /**
+     * @description Short for biginteger.increment
+     * @mysql BIGINT (with auto_increment)
+     * @postgres BIGINT (with BIGSERIAL for auto_increment)
+     * @sqlite INTEGER
+     */
+    bigIncrement(name: string, length?: number): Omit<ConstraintBuilder, "increment">;
+    /**
+     * Date type
+     * @mysql DATE
+     * @postgres DATE
+     * @sqlite TEXT
+     */
+    date(name: string, precision?: number): ConstraintBuilder;
+    /**
+     * Time type
+     * @mysql TIME(precision)
+     * @postgres TIME(precision)
+     * @sqlite TEXT
+     */
+    time(name: string, precision?: number): ConstraintBuilder;
+    /**
+     * Year type
+     * @mysql YEAR
+     * @postgres SMALLINT
+     * @sqlite TEXT
+     */
+    year(name: string): ConstraintBuilder;
+    /**
+     * Date and time type
+     * @mysql DATETIME(precision)
+     * @postgres TIMESTAMP(precision) WITHOUT TIME ZONE
+     * @sqlite TEXT
+     */
+    datetime(name: string, options?: {
+        withTimezone?: boolean;
+        precision?: number;
+    }): ConstraintBuilder;
+    /**
+     * Timestamp type
+     * @mysql TIMESTAMP(precision)
+     * @postgres TIMESTAMP(precision) WITH/WITHOUT TIME ZONE
+     * @sqlite TEXT
+     */
+    timestamp(name: string, options?: {
+        withTimezone?: boolean;
+        precision?: number;
+    }): ConstraintBuilder;
+    /**
+     * Boolean type
+     * @mysql BOOLEAN
+     * @postgres BOOLEAN
+     * @sqlite INTEGER
+     */
+    boolean(name: string): ConstraintBuilder;
+    /**
+     * Fixed-length binary data
+     * @mysql BINARY(length)
+     * @postgres BYTEA
+     * @sqlite BLOB
+     */
+    binary(name: string): ConstraintBuilder;
+    /**
+     * Variable-length binary data
+     * @mysql VARBINARY(length)
+     * @postgres BYTEA
+     * @sqlite BLOB
+     */
+    varbinary(name: string, length?: number): ConstraintBuilder;
+    /**
+     * Binary large object
+     * @mysql BLOB
+     * @postgres BYTEA
+     * @sqlite BLOB
+     */
+    blob(name: string): ConstraintBuilder;
+    /**
+     * Small binary large object
+     * @mysql TINYBLOB
+     * @postgres BYTEA
+     * @sqlite BLOB
+     */
+    tinyblob(name: string): ConstraintBuilder;
+    /**
+     * Medium binary large object
+     * @mysql MEDIUMBLOB
+     * @postgres BYTEA
+     * @sqlite BLOB
+     */
+    mediumblob(name: string): ConstraintBuilder;
+    /**
+     * Large binary large object
+     * @mysql LONGBLOB
+     * @postgres BYTEA
+     * @sqlite BLOB
+     */
+    longblob(name: string): ConstraintBuilder;
+    /**
+     * JSON data type
+     * @mysql JSON (MySQL 5.7+)
+     * @postgres JSON
+     * @sqlite TEXT (not supported, stored as text)
+     */
+    json(name: string): ConstraintBuilder;
+    /**
+     * Binary JSON data type
+     * @mysql Not supported (falls back to JSON)
+     * @postgres JSONB
+     * @sqlite TEXT (not supported, stored as text)
+     */
+    jsonb(name: string): ConstraintBuilder;
+    /**
+     * Enumeration type
+     * @mysql ENUM(values)
+     * @postgres TEXT with CHECK constraint
+     * @sqlite TEXT
+     */
+    enum(name: string, values: readonly string[]): ConstraintBuilder;
+    /**
+     * Custom column type
+     * @mysql Custom type as specified
+     * @postgres Custom type as specified
+     * @sqlite Custom type as specified
+     */
+    custom(name: string, type: string, length?: number): ConstraintBuilder;
+    /**
+     * Raw column type
+     * @mysql Custom type as specified
+     * @postgres Custom type as specified
+     * @sqlite Custom type as specified
+     * @example
+     * ```ts
+     * qb.rawColumn("name varchar(255)");
+     * ```
+     */
+    rawColumn(raw: string): ConstraintBuilder;
+    getNamedConstraints(): QueryNode[];
+}
+
+declare class AlterTableBuilder extends BaseBuilder {
+    private table;
+    private sqlType;
+    constructor(table: string, nodes: QueryNode[], sqlType: SqlDataSourceType);
+    /**
+     * @description Adds a column to the table
+     * @param cb is the callback that will be used to build the column
+     */
+    addColumn(cb: (col: CreateTableBuilder) => ConstraintBuilder): void;
+    /**
+     * @description Alters a column, can generate multiple sql statements depending on the constraints
+     * @throws HysteriaError if sqlite database
+     */
+    alterColumn(columnBuilder: (col: CreateTableBuilder) => ConstraintBuilder): void;
+    /**
+     * @description Drops a column
+     */
+    dropColumn(name: string): void;
+    /**
+     * @description Renames a column
+     */
+    renameColumn(oldName: string, newName: string): void;
+    /**
+     * @description Drops a default value from a column
+     * @sqlite not supported and will throw error
+     */
+    dropDefault(columnName: string): void;
+    /**
+     * @description Adds a primary key to a column
+     * @sqlite not supported and will throw error
+     * @private Used internally by alterColumn
+     */
+    private addPrimaryKey;
+    /**
+     * @description Raw non type safe way builder to add a constraint
+     * @sqlite not supported and will throw error
+     */
+    addConstraint(...options: ConstructorParameters<typeof ConstraintNode>): void;
+    /**
+     * @description Adds a foreign key constraint to a column
+     * @sqlite not supported and will throw error
+     * @private Used internally by alterColumn
+     */
+    private addForeignKey;
+    /**
+     * @description Adds a unique constraint to a column
+     * @description By default generates a constraint name using standard pattern: uq_${table}_${column}
+     * @sqlite not supported and will throw error
+     * @private Used internally by alterColumn
+     */
+    private unique;
+    /**
+     * @description Sets a default value for a column
+     * @sqlite not supported and will throw error
+     * @private Used internally by alterColumn
+     */
+    private setDefault;
+    /**
+     * @description Drops a foreign key by column name and referenced column, generates constraint name using standard pattern: fk_${table}_${leftColumn}_${rightColumn}
+     * @description If a custom constraint name was used to generate the foreign key, use `dropConstraint` instead
+     * @param leftColumn is the current model column name (e.g. userId)
+     * @param rightColumn is the referenced model column name (e.g. id)
+     * @sqlite not supported and will throw error
+     */
+    dropForeignKey(leftColumn: string, rightColumn: string): void;
+    /**
+     * @description Drops a unique constraint by column name, generates constraint name using standard pattern: uq_${table}_${column}
+     * @description If a custom constraint name was used to generate the unique constraint, use `dropConstraint` instead
+     * @param columnName is the current model column name (e.g. userId)
+     * @sqlite not supported and will throw error
+     * @cockroachdb not supported
+     */
+    dropUnique(columnName: string, options?: CommonConstraintOptions): void;
+    /**
+     * @description Drops a constraint by constraint name
+     * @sqlite not supported and will throw error
+     */
+    dropConstraint(constraintName: string): void;
+    /**
+     * @description Drops the primary key constraint
+     * @postgres not supported, use `dropConstraint` instead with the pk constraint name
+     * @sqlite not supported and will throw error
+     * @throws HysteriaError if postgres and table is not provided
+     */
+    dropPrimaryKey(table?: string): void;
+}
+
+declare class Schema {
+    queryStatements: string[];
+    sqlType: SqlDataSourceType;
+    constructor(sqlType?: SqlDataSourceType);
+    /**
+     * @description Add raw query to the migration
+     */
+    rawQuery(query: string): void;
+    /**
+     * @description Runs the sql in the given file, throws error if file does not exist or is not .sql or .txt
+     * @description File is splitted by semicolons and each statement is executed separately and in order
+     */
+    runFile(filePath: string): void;
+    /**
+     * @description Create table constructor
+     */
+    createTable(table: string, cb: (table: CreateTableBuilder) => void, options?: {
+        ifNotExists?: boolean;
+    }): void;
+    /**
+     * @description Alter table constructor
+     */
+    alterTable(table: string, cb: (t: AlterTableBuilder) => void): void;
+    /**
+     * @description Drop table in the database
+     */
+    dropTable(table: string, ifExists?: boolean): void;
+    /**
+     * @description Rename table in the database
+     */
+    renameTable(oldTable: string, newTable: string): void;
+    /**
+     * @description Truncate table
+     */
+    truncateTable(table: string): void;
+    /**
+     * @description Create index on table
+     */
+    createIndex(table: string, columns: string[] | string, options: CommonConstraintOptions): void;
+    /**
+     * @description Drop index on table
+     * @mysql requires table name for index drop
+     */
+    dropIndex(indexName: string, table?: string): void;
+    /**
+     * @description Adds a primary key to a table
+     */
+    addPrimaryKey(table: string, columns: string[]): void;
+    /**
+     * @description Adds a UNIQUE constraint to a table
+     */
+    addUnique(table: string, columns: string[] | string, options?: CommonConstraintOptions): void;
+    /**
+     * @description Drops a foreign key from a table, uses a standard constraint name pattern: fk_${table}_${leftColumn}_${rightColumn}
+     * @description If a custom constraint name was used to generate the foreign key, use `dropConstraint` instead
+     */
+    dropForeignKey(table: string, leftColumn: string, rightColumn: string): void;
+    /**
+     * @description Drops a UNIQUE constraint from a table
+     * @description If no constraintName is provided, it computes the default name using columns
+     */
+    dropUnique(table: string, columnsOrConstraintName: string | string[], options?: CommonConstraintOptions): void;
+    /**
+     * @description Drops a primary key from a table
+     */
+    dropPrimaryKey(table: string): void;
+    /**
+     * @description Adds a foreign key to a table
+     */
+    addConstraint(table: string, ...options: ConstructorParameters<typeof ConstraintNode>): void;
+    /**
+     * @description Drops a constraint from a table
+     */
+    dropConstraint(table: string, constraintName: string): void;
+    private generateAstInstance;
+}
+
+declare class InterpreterUtils {
+    private readonly model;
+    private readonly modelColumnsMap;
+    constructor(model: typeof Model);
+    formatStringColumn(dbType: SqlDataSourceType, column: string): string;
+    formatStringTable(dbType: SqlDataSourceType, table: string): string;
+    prepareColumns(columns: string[], values: any[], mode?: "insert" | "update"): {
+        columns: string[];
+        values: any[];
+    };
+}
+
+type BaseValues$1 = string | number | boolean | undefined | null | RawNode;
+type BinaryOperatorType$1 = "=" | "!=" | "<>" | ">" | "<" | ">=" | "<=" | "is" | "is not" | "like" | "not like" | "is null" | "is not null" | "ilike" | "in" | "not in" | "between" | "not between" | "regexp" | "not regexp" | "not ilike";
+declare class WhereNode extends QueryNode {
+    column: string;
+    isNegated: boolean;
+    operator: BinaryOperatorType$1;
+    value: BaseValues$1 | BaseValues$1[];
+    chainsWith: "and" | "or";
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, chainsWith: "and" | "or", isNegated: boolean | undefined, operator: BinaryOperatorType$1, value: BaseValues$1 | BaseValues$1[], isRawValue?: boolean);
+}
+
+type SubqueryOperatorType = "in" | "not in" | "exists" | "not exists" | "between" | "not between" | ">" | "<" | ">=" | "<=";
+declare class WhereSubqueryNode extends QueryNode {
+    column: string;
+    operator: SubqueryOperatorType;
+    subquery: string | QueryNode | QueryNode[];
+    chainsWith: "and" | "or";
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, operator: SubqueryOperatorType, subquery: string | QueryNode | QueryNode[], chainsWith?: "and" | "or");
+}
+
+declare class WhereGroupNode extends QueryNode {
+    nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
+    chainsWith: "and" | "or";
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(nodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[], chainsWith?: "and" | "or");
+}
+
+/**
+ * @description Options for the relation
+ * @property {string} softDeleteColumn - The column name for the soft delete column, if set, the relation will only return rows that have not been soft deleted
+ * @property {string} softDeleteType - The type of the soft delete column
+ */
+declare enum RelationEnum {
+    hasOne = "hasOne",// One to One without foreign key
+    belongsTo = "belongsTo",// One to One with foreign key
+    hasMany = "hasMany",
+    manyToMany = "manyToMany"
+}
+/**
+ * Main Relation Class
+ */
+declare abstract class Relation {
+    abstract type: RelationEnum;
+    model: typeof Model;
+    columnName: string;
+    foreignKey?: string;
+    relatedModel: string;
+    protected constructor(model: typeof Model, columnName: string);
+}
+
+declare class SqlModelManagerUtils<T extends Model> {
+    protected dbType: SqlDataSourceType;
+    protected sqlDataSource: SqlDataSource;
+    protected modelRelations: Relation[];
+    protected modelRelationsMap: Map<string, Relation>;
+    constructor(typeofModel: typeof Model, dbType: SqlDataSourceType, sqlDataSource: SqlDataSource);
+    getRelationFromModel(relation: ModelRelation<T>): Relation;
+}
+
+type PaginationMetadata = {
+    perPage: number;
+    currentPage: number;
+    firstPage: number;
+    isEmpty: boolean;
+    total: number;
+    lastPage: number;
+    hasMorePages: boolean;
+    hasPages: boolean;
+};
+type CursorPaginationMetadata = {
+    perPage: number;
+    firstPage: number;
+    isEmpty: boolean;
+    total: number;
+};
+type PaginatedData<T extends Model, A extends object = {}, R extends object = {}> = {
+    paginationMetadata: PaginationMetadata;
+    data: AnnotatedModel<T, A, R>[];
+};
+type CursorPaginatedData<T extends Model, A extends object = {}, R extends object = {}> = {
+    paginationMetadata: CursorPaginationMetadata;
+    data: AnnotatedModel<T, A, R>[];
+};
+
+type DeleteOptions = {
+    ignoreBeforeDeleteHook?: boolean;
+};
+type SoftDeleteOptions<T> = {
+    column?: MongoCollectionKey<T>;
+    value?: string | number | boolean;
+    ignoreBeforeDeleteHook?: boolean;
+};
+
+type BaseValues = string | number | boolean | null;
+type BinaryOperatorType = "=" | "!=" | "<>" | ">" | "<" | ">=" | "<=" | "like" | "ilike" | "in";
+declare class HavingNode extends QueryNode {
+    column: string;
+    isNegated: boolean;
+    operator: BinaryOperatorType;
+    value: BaseValues | BaseValues[];
+    chainsWith: "and" | "or";
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, chainsWith: "and" | "or", isNegated: boolean | undefined, operator: BinaryOperatorType, value: BaseValues | BaseValues[], isRawValue?: boolean);
+}
+
+declare class DistinctNode extends QueryNode {
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor();
+}
+
+declare class DistinctOnNode extends QueryNode {
+    columns: string[];
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(columns: string[]);
+}
+
+declare class 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 SelectNode extends QueryNode {
+    column: string | QueryNode | QueryNode[];
+    alias?: string;
+    sqlFunction?: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string | QueryNode | QueryNode[], alias?: string, sqlFunction?: string, isRaw?: boolean);
+}
+
+declare class JoinNode extends QueryNode {
+    table: string;
+    left: string;
+    right: string;
+    on?: {
+        left?: string;
+        right?: string;
+        operator: string;
+    };
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    type: "inner" | "left" | "right" | "full" | "cross" | "natural";
+    constructor(table: string, left: string, right: string, type: "inner" | "left" | "right" | "full" | "cross" | "natural" | undefined, on: {
+        left?: string;
+        right?: string;
+        operator: string;
+    }, isRawValue?: boolean);
+}
+
+declare class GroupByNode extends QueryNode {
+    column: string;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, isRawValue?: boolean);
+}
+
+declare class LimitNode extends QueryNode {
+    limit: number;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(limit: number);
+}
+
+declare class OffsetNode extends QueryNode {
+    offset: number;
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(offset: number);
+}
+
+declare class OrderByNode extends QueryNode {
+    column: string;
+    direction: "asc" | "desc";
+    chainsWith: string;
+    canKeywordBeSeenMultipleTimes: boolean;
+    folder: string;
+    file: string;
+    constructor(column: string, direction?: "asc" | "desc", isRawValue?: boolean);
+}
+
+type DateFormat = "ISO" | "TIMESTAMP" | "DATE_ONLY" | "TIME_ONLY";
+type Timezone = "UTC" | "LOCAL";
+
+type ColumnDataType = Exclude<keyof CreateTableBuilder, "enum" | "rawColumn" | "custom"> | readonly string[];
+type ColumnDataTypeOptionWithLength = {
+    type?: "char" | "varchar" | "string" | "uuid" | "ulid" | "varbinary" | "integer" | "tinyint" | "smallint" | "mediumint" | "bigint";
+    length?: number;
+};
+type ColumnDataTypeOptionWithEnum = {
+    type?: readonly string[];
+};
+type ColumnDataTypeOptionWithPrecision = {
+    type?: "float" | "double" | "real";
+    precision?: number;
+};
+type ColumnDataTypeOptionWithScaleAndPrecision = {
+    type?: "decimal" | "numeric";
+    precision?: number;
+    scale?: number;
+};
+type ColumnDataTypeOptionWithText = {
+    type?: "text" | "longtext" | "mediumtext" | "tinytext";
+};
+type ColumnDataTypeOptionWithBinary = {
+    type?: "binary" | "blob" | "tinyblob" | "mediumblob" | "longblob";
+};
+type ColumnDataTypeOptionWithDatePrecision = {
+    type?: "date" | "time" | "datetime" | "timestamp";
+    precision?: number;
+    withTimezone?: boolean;
+};
+type ColumnDataTypeOptionSimple = {
+    type?: "year" | "boolean" | "json" | "jsonb";
+};
+type ColumnDataTypeOption = ColumnDataTypeOptionWithLength | ColumnDataTypeOptionWithPrecision | ColumnDataTypeOptionWithScaleAndPrecision | ColumnDataTypeOptionWithText | ColumnDataTypeOptionWithBinary | ColumnDataTypeOptionWithDatePrecision | ColumnDataTypeOptionWithEnum | ColumnDataTypeOptionSimple;
+type LazyRelationType = {
+    type?: RelationEnum;
+    columnName: string;
+    model: () => typeof Model;
+    foreignKey: string | (() => string);
+    constraintName: string | (() => string);
+    onDelete?: OnUpdateOrDelete;
+    onUpdate?: OnUpdateOrDelete;
+    /**
+     * @description Only for many to many relations
+     */
+    manyToManyOptions?: {
+        primaryModel: string;
+        throughModel: string | (() => string);
+        leftForeignKey: string | (() => string);
+        rightForeignKey: string | (() => string);
+        wasModelProvided: boolean;
+    };
+};
+type DateColumnOptions = {
+    /**
+     * @description The format to store dates in ('ISO' or 'TIMESTAMP')
+     * @default "ISO"
+     */
+    format?: DateFormat;
+    /**
+     * @description The timezone to use ('UTC' or 'LOCAL')
+     * @default "UTC"
+     */
+    timezone?: Timezone;
+    /**
+     * @description Whether to automatically update the timestamp on record updates, uses timezone and format from the dateColumn options
+     * @default false
+     */
+    autoUpdate?: boolean;
+    /**
+     * @description Whether to automatically set the timestamp on record creation, uses timezone and format from the dateColumn options
+     * @default false
+     */
+    autoCreate?: boolean;
+} & ColumnOptions;
+type SymmetricEncryptionOptions = {
+    /**
+     * @description The key to use for the symmetric encryption
+     */
+    key: string;
+} & ColumnOptions;
+type AsymmetricEncryptionOptions = {
+    /**
+     * @description The public key to use for the asymmetric encryption
+     */
+    publicKey: string;
+    /**
+     * @description The private key to use for the asymmetric encryption
+     */
+    privateKey: string;
+} & ColumnOptions;
+/**
+ * columns
+ * @description Options for the column decorator
+ */
+type ColumnOptions = {
+    /**
+     * @description Whether the column is the primary key, composite primary keys are not supported
+     * @warning Only one primary key is allowed per model
+     * @throws {HysteriaError} if more than one primary key is defined
+     * @default false
+     */
+    primaryKey?: boolean;
+    /**
+     * @description The name of the primary key constraint in the database for automatic migrations
+     */
+    primaryKeyConstraintName?: string;
+    /**
+     * @description Called on the value returned from the database before it is returned from the model
+     */
+    serialize?: (value: any) => any;
+    /**
+     * @description Called on the value before it is inserted or updated in the database
+     * @warning This will not be called on massive update operations since it's not possible to know which values are being updated, so you must pass the value you want to update in the payload
+     */
+    prepare?: (value: any) => any;
+    /**
+     * @description Whether the column is returned in the serialization output, this column will always be undefined
+     * @default false
+     */
+    hidden?: boolean;
+    /**
+     * @description If true, the prepare function will always be called on update regardless of whether the value has been provided in the update payload
+     * @default false
+     */
+    autoUpdate?: boolean;
+    /**
+     * @description The name of the column in the database, can be used to specify the column name in the database
+     * @default The name of the property following the model case convention
+     */
+    databaseName?: string;
+    /**
+     * @description Custom OpenAPI schema for the column, if omitted, the column type will be inferred from the other options in best effort
+     */
+    openApi?: OpenApiModelPropertyType & {
+        required?: boolean;
+    };
+    /**
+     * @description Whether the column can be null in the database
+     * @migration Only affects auto-generated migrations
+     */
+    nullable?: boolean;
+    /**
+     * @description The default value for the column in the database
+     * @migration Only affects auto-generated migrations
+     */
+    default?: string | number | null | boolean;
+} & 
+/**
+ * @description The data type of the column
+ * @migration Only affects auto-generated migrations
+ */
+ColumnDataTypeOption;
+type ColumnType = {
+    columnName: string;
+    databaseName: string;
+    serialize?: (value: any) => any;
+    prepare?: (value: any) => any;
+    hidden?: boolean;
+    autoUpdate?: boolean;
+    isPrimary: boolean;
+    openApi?: OpenApiModelPropertyType & {
+        required?: boolean;
+    };
+    /** Database specific data for migrations, must be provided or it'll be ignored for auto-generated migrations */
+    primaryKeyConstraintName?: string;
+    type?: ColumnDataType;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    withTimezone?: boolean;
+    constraints?: {
+        nullable?: boolean;
+        default?: string | number | null | boolean;
+    };
+};
+type ThroughModelCallback<T extends typeof Model> = () => T;
+type ThroughModelString = string;
+type ThroughModel<T extends typeof Model> = ThroughModelCallback<T> | ThroughModelString;
+type ExtractModelFromTM<TM extends ThroughModel<any>> = TM extends ThroughModelCallback<infer T> ? T : never;
+type ManyToManyOptions<T extends typeof Model, TM extends ThroughModel<T>> = {
+    /**
+     * @description The foreign key of current model on the Pivot table
+     * @example If the current model is User and the through model is UserAddress, the leftForeignKey will be "userId"
+     */
+    leftForeignKey?: TM extends ThroughModelString ? string : ModelKey<InstanceType<ExtractModelFromTM<TM>>>;
+    /**
+     * @description The foreign key of the related model on the Pivot table
+     * @example If the current model is User and the through model is UserAddress, the rightForeignKey will be "addressId"
+     */
+    rightForeignKey?: TM extends ThroughModelString ? string : ModelKey<InstanceType<ExtractModelFromTM<TM>>>;
+};
+type IndexType = {
+    columns: string[];
+    name: string;
+};
+type UniqueType = {
+    columns: string[];
+    name: string;
+};
+
+declare abstract class FooterQueryBuilder<T extends Model> {
+    protected sqlDataSource: SqlDataSource;
+    protected model: typeof Model;
+    protected groupByNodes: GroupByNode[];
+    protected orderByNodes: OrderByNode[];
+    protected limitNode: LimitNode | null;
+    protected offsetNode: OffsetNode | null;
+    protected modelColumns: ColumnType[];
+    protected modelColumnsMap: Map<string, ColumnType>;
+    protected logs: boolean;
+    protected constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Clears the group by query
+     */
+    clearGroupBy(): this;
+    /**
+     * @description Clears the order by query
+     */
+    clearOrderBy(): this;
+    /**
+     * @description Clears the limit query
+     */
+    clearLimit(): this;
+    /**
+     * @description Clears the offset query
+     */
+    clearOffset(): this;
+    /**
+     * @description Adds a group by query
+     */
+    groupBy(...columns: ModelKey<T>[]): this;
+    groupBy<S extends string>(...columns: SelectableColumn<S>[]): this;
+    /**
+     * @description Adds a raw group by query, GROUP BY clause is not necessary and will be added automatically
+     */
+    groupByRaw(query: string): this;
+    /**
+     * @description Adds an order by query
+     */
+    orderBy(column: ModelKey<T>, order: OrderByChoices): this;
+    orderBy<S extends string>(column: SelectableColumn<S>, order: OrderByChoices): this;
+    /**
+     * @description Adds a raw order by query, ORDER BY clause is not necessary and will be added automatically
+     */
+    orderByRaw(query: string): this;
+    /**
+     * @description Adds a limit query
+     */
+    limit(limit: number): this;
+    /**
+     * @description Adds an offset query
+     */
+    offset(offset: number): this;
+}
+
+declare abstract class JoinQueryBuilder<T extends Model> extends FooterQueryBuilder<T> {
+    protected joinNodes: JoinNode[];
+    protected constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Clear the join query
+     */
+    clearJoin(): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    joinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    leftJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    rightJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    fullJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    crossJoinRaw(query: string): this;
+    /**
+     * @description Join a table with the current model, join clause is not necessary and will be added automatically
+     */
+    naturalJoinRaw(query: string): this;
+    /**
+     * @alias join
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
+     * @param primaryColumn - The primary column of the current model, default is caller model primary key if using a Model, if using a Raw Query Builder you must provide the key for the primary table, must be in the format of `table.column`
+     * @param operator - The comparison operator to use in the ON clause (default: "=")
+     */
+    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    innerJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType$1): this;
+    innerJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType$1): this;
+    /**
+     * @description Join a table with the current model
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
+     * @param primaryColumn - The primary column of the current model, default is caller model primary key if using a Model, if using a Raw Query Builder you must provide the key for the primary table, must be in the format of `table.column`
+     * @param operator - The comparison operator to use in the ON clause (default: "=")
+     */
+    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    join(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType$1): this;
+    join<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType$1): this;
+    /**
+     * @description Join a table with the current model
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table, must be in the format of `table.column`
+     * @param primaryColumn - The primary column of the current model, default is caller model primary key if using a Model, if using a Raw Query Builder you must provide the key for the primary table, must be in the format of `table.column`
+     * @param operator - The comparison operator to use in the ON clause (default: "=")
+     */
+    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    leftJoin(relationTable: string, referencingColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn: ModelKey<T>, operator?: BinaryOperatorType$1): this;
+    leftJoin<R extends typeof Model>(relationModel: R, referencingColumn: ModelKey<InstanceType<R>>, primaryColumn?: ModelKey<T>, operator?: BinaryOperatorType$1): this;
+    /**
+     * @description Join a table with the current model
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table
+     * @param primaryColumn - The primary column of the current model, default is caller model primary key if using A Model, if using a Raw Query Builder you must provide the key for the primary table
+     * @param operator - The comparison operator to use in the ON clause (default: "=")
+     */
+    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    rightJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    /**
+     * @description Perform a FULL OUTER JOIN with another table
+     * @param relationTable - The table to join
+     * @param referencingColumn - The column to reference from the relation table
+     * @param primaryColumn - The primary column of the current model
+     * @param operator - The comparison operator to use in the ON clause (default: "=")
+     */
+    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn: JoinableColumn, operator?: BinaryOperatorType$1): this;
+    fullJoin(relationTable: string, referencingColumnOrPrimaryColumn: JoinableColumn, primaryColumn?: JoinableColumn, operator?: BinaryOperatorType$1): this;
+}
+
+declare class SelectQueryBuilder<T extends Model> extends JoinQueryBuilder<T> {
+    protected dbType: SqlDataSourceType;
+    protected modelSelectedColumns: string[];
+    protected modelAnnotatedColumns: string[];
+    protected withQuery?: string;
+    protected fromNode: FromNode;
+    protected distinctNode: DistinctNode | null;
+    protected distinctOnNodes: DistinctOnNode[];
+    protected selectNodes: SelectNode[];
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Adds a SELECT condition to the query.
+     * @description Can be stacked multiple times
+     * @warning For annotations, use the `annotate` method instead, aliases and methods are not supported in the select method and will give error `column "${columnName} as ${alias}" does not exist`
+     * @example
+     * ```ts
+     * const user = await User.query().select("name", "age").first(); // SELECT name, age FROM users
+     * const user = await User.query().select("name", "users.age").first(); // SELECT name, users.age FROM users
+     * ```
+     */
+    select<S extends string>(...columns: SelectableColumn<S>[]): this;
+    select(...columns: (ModelKey<T> | "*")[]): this;
+    /**
+     * @description Adds a raw select statement to the query
+     * @warning For models, only annotated columns are available and will be added to the `$annotations` property of the model. Everything else will be ignored, if you need a query like `selectRaw` you can use the `QueryBuilder` instead.
+     */
+    selectRaw(statement: string): this;
+    /**
+     * @description Clears the SELECT clause
+     */
+    clearSelect(): this;
+    /**
+     * @description Clears the FROM clause
+     */
+    clearFrom(): this;
+    /**
+     * @description Clears the DISTINCT clause
+     */
+    clearDistinct(): this;
+    /**
+     * @description Clears the DISTINCT ON clause
+     */
+    clearDistinctOn(): this;
+    /**
+     * @description Annotates a column with a SQL method or a simple alias
+     * @description If using a model, the result will be available in the $annotations property of the model, else it will be available in the result of the query
+     * @example
+     * ```ts
+     * const user = await User.query().annotate("max", "id", "maxId").first(); // max(id) as maxId
+     * const user = await User.query().annotate("id", "superId").first(); // id as superId
+     * const user = await User.query().annotate("id", "superId").first(); // id as superId
+     * ```
+     */
+    annotate(column: string, alias: string): this;
+    annotate(sqlMethod: SqlMethod, column: string, alias: string): this;
+    annotate(sqlMethod: string, column: string, alias: string): this;
+    /**
+     * @description Sets the table to select from, by default is the table defined in the Model
+     * @description Can be used on non select queries too, it will only specify the table name (es. INSERT INTO $table)
+     */
+    from(table: string): this;
+    /**
+     * @description Sets the table to select from, by default is the table defined in the Model
+     * @description Better naming convention for non select queries
+     * @alias from
+     */
+    table(table: string): this;
+    /**
+     * @description Adds a DISTINCT clause to the query
+     */
+    distinct(): this;
+    /**
+     * @description Adds a DISTINCT ON clause to the query
+     * @postgresql Only usable with PostgreSQL
+     */
+    distinctOn(...columns: ModelKey<T>[]): this;
+    distinctOn<S extends string>(...columns: SelectableColumn<S>[]): this;
+}
+
+declare abstract class WhereQueryBuilder<T extends Model> extends SelectQueryBuilder<T> {
+    protected whereNodes: (WhereNode | WhereGroupNode | WhereSubqueryNode)[];
+    protected havingNodes: HavingNode[];
+    protected isNestedCondition: boolean;
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource, isNestedCondition?: boolean);
+    clearWhere(): this;
+    clearHaving(): this;
+    /**
+     * @description Accepts a value and executes a callback only of the value is not null or undefined.
+     * @warning The value is not checked for truthiness but existence, it is only checked for undefined or null. So false, 0, "", etc. will be considered truthy.
+     */
+    strictWhen(value: any, cb: (query: this) => void): this;
+    /**
+     * @description Accepts a value and executes a callback only of the value is not falsy.
+     * @warning The value is checked for truthiness, so false, 0, "", etc. will be considered falsy. Use strictWhen for null or undefined only cases.
+     */
+    when(value: any, cb: (query: this) => void): this;
+    /**
+     * @description Adds a WHERE condition to the query.
+     */
+    where(column: ModelKey<T>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    where<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    where(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    where(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    where(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    where(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues$1): this;
+    /**
+     * @description Adds an AND WHERE condition to the query.
+     */
+    andWhere(column: ModelKey<T>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    andWhere(column: SelectableColumn<string>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    andWhere(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues$1): this;
+    andWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    andWhere(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    andWhere(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    /**
+     * @description Adds an OR WHERE condition to the query.
+     */
+    orWhere(column: ModelKey<T>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    orWhere<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    orWhere<S extends string>(column: ModelKey<T> | SelectableColumn<S>, value: BaseValues$1): this;
+    orWhere(cb: (queryBuilder: WhereOnlyQueryBuilder<T>) => void): this;
+    orWhere(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    orWhere(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    /**
+     * @description Adds a negated WHERE condition to the query.
+     */
+    whereNot(column: ModelKey<T>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    whereNot<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    whereNot(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues$1): this;
+    whereNot(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    whereNot(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    /**
+     * @description Adds a negated AND WHERE condition to the query.
+     */
+    andWhereNot(column: ModelKey<T>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    andWhereNot<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    andWhereNot(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues$1): this;
+    andWhereNot(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    andWhereNot(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    /**
+     * @description Adds a negated OR WHERE condition to the query.
+     */
+    orWhereNot(column: ModelKey<T>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    orWhereNot<S extends string>(column: SelectableColumn<S>, operator: BinaryOperatorType$1, value: BaseValues$1): this;
+    orWhereNot(column: ModelKey<T> | SelectableColumn<string>, value: BaseValues$1): this;
+    orWhereNot(column: ModelKey<T> | SelectableColumn<string>, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    orWhereNot(column: ModelKey<T> | SelectableColumn<string>, operator: SubqueryOperatorType, subQuery: QueryBuilder<T> | ((subQuery: QueryBuilder<T>) => void)): this;
+    /**
+     * @description Adds a WHERE BETWEEN condition to the query.
+     */
+    whereBetween(column: ModelKey<T>, min: BaseValues$1, max: BaseValues$1): this;
+    whereBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues$1, max: BaseValues$1): this;
+    /**
+     * @description Adds an AND WHERE BETWEEN condition to the query.
+     */
+    andWhereBetween(column: ModelKey<T>, min: BaseValues$1, max: BaseValues$1): this;
+    andWhereBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues$1, max: BaseValues$1): this;
+    /**
+     * @description Adds an OR WHERE BETWEEN condition to the query.
+     */
+    orWhereBetween(column: ModelKey<T>, min: BaseValues$1, max: BaseValues$1): this;
+    orWhereBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues$1, max: BaseValues$1): this;
+    /**
+     * @description Adds a WHERE NOT BETWEEN condition to the query.
+     */
+    whereNotBetween(column: ModelKey<T>, min: BaseValues$1, max: BaseValues$1): this;
+    whereNotBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues$1, max: BaseValues$1): this;
+    /**
+     * @description Adds an AND WHERE NOT BETWEEN condition to the query.
+     */
+    andWhereNotBetween(column: ModelKey<T>, min: BaseValues$1, max: BaseValues$1): this;
+    andWhereNotBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues$1, max: BaseValues$1): this;
+    /**
+     * @description Adds an OR WHERE NOT BETWEEN condition to the query.
+     */
+    orWhereNotBetween(column: ModelKey<T>, min: BaseValues$1, max: BaseValues$1): this;
+    orWhereNotBetween<S extends string>(column: SelectableColumn<S>, min: BaseValues$1, max: BaseValues$1): this;
+    /**
+     * @description Adds a WHERE LIKE condition to the query.
+     */
+    whereLike(column: ModelKey<T>, value: string): this;
+    whereLike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an AND WHERE LIKE condition to the query.
+     */
+    andWhereLike(column: ModelKey<T>, value: string): this;
+    andWhereLike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an OR WHERE LIKE condition to the query.
+     */
+    orWhereLike(column: ModelKey<T>, value: string): this;
+    orWhereLike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds a WHERE ILIKE condition to the query.
+     */
+    whereILike(column: ModelKey<T>, value: string): this;
+    whereILike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an AND WHERE ILIKE condition to the query.
+     */
+    andWhereILike(column: ModelKey<T>, value: string): this;
+    andWhereILike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an OR WHERE ILIKE condition to the query.
+     */
+    orWhereILike(column: ModelKey<T>, value: string): this;
+    orWhereILike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds a WHERE NOT LIKE condition to the query.
+     */
+    whereNotLike(column: ModelKey<T>, value: string): this;
+    whereNotLike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an AND WHERE NOT LIKE condition to the query.
+     */
+    andWhereNotLike(column: ModelKey<T>, value: string): this;
+    andWhereNotLike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an OR WHERE NOT LIKE condition to the query.
+     */
+    orWhereNotLike(column: ModelKey<T>, value: string): this;
+    orWhereNotLike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds a WHERE NOT ILIKE condition to the query.
+     */
+    whereNotILike(column: ModelKey<T>, value: string): this;
+    whereNotILike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an AND WHERE NOT ILIKE condition to the query.
+     */
+    andWhereNotILike(column: ModelKey<T>, value: string): this;
+    andWhereNotILike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds an OR WHERE NOT ILIKE condition to the query.
+     */
+    orWhereNotILike(column: ModelKey<T>, value: string): this;
+    orWhereNotILike<S extends string>(column: SelectableColumn<S>, value: string): this;
+    /**
+     * @description Adds a WHERE IN condition to the query.
+     * @warning If the array is empty, it will add an impossible condition.
+     */
+    whereIn(column: ModelKey<T>, values: BaseValues$1[]): this;
+    whereIn<S extends string>(column: SelectableColumn<S>, values: BaseValues$1[]): this;
+    /**
+     * @description Adds an AND WHERE IN condition to the query.
+     * @warning If the array is empty, it will add an impossible condition.
+     */
+    andWhereIn(column: ModelKey<T>, values: BaseValues$1[]): this;
+    andWhereIn<S extends string>(column: SelectableColumn<S>, values: BaseValues$1[]): this;
+    /**
+     * @description Adds an OR WHERE IN condition to the query.
+     * @warning If the array is empty, it will add an impossible condition.
+     */
+    orWhereIn(column: ModelKey<T>, values: BaseValues$1[]): this;
+    orWhereIn<S extends string>(column: SelectableColumn<S>, values: BaseValues$1[]): this;
+    /**
+     * @description Adds a WHERE NOT IN condition to the query.
+     * @warning If the array is empty, it will add an obvious condition to make it true.
+     */
+    whereNotIn(column: ModelKey<T>, values: BaseValues$1[]): this;
+    whereNotIn<S extends string>(column: SelectableColumn<S>, values: BaseValues$1[]): this;
+    /**
+     * @description Adds an OR WHERE NOT IN condition to the query.
+     * @warning If the array is empty, it will add an obvious condition to make it true.
+     */
+    andWhereNotIn(column: ModelKey<T>, values: BaseValues$1[]): this;
+    andWhereNotIn<S extends string>(column: SelectableColumn<S>, values: BaseValues$1[]): this;
+    /**
+     * @description Adds an OR WHERE NOT IN condition to the query.
+     * @warning If the array is empty, it will add an obvious condition to make it true.
+     */
+    orWhereNotIn(column: ModelKey<T>, values: BaseValues$1[]): this;
+    orWhereNotIn<S extends string>(column: SelectableColumn<S>, values: BaseValues$1[]): this;
+    /**
+     * @description Adds a WHERE NULL condition to the query.
+     */
+    whereNull(column: ModelKey<T>): this;
+    whereNull<S extends string>(column: SelectableColumn<S>): this;
+    /**
+     * @description Adds an AND WHERE NULL condition to the query.
+     */
+    andWhereNull(column: ModelKey<T>): this;
+    andWhereNull<S extends string>(column: SelectableColumn<S>): this;
+    /**
+     * @description Adds an OR WHERE NULL condition to the query.
+     */
+    orWhereNull(column: ModelKey<T>): this;
+    orWhereNull<S extends string>(column: SelectableColumn<S>): this;
+    /**
+     * @description Adds a WHERE NOT NULL condition to the query.
+     */
+    whereNotNull(column: ModelKey<T>): this;
+    whereNotNull<S extends string>(column: SelectableColumn<S>): this;
+    /**
+     * @description Adds an AND WHERE NOT NULL condition to the query.
+     */
+    andWhereNotNull(column: ModelKey<T>): this;
+    andWhereNotNull<S extends string>(column: SelectableColumn<S>): this;
+    /**
+     * @description Adds an OR WHERE NOT NULL condition to the query.
+     */
+    orWhereNotNull(column: ModelKey<T>): this;
+    orWhereNotNull<S extends string>(column: SelectableColumn<S>): this;
+    /**
+     * @description Adds a WHERE REGEXP condition to the query.
+     */
+    whereRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    whereRegexp<S extends string>(column: SelectableColumn<S>, regexp: RegExp): this;
+    /**
+     * @description Adds an AND WHERE REGEXP condition to the query.
+     */
+    andWhereRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    andWhereRegexp<S extends string>(column: SelectableColumn<S>, regexp: RegExp): this;
+    /**
+     * @description Adds an OR WHERE REGEXP condition to the query.
+     */
+    orWhereRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    orWhereRegexp<S extends string>(column: SelectableColumn<S>, regexp: RegExp): this;
+    whereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    whereNotRegexp<S extends string>(column: SelectableColumn<S>, regexp: RegExp): this;
+    andWhereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    andWhereNotRegexp<S extends string>(column: SelectableColumn<S>, regexp: RegExp): this;
+    orWhereNotRegexp(column: ModelKey<T>, regexp: RegExp): this;
+    orWhereNotRegexp<S extends string>(column: SelectableColumn<S>, regexp: RegExp): this;
+    /**
+     * @description Adds a AND WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     */
+    whereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    /**
+     * @description Adds a AND WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     */
+    andWhereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    /**
+     * @description Adds a OR WHERE EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     */
+    orWhereExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    /**
+     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     */
+    whereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    /**
+     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     */
+    andWhereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    /**
+     * @description Adds a WHERE NOT EXISTS condition to the query. By default uses the same table, you can use the `from` method to change the table.
+     */
+    orWhereNotExists(cbOrQueryBuilder: (queryBuilder: QueryBuilder<T>) => void | QueryBuilder<T>): this;
+    /**
+     * @description Adds a raw WHERE condition to the query.
+     */
+    whereRaw(query: string, queryParams?: any[]): this;
+    /**
+     * @description Adds a raw AND WHERE condition to the query.
+     */
+    andWhereRaw(query: string, queryParams?: any[]): this;
+    /**
+     * @description Adds a raw OR WHERE condition to the query.
+     */
+    orWhereRaw(query: string, queryParams?: any[]): this;
+    /**
+     * @description Adds a HAVING condition to the query.
+     */
+    having<S extends string>(column: SelectableColumn<S>, value: any): this;
+    having(column: ModelKey<T>, operator: BinaryOperatorType$1, value: any): this;
+    /**
+     * @description Adds an AND HAVING condition to the query.
+     */
+    andHaving<S extends string>(column: SelectableColumn<S>, value: any): this;
+    andHaving(column: ModelKey<T>, operator: BinaryOperatorType$1, value: any): this;
+    /**
+     * @description Adds an OR HAVING condition to the query.
+     */
+    orHaving<S extends string>(column: SelectableColumn<S>, value: any): this;
+    orHaving(column: ModelKey<T>, operator: BinaryOperatorType$1, value: any): this;
+    /**
+     * @description Adds a raw HAVING condition to the query.
+     */
+    havingRaw(query: string): this;
+    /**
+     * @description Adds a raw OR HAVING condition to the query.
+     */
+    andHavingRaw(query: string): this;
+    /**
+     * @description Adds a raw OR HAVING condition to the query.
+     */
+    orHavingRaw(query: string): this;
+    private buildSubQuery;
+    private andWhereSubQuery;
+    private orWhereSubQuery;
+    private andWhereGroup;
+    private orWhereGroup;
+}
+
+type JsonParam = Record<string, unknown> | any[];
+declare class JsonQueryBuilder<T extends Model> extends WhereQueryBuilder<T> {
+    /**
+     * @description Filters records matching exact JSON value.
+     */
+    whereJson(column: ModelKey<T>, value: JsonParam): this;
+    whereJson(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records matching the given JSON value.
+     */
+    andWhereJson(column: ModelKey<T>, value: JsonParam): this;
+    andWhereJson(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records matching the given JSON value.
+     */
+    orWhereJson(column: ModelKey<T>, value: JsonParam): this;
+    orWhereJson(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column does NOT contain the given value.
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     */
+    whereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
+    whereJsonNotContains(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column does NOT contain the given value (AND).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     */
+    andWhereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
+    andWhereJsonNotContains(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column does NOT contain the given value (OR).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     */
+    orWhereJsonNotContains(column: ModelKey<T>, value: JsonParam): this;
+    orWhereJsonNotContains(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column contains the given value.
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     */
+    whereJsonContains(column: ModelKey<T>, value: JsonParam): this;
+    whereJsonContains(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column contains the given value (AND).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     */
+    andWhereJsonContains(column: ModelKey<T>, value: JsonParam): this;
+    andWhereJsonContains(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column contains the given value (OR).
+     * @sqlite might not work for all cases, suggest using the whereJsonRaw method instead
+     */
+    orWhereJsonContains(column: ModelKey<T>, value: JsonParam): this;
+    orWhereJsonContains(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column does NOT match the given value.
+     */
+    whereNotJson(column: ModelKey<T>, value: JsonParam): this;
+    whereNotJson(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column does NOT match the given value (AND).
+     */
+    andWhereNotJson(column: ModelKey<T>, value: JsonParam): this;
+    andWhereNotJson(column: string, value: JsonParam): this;
+    /**
+     * @description Filters records where JSON column does NOT match the given value (OR).
+     */
+    orWhereNotJson(column: ModelKey<T>, value: JsonParam): this;
+    orWhereNotJson(column: string, value: JsonParam): this;
+    /**
+     * @description Add a raw JSON filter expression.
+     */
+    whereJsonRaw(raw: string, params?: any[]): this;
+    /**
+     * @description Add a raw JSON filter expression (AND).
+     */
+    andWhereJsonRaw(raw: string, params?: any[]): this;
+    /**
+     * @description Add a raw JSON filter expression (OR).
+     */
+    orWhereJsonRaw(raw: string, params?: any[]): this;
+}
+
+type PluckReturnType<T extends Model, K extends ModelKey<T>> = T[K] extends infer U ? U[] : never;
+type WhereOnlyQueryBuilder<T extends Model> = Pick<WhereQueryBuilder<T>, "where" | "andWhere" | "orWhere" | "whereNot" | "andWhereNot" | "orWhereNot" | "whereIn" | "andWhereIn" | "orWhereIn" | "whereNotIn" | "andWhereNotIn" | "orWhereNotIn" | "whereBetween" | "andWhereBetween" | "orWhereBetween" | "whereNotBetween" | "andWhereNotBetween" | "orWhereNotBetween" | "whereNull" | "andWhereNull" | "orWhereNull" | "whereNotNull" | "andWhereNotNull" | "orWhereNotNull" | "whereLike" | "andWhereLike" | "orWhereLike" | "whereILike" | "andWhereILike" | "orWhereILike" | "whereNotLike" | "andWhereNotLike" | "orWhereNotLike" | "whereNotILike" | "andWhereNotILike" | "orWhereNotILike" | "whereRegexp" | "andWhereRegexp" | "orWhereRegexp" | "whereNotRegexp" | "andWhereNotRegexp" | "orWhereNotRegexp" | "whereRaw" | "andWhereRaw" | "orWhereRaw" | "whereExists" | "orWhereExists" | "andWhereExists"> & Pick<JsonQueryBuilder<T>, "whereJson" | "andWhereJson" | "orWhereJson" | "whereJsonContains" | "andWhereJsonContains" | "orWhereJsonContains" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains" | "whereJsonRaw" | "andWhereJsonRaw" | "orWhereJsonRaw" | "whereJsonNotContains" | "andWhereJsonNotContains" | "orWhereJsonNotContains">;
+type RelationRetrieveMethod<P extends any> = P extends any[] ? "many" : "one";
+type SelectableColumn<T extends string = string> = T extends `${infer Table}.${infer Column}.${string}` ? never : T extends `${string} ${string}` ? never : T extends `.${string}` | `${string}.` ? never : T extends `${string}-${string}` ? never : T extends `${string}.${string}` ? T : T;
+/**
+ * @description A column that can be used in a join statement e.g. `users.id`
+ */
+type JoinableColumn = `${string}.${string}`;
+/**
+ * @description Options for streaming queries
+ * @sqlite Ignores the options below
+ */
+type StreamOptions = {
+    highWaterMark?: number;
+    /** Postgres only */
+    rowMode?: "array";
+    /** Postgres only */
+    batchSize?: number;
+    /** Postgres only */
+    types?: any;
+    /** Mysql only */
+    objectMode?: boolean;
+};
+type Cursor<T extends Model, K extends ModelKey<T>> = {
+    key: K;
+    value: string | number;
+};
+type PaginateWithCursorOptions<T extends Model, K extends ModelKey<T>> = {
+    discriminator: K;
+    operator?: "<" | ">";
+    orderBy?: "asc" | "desc";
+};
+
+type UpdateOptions = {
+    ignoreBeforeUpdateHook?: boolean;
+};
+
+type TransactionIsolationLevel = "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+type StartTransactionOptions = {
+    isolationLevel?: TransactionIsolationLevel;
+};
+/**
+ * @description Options for the transaction execution
+ */
+type TransactionExecutionOptions = {
+    /**
+     * @description If true, the transaction will throw an error if it is inactive
+     */
+    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;
+}
+
+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 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;
+        }>;
+    };
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Returns true if the query builder is a relation query builder, this changes the behavior of the query builder like limit, offset, etc.
+     * @internal
+     */
+    protected get isRelationQueryBuilder(): boolean;
+    /**
+     * @description Creates a new ModelQueryBuilder instance from a model. Will use the main connection to the database by default.
+     */
+    static from(model: typeof Model, options?: BaseModelMethodOptions): ModelQueryBuilder<InstanceType<typeof model>>;
+    one(options?: OneOptions): Promise<AnnotatedModel<T, A, R> | null>;
+    first(options?: OneOptions): Promise<AnnotatedModel<T, A, R> | null>;
+    oneOrFail(options?: {
+        ignoreHooks?: OneOptions["ignoreHooks"] & {
+            customError?: Error;
+        };
+    }): Promise<AnnotatedModel<T, A, R>>;
+    firstOrFail(options?: {
+        ignoreHooks?: OneOptions["ignoreHooks"] & {
+            customError?: Error;
+        };
+    }): Promise<AnnotatedModel<T, A, R>>;
+    many(options?: ManyOptions): Promise<AnnotatedModel<T, A, R>[]>;
+    chunk(chunkSize: number, options?: ManyOptions): AsyncGenerator<AnnotatedModel<T, A, R>[]>;
+    stream(options?: ManyOptions & StreamOptions, cb?: (stream: PassThrough & AsyncGenerator<AnnotatedModel<T, A, R>>) => void | Promise<void>): Promise<PassThrough & AsyncGenerator<AnnotatedModel<T, A, R>>>;
+    paginateWithCursor<K extends ModelKey<T>>(page: number, options?: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T, A, R>, Cursor<T, K>]>;
+    private manyWithPerformance;
+    private oneWithPerformance;
+    private oneOrFailWithPerformance;
+    private firstOrFailWithPerformance;
+    private firstWithPerformance;
+    private paginateWithPerformance;
+    private paginateWithCursorWithPerformance;
+    update(data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions): Promise<number>;
+    softDelete(options?: SoftDeleteOptions<T>): Promise<number>;
+    delete(options?: DeleteOptions): Promise<number>;
+    getCount(column?: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getMax(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getMin(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getAvg(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    getSum(column: string, options?: {
+        ignoreHooks: boolean;
+    }): Promise<number>;
+    paginate(page: number, perPage: number, options?: {
+        ignoreHooks: boolean;
+    }): Promise<PaginatedData<T, A, R>>;
+    select<S extends string>(...columns: SelectableColumn<S>[]): this;
+    select(...columns: (ModelKey<T> | "*")[]): this;
+    /**
+     * @description Annotates a column with a SQL method or a simple alias
+     * @description If using a model, the result will be available in the $annotations property of the model, else it will be available in the result of the query
+     * @example
+     * ```ts
+     * const user = await User.query().annotate("max", "id", "maxId").first(); // max(id) as maxId
+     * const user = await User.query().annotate("id", "superId").first(); // id as superId
+     * ```
+     */
+    annotate<K extends string, V = any>(column: string, alias: K): ModelQueryBuilder<T, A & {
+        [P in K]: V;
+    }, R>;
+    annotate<K extends string, S extends SqlMethod, V = CommonSqlMethodReturnType<S>>(sqlMethod: string, column: string, alias: K): ModelQueryBuilder<T, A & {
+        [P in K]: V;
+    }, R>;
+    annotate<K extends string, S extends SqlMethod, V = CommonSqlMethodReturnType<S>>(sqlMethod: S, column: string, alias: K): ModelQueryBuilder<T, A & {
+        [P in K]: V;
+    }, R>;
+    annotate<K extends string, S extends SqlMethod, V = CommonSqlMethodReturnType<S>>(sqlMethod: S, column: string, alias: K): ModelQueryBuilder<T, A & {
+        [P in K]: V;
+    }, R>;
+    /**
+     * @description Removes annotations from the serialized model, by default, annotations are maintained in the serialized model if `annotate` is used
+     */
+    removeAnnotations(): ModelQueryBuilder<T, {}>;
+    /**
+     * @description Fills the relations in the model in the serialized response. Relation must be defined in the model.
+     * @warning Many to many relations have special behavior, since they require a join, a join clause will always be added to the query.
+     * @warning Many to many relations uses the model foreign key for mapping in the `$annotations` property, this property will be removed from the model after the relation is filled.
+     * @warning Foreign keys should always be selected in the relation query builder, otherwise the relation will not be filled.
+     */
+    load<RelationKey extends ModelRelation<T>, IA extends Record<string, any> = {}, IR extends Record<string, any> = {}>(relation: RelationKey, cb: (queryBuilder: RelationQueryBuilderType<RelatedInstance<T, RelationKey>>) => RelationQueryBuilderType<RelatedInstance<T, RelationKey>, IA, IR>): ModelQueryBuilder<T, A, R & {
+        [K in RelationKey]: Awaited<ReturnType<ModelQueryBuilder<RelatedInstance<T, K>, IA, IR>[RelationRetrieveMethod<T[K]>]>>;
+    }>;
+    load<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: RelationQueryBuilderType<RelatedInstance<T, RelationKey>>) => void): ModelQueryBuilder<T, A, R & {
+        [K in RelationKey]: Awaited<ReturnType<ModelQueryBuilder<RelatedInstance<T, K>, {}, {}>[RelationRetrieveMethod<T[K]>]>>;
+    }>;
+    /**
+     * @description Clears the relations from the query builder
+     */
+    clearRelations(): this;
+    /**
+     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     */
+    havingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    havingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType$1 | BaseValues$1, maybeValue?: BaseValues$1): this;
+    /**
+     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     */
+    andHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    andHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType$1 | BaseValues$1, maybeValue?: BaseValues$1): this;
+    /**
+     * @description Checks if the relation exists in the models and has the given filters, if no callback is provided, it only check if there is at least one record for the relation,
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     */
+    orHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    orHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType$1 | BaseValues$1, maybeValue?: BaseValues$1): this;
+    /**
+     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the Relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     */
+    notHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    notHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType$1 | BaseValues$1, maybeValue?: BaseValues$1): this;
+    /**
+     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     */
+    andNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    andNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType$1 | BaseValues$1, maybeValue?: BaseValues$1): this;
+    /**
+     * @description Checks if the relation does not exist in the models and has the given filters, if no callback is provided, it only check if there is no record for the Relation
+     * @warning All select statements are ignored, since we're only checking if the relation exists, a "select 1" will be added to the Query
+     */
+    orNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, cb?: (queryBuilder: ModelQueryBuilder<RelatedInstance<T, RelationKey>>) => void): this;
+    orNotHavingRelated<RelationKey extends ModelRelation<T>>(relation: RelationKey, operatorOrValue?: BinaryOperatorType$1 | BaseValues$1, maybeValue?: BaseValues$1): this;
+    /**
+     * @description Returns a copy of the query builder instance.
+     */
+    clone(): this;
+    /**
+     * @description Recursively processes all relations, including nested ones
+     */
+    protected processRelationsRecursively(models: T[]): Promise<void>;
+    protected mapRelatedModelsToModels<R extends ModelWithoutRelations<T>>(relation: Relation, modelsToFillWithRelations: T[], relatedModels: R[]): void;
+    protected getRelatedModelsForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): Promise<ModelWithoutRelations<T>[]>;
+    protected getRelatedModelsQueryForRelation(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, models: T[]): ModelQueryBuilder<T>;
+    protected getFilterValuesFromModelsForRelation(relation: Relation, models: T[]): any[];
+    protected applyHavingRelatedFilter(relationQueryBuilder: ModelQueryBuilder<any>, relation: Relation, operator?: BinaryOperatorType$1, value?: BaseValues$1): void;
+    protected addAdditionalColumnsToModel(row: any, typeofModel: typeof Model): Record<string, any>;
+}
+
+declare class ModelManager<T extends Model> {
+    protected sqlDataSource: SqlDataSource;
+    protected sqlType: SqlDataSourceType;
+    protected logs: boolean;
+    protected model: typeof Model;
+    protected modelInstance: T;
+    protected astParser: AstParser;
+    protected interpreterUtils: InterpreterUtils;
+    /**
+     * @description Constructor for ModelManager class.
+     */
+    constructor(model: typeof Model, sqlDataSource: SqlDataSource);
+    /**
+     * @description Finds all records that match the input
+     */
+    find<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input?: FindType<T, S, R>): Promise<AnnotatedModel<T, {}>[]>;
+    find<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input?: UnrestrictedFindType<T, S, R>): Promise<AnnotatedModel<T, {}>[]>;
+    /**
+     * @description Finds the first record that matches the input
+     */
+    findOne<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: UnrestrictedFindOneType<T, S, R>): Promise<AnnotatedModel<T, {}> | null>;
+    findOne<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: FindOneType<T, S, R>): Promise<AnnotatedModel<T, {}> | null>;
+    /**
+     * @description Finds the first record that matches the input or throws an error
+     */
+    findOneOrFail<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: FindOneType<T, S, R>): Promise<AnnotatedModel<T, {}>>;
+    findOneOrFail<S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(input: UnrestrictedFindOneType<T, S, R>): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Finds a record by its primary key
+     * @description Ignores all model hooks
+     * @throws {HysteriaError} if the model has no primary key
+     */
+    findOneByPrimaryKey(value: string | number, returning?: ModelKey<T>[]): Promise<AnnotatedModel<T, {}> | null>;
+    /**
+     * @description Creates a new record in the database
+     */
+    insert(model: Partial<T>, options?: InsertOptions<T>): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Creates multiple records in the database
+     */
+    insertMany(models: Partial<T>[], options?: InsertOptions<T>): Promise<AnnotatedModel<T, {}>[]>;
+    upsertMany(conflictColumns: string[], columnsToUpdate: string[], data: ModelWithoutRelations<T>[], options?: UpsertOptions<T>): Promise<AnnotatedModel<T, {}>[]>;
+    /**
+     * @description Updates a record, returns the updated record
+     * @description Model is retrieved from the database using the primary key regardless of any model hooks
+     * @description Can only be used if the model has a primary key, use a massive update if the model has no primary key
+     */
+    updateRecord(model: Partial<T>, options?: {
+        returning?: ModelKey<T>[];
+    }): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Deletes a record
+     * @description Can only be used if the model has a primary key, use a massive delete if the model has no primary key
+     */
+    deleteRecord(model: T): Promise<void>;
+    /**
+     * @description Returns a query builder instance
+     */
+    query(): Omit<ModelQueryBuilder<T>, "insert" | "insertMany">;
+    /**
+     * @description Mysql does not return the inserted model, so we need to get the inserted model from the database
+     */
+    private handleMysqlInsert;
+}
+
+type TableColumnInfo = {
+    name: string;
+    dataType: string;
+    isNullable: boolean;
+    defaultValue: string | number | boolean | null;
+    length?: number | null;
+    precision?: number | null;
+    scale?: number | null;
+    withTimezone?: boolean | null;
+};
+type TableIndexInfo = {
+    name: string;
+    columns: string[];
+    isUnique: boolean;
+};
+type TablePrimaryKeyInfo = {
+    name?: string;
+    columns: string[];
+};
+type TableSchemaInfo = {
+    columns: TableColumnInfo[];
+    indexes: TableIndexInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    primaryKey?: TablePrimaryKeyInfo;
+};
+type TableForeignKeyInfo = {
+    name?: string;
+    columns: string[];
+    referencedTable: string;
+    referencedColumns: string[];
+    onDelete?: string | null;
+    onUpdate?: string | null;
+};
+
+/**
+ * @description The SqlDataSource class is the main class for interacting with the database, it's used to create connections, execute queries, and manage transactions
+ */
+declare class SqlDataSource extends DataSource {
+    private static instance;
+    private globalTransaction;
+    private sqlType;
+    private models;
+    private ownsPool;
+    /**
+     * @description The pool of connections for the database
+     */
+    sqlPool: SqlPoolType | null;
+    /**
+     * @description Only used in transaction context to specify the connection, not meant to be used directly
+     * @private
+     */
+    sqlConnection: GetConnectionReturnType<SqlDataSourceType> | null;
+    /**
+     * @description Options provided in the sql data source initialization
+     */
+    inputDetails: SqlDataSourceInput;
+    /**
+     * @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
+     * ```
+     */
+    static connect<T extends Record<string, SqlDataSourceModel> = {}>(input: SqlDataSourceInput<T>, cb?: (sqlDataSource: AugmentedSqlDataSource<T>) => Promise<void> | void): Promise<AugmentedSqlDataSource<T>>;
+    static connect<T extends Record<string, SqlDataSourceModel> = {}>(cb?: (sqlDataSource: AugmentedSqlDataSource<T>) => Promise<void> | void): Promise<SqlDataSource>;
+    /**
+     * @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();
+     * ```
+     */
+    static connectToSecondarySource<T extends Record<string, SqlDataSourceModel> = {}>(input: SqlDataSourceInput<T>, cb?: (sqlDataSource: AugmentedSqlDataSource<T>) => Promise<void> | void): Promise<AugmentedSqlDataSource<T>>;
+    static connectToSecondarySource<T extends Record<string, SqlDataSourceModel> = {}>(cb?: (sqlDataSource: AugmentedSqlDataSource<T>) => Promise<void> | void): Promise<SqlDataSource>;
+    /**
+     * @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();
+     * });
+     * ```
+     */
+    static useConnection<T extends Record<string, SqlDataSourceModel> = {}>(connectionDetails: UseConnectionInput<T>, cb: (sqlDataSource: AugmentedSqlDataSource<T>) => Promise<void>): Promise<void>;
+    /**
+     * @description Returns the instance of the SqlDataSource
+     * @throws {HysteriaError} If the connection is not established
+     */
+    static getInstance(): SqlDataSource;
+    /**
+     * @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
+     */
+    static query(table: string): QueryBuilder;
+    /**
+     * @description Creates a table on the database, return the query to be executed to create the table
+     */
+    static createTable(...args: Parameters<Schema["createTable"]>): string;
+    /**
+     * @description Alters a table on the database, return the queries to be executed in order to alter the table
+     */
+    static alterTable(...args: Parameters<Schema["alterTable"]>): string[];
+    /**
+     * @description Starts a global transaction on the database
+     */
+    static startGlobalTransaction(options?: StartTransactionOptions): Promise<Transaction>;
+    /**
+     * @description Commits a global transaction on the database
+     * @throws {HysteriaError} If the global transaction is not started
+     */
+    static commitGlobalTransaction(): Promise<void>;
+    /**
+     * @description Rolls back a global transaction on the database
+     * @throws {HysteriaError} If the global transaction is not started
+     */
+    static rollbackGlobalTransaction(): Promise<void>;
+    /**
+     * @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
+     */
+    static startTransaction(options?: StartTransactionOptions): Promise<Transaction>;
+    static startTransaction(cb: (trx: Transaction) => Promise<void>, options?: StartTransactionOptions): Promise<void>;
+    /**
+     * @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
+     */
+    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>>;
+    /**
+     * @description Retrieves informations from the database for the given table
+     */
+    static getTableSchema(table: string): Promise<TableSchemaInfo>;
+    /**
+     * @description Closes the current connection
+     */
+    static closeConnection(): Promise<void>;
+    /**
+     * @alias closeConnection
+     */
+    static disconnect(): Promise<void>;
+    /**
+     * @description Executes a raw query on the database
+     */
+    static rawQuery<T = any>(query: string, params?: any[]): Promise<T>;
+    /**
+     * @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
+     * @example
+     * ```ts
+     * import { sql } from "hysteria-orm";
+     *
+     * await User.query().where("name", sql.rawStatement("LOWER(name)"));
+     * ```
+     */
+    static rawStatement(value: string): RawNode;
+    private constructor();
+    /**
+     * @description Returns true if the connection is established
+     */
+    get isConnected(): boolean;
+    /**
+     * @description Clones the SqlDataSource instance
+     * @param options.shouldRecreatePool Whether to recreate the pool of connections for the given driver, by default it's false
+     * @sqlite ignores the shouldRecreatePool option
+     * @returns A new SqlDataSource instance with the same input details
+     */
+    clone(options?: SqlCloneOptions): Promise<this>;
+    /**
+     * @description Returns the type of the database
+     */
+    getDbType(): SqlDataSourceType;
+    /**
+     * @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
+     */
+    query(table: string): QueryBuilder;
+    /**
+     * @description Return the query to alter the given table schema
+     */
+    alterTable(...args: Parameters<Schema["alterTable"]>): string[];
+    /**
+     * @description Return the query to create the given table schema
+     */
+    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
+     */
+    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
+     * @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
+     */
+    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
+     * @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
+     */
+    getModelManager<T extends Model>(model: {
+        new (): T;
+    } | typeof Model): ModelManager<T>;
+    /**
+     * @description Returns the current raw driver Pool, you can specify the type of connection you want to get to have better type safety
+     * @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>;
+    /**
+     * @description Returns a connection from the pool, you can specify the type of connection you want to get to have better type safety
+     * @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>>;
+    /**
+     * @description Closes the current connection
+     * @description If there is an active global transaction, it will be rolled back
+     */
+    closeConnection(): Promise<void>;
+    getConnectionDetails(): SqlDataSourceInput;
+    /**
+     * @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
+     * @sqlite Not supported but won't throw an error
+     */
+    syncSchema(options?: {
+        transactional: boolean;
+    }): Promise<void>;
+    /**
+     * @description Executes a raw query on the database
+     */
+    rawQuery<T = any>(query: string, params?: any[]): Promise<T>;
+    /**
+     * @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
+     * @example
+     * ```ts
+     * import { sql } from "hysteria-orm";
+     *
+     * await User.query().where("name", sql.rawStatement("LOWER(name)"));
+     * ```
+     */
+    rawStatement(value: string): RawNode;
+    /**
+     * @description Retrieves information from the database for the given table
+     */
+    getTableSchema(table: string): Promise<TableSchemaInfo>;
+    /**
+     * @description Models provided inside the connection method will always be used for openapi schema generation
+     * @experimental
+     */
+    getModelOpenApiSchema(): (OpenApiModelType & {
+        modelName: string;
+    })[];
+    /**
+     * @description Introspects table columns metadata
+     */
+    getTableInfo(table: string): Promise<TableColumnInfo[]>;
+    /**
+     * @description Introspects table indexes metadata using AST-driven queries
+     */
+    getIndexInfo(table: string): Promise<TableIndexInfo[]>;
+    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)
+     */
+    get registeredModels(): Record<string, typeof Model>;
+}
+
+type SqlDriverSpecificOptions = Omit<DriverSpecificOptions, "mongoOptions" | "redisOptions">;
+type MysqlConnectionInstance = Awaited<ReturnType<Mysql2Import["createPool"]>>;
+type PgPoolClientInstance = InstanceType<PgImport["Pool"]>;
+type SqliteConnectionInstance = InstanceType<Sqlite3Import["Database"]>;
+type SqlPoolType = MysqlConnectionInstance | PgPoolClientInstance | SqliteConnectionInstance;
+/**
+ * @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 = {
+    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<T extends Record<string, SqlDataSourceModel> = {}> = {
+    readonly type?: Exclude<DataSourceType, "mongo">;
+    /**
+     * @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 driver specific options to use for the sql data source, it's used to configure the driver specific options for the sql data source
+     */
+    driverOptions?: SqlDriverSpecificOptions;
+} & (MysqlSqlDataSourceInput | PostgresSqlDataSourceInput | SqliteDataSourceInput);
+type UseConnectionInput<T extends Record<string, SqlDataSourceModel> = {}> = {
+    readonly type: Exclude<DataSourceType, "mongo">;
+    readonly logs?: boolean;
+    readonly models?: T;
+    readonly driverOptions?: SqlDriverSpecificOptions;
+    connectionPolicies?: ConnectionPolicies;
+    queryFormatOptions?: FormatOptionsWithLanguage;
+} & (NotNullableMysqlSqlDataSourceInput | NotNullablePostgresSqlDataSourceInput | NotNullableSqliteDataSourceInput);
+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 : 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"]> : never;
+type AugmentedSqlDataSource<T extends Record<string, SqlDataSourceModel> = {}> = SqlDataSource & {
+    [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];
+};
+
+type AstParserType = {
+    sql: string;
+    bindings: any[];
+};
+
+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;
+}
+
+declare class QueryBuilder<T extends Model = any> extends JsonQueryBuilder<T> {
+    model: typeof Model;
+    protected astParser: AstParser;
+    protected unionNodes: UnionNode[];
+    protected withNodes: WithNode[];
+    protected lockQueryNodes: LockNode[];
+    protected isNestedCondition: boolean;
+    protected mustRemoveAnnotations: boolean;
+    protected interpreterUtils: InterpreterUtils;
+    /**
+     * @description Performance methods that return the time that took to execute the query with the result
+     */
+    performance: {
+        many: (returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, any, any>[];
+            time: number;
+        }>;
+        one: (returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, any, any> | null;
+            time: number;
+        }>;
+        oneOrFail: (returnType?: "millis" | "seconds") => Promise<{
+            data: any;
+            time: number;
+        }>;
+        first: (returnType?: "millis" | "seconds") => Promise<{
+            data: AnnotatedModel<T, any, any> | null;
+            time: number;
+        }>;
+        firstOrFail: (returnType?: "millis" | "seconds") => Promise<{
+            data: any;
+            time: number;
+        }>;
+        paginate: (page: number, perPage: number, returnType?: "millis" | "seconds") => Promise<{
+            data: PaginatedData<T>;
+            time: number;
+        }>;
+        paginateWithCursor: (page: number, options: PaginateWithCursorOptions<T, ModelKey<T>>, cursor?: Cursor<T, ModelKey<T>>, returnType?: "millis" | "seconds") => Promise<{
+            data: [CursorPaginatedData<T>, Cursor<T, ModelKey<T>>];
+            time: number;
+        }>;
+        exists: (returnType?: "millis" | "seconds") => Promise<{
+            data: boolean;
+            time: number;
+        }>;
+    };
+    constructor(model: typeof Model, sqlDataSource?: SqlDataSource);
+    protected get fromTable(): string;
+    /**
+     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
+     */
+    exists(): Promise<boolean>;
+    /**
+     * @description Executes the query and returns true if the query returns at least one result, false otherwise.
+     * @description Returns the time that took to execute the query
+     */
+    existsWithPerformance(returnType?: "millis" | "seconds"): Promise<{
+        data: boolean;
+        time: number;
+    }>;
+    /**
+     * @description Executes the query and retrieves multiple results.
+     */
+    many(): Promise<AnnotatedModel<T, any, any>[]>;
+    /**
+     * @description Executes the query and retrieves a single column from the results.
+     * @param key - The column to retrieve from the results, must be a Model Column
+     */
+    pluck<K extends ModelKey<T>>(key: K): Promise<PluckReturnType<T, K>>;
+    /**
+     * @description Executes the query and retrieves a single result.
+     */
+    one(): Promise<AnnotatedModel<T, any, any> | null>;
+    /**
+     * @alias one
+     */
+    first(): Promise<AnnotatedModel<T, any, any> | null>;
+    /**
+     * @description Executes the query and retrieves the first result. Fail if no result is found.
+     */
+    oneOrFail(): Promise<AnnotatedModel<T, any, any>>;
+    /**
+     * @alias oneOrFail
+     */
+    firstOrFail(): Promise<AnnotatedModel<T, any, any>>;
+    /**
+     * @description Executes the query and returns a node readable stream.
+     * @description If used by a model query builder, it will serialize the models and apply the hooks and relations.
+     * @postgres needs the pg-query-stream package in order to work
+     * @throws If using postgres and the `pg-query-stream` package is not installed
+     */
+    stream<M extends Model = T>(options?: StreamOptions, cb?: (stream: PassThrough & AsyncGenerator<AnnotatedModel<M, any, any>>) => void | Promise<void>): Promise<PassThrough & AsyncGenerator<AnnotatedModel<M, {}, {}>>>;
+    /**
+     * @description Chunks the query into smaller queries, it returns a generator of the chunks
+     * @description It will continue to yield chunks until the query returns no results
+     * @description Useful for large queries that need to be processed in chunks
+     * @warning overrides limit and offset set before in the query builder
+     * @param chunkSize - The size of the chunk
+     * @returns a generator of the chunks
+     * @example
+     * const chunks = await queryBuilder.chunk(100);
+     * // first chunk
+     * const firstChunk = await chunks.next();
+     * console.log(firstChunk.value);
+     * // second chunk
+     * const secondChunk = await chunks.next();
+     * console.log(secondChunk.value);
+     * // third chunk
+     * const thirdChunk = await chunks.next();
+     * console.log(thirdChunk.value);
+     *
+     * @example
+     * const chunkSize = 3;
+     * const chunks = [];
+     * const query = sql.query("users").orderBy("name", "asc");
+     * for await (const chunk of sql.chunk(chunkSize)) {
+     *   chunks.push(chunk);
+     * }
+     *
+     * console.log(chunks);
+     */
+    chunk(chunkSize: number): AsyncGenerator<any[], void, unknown>;
+    /**
+     * @description Executes the query and retrieves multiple paginated results.
+     * @description Overrides the limit and offset clauses in order to paginate the results.
+     * @description Allows to avoid offset clause that can be inefficient for large datasets
+     * @description If using a model query builder, primary key is used as discriminator by default
+     * @param options - The options for the paginate with cursor
+     * @param options.discriminator - The discriminator to use for the paginate with Cursor pagination
+     * @param options.operator - The operator to use for the paginate with Cursor pagination
+     * @param options.orderBy - The order by to use for the paginate with Cursor pagination
+     * @param cursor - The cursor to use for the paginate with Cursor pagination
+     * @warning If no order by clause is present in the query, the query will add an order by clause to the query `orderBy(discriminator, "asc")`
+     * @returns the pagination metadata and the cursor for the next page
+     */
+    paginateWithCursor<K extends ModelKey<T>>(limit: number, options: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T>, Cursor<T, K>]>;
+    /**
+     * @description Selects a subquery, subquery must return a single column
+     */
+    selectSubQuery(cbOrQueryBuilder: ((subQuery: QueryBuilder<T>) => void) | QueryBuilder<any>, alias: string): this;
+    /**
+     * @description Locks the table for update
+     * @param skipLocked - If true, the query will skip locked rows
+     * @sqlite does not support skipping locked rows, it will be ignored
+     */
+    lockForUpdate(options?: {
+        skipLocked?: boolean;
+        noWait?: boolean;
+    }): this;
+    /**
+     * @description Locks the table for share
+     * @param skipLocked - If true, the query will skip locked rows
+     * @sqlite does not support skipping locked rows, it will be ignored
+     */
+    forShare(options?: {
+        skipLocked?: boolean;
+        noWait?: boolean;
+    }): this;
+    /**
+     * @description Adds a UNION to the query.
+     */
+    union(query: string, bindings?: any[]): this;
+    union(cb: UnionCallBack<T>): this;
+    /**
+     * @description Adds a UNION ALL to the query.
+     */
+    unionAll(query: string, bindings?: any[]): this;
+    unionAll(cb: UnionCallBack<T>): this;
+    unionAll(queryBuilder: QueryBuilder<any>): this;
+    /**
+     * @description Increments the value of a column by a given amount, column must be of a numeric type in order to be incremented
+     * @typeSafe - In typescript, only numeric columns of the model will be accepted if using a Model
+     * @default value + 1
+     * @returns the number of affected rows
+     */
+    increment(column: NumberModelKey<T>, value?: number): Promise<number>;
+    /**
+     * @description Decrements the value of a column by a given amount, column must be of a numeric type in order to be decremented
+     * @typeSafe - In typescript, only numeric columns of the model will be accepted if using a Model
+     * @default value - 1
+     * @returns the number of affected rows
+     */
+    decrement(column: NumberModelKey<T>, value?: number): Promise<number>;
+    /**
+     * @description Executes the query and retrieves the count of results, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     */
+    getCount(column?: string): Promise<number>;
+    /**
+     * @description Executes the query and retrieves the maximum value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     */
+    getMax(column: string): Promise<number>;
+    /**
+     * @description Executes the query and retrieves the minimum value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     */
+    getMin(column: string): Promise<number>;
+    /**
+     * @description Executes the query and retrieves the average value of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     */
+    getAvg(column: string): Promise<number>;
+    /**
+     * @description Executes the query and retrieves the sum of a column, it ignores all select, group by, order by, limit and offset clauses if they are present.
+     */
+    getSum(column: string): Promise<number>;
+    /**
+     * @description Executes the query and retrieves multiple paginated results.
+     * @description Overrides the limit and offset clauses in order to paginate the results.
+     */
+    paginate(page: number, perPage: number): Promise<PaginatedData<T>>;
+    /**
+     * @description Overrides the from clause in the query.
+     */
+    from(table: string, alias?: string): this;
+    from(cb: (qb: QueryBuilder<T>) => void, alias: string): this;
+    /**
+     * @description Adds a CTE to the query using a callback to build the subquery.
+     */
+    with(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    /**
+     * @description Adds a recursive CTE to the query using a callback to build the subquery.
+     */
+    withRecursive(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    /**
+     * @description Adds a materialized CTE to the query using a callback to build the subquery.
+     * @postgres only
+     * @throws HysteriaError if the database type is not postgres
+     */
+    withMaterialized(alias: string, cb: (qb: QueryBuilder<T>) => void): this;
+    /**
+     * @description Insert record into a table
+     * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
+     * @returns raw driver response
+     */
+    insert(data: Record<string, any>, returning?: string[]): Promise<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
+     */
+    insertMany(data: Record<string, any>[], returning?: string[]): Promise<T[]>;
+    /**
+     * @description Updates records from a table
+     * @returns the number of affected rows
+     */
+    update(data: Record<string, any>): Promise<number>;
+    /**
+     * @description Deletes all records from a table
+     */
+    truncate(): Promise<void>;
+    /**
+     * @description Deletes records from a table
+     * @returns the number of affected rows
+     */
+    delete(): Promise<number>;
+    /**
+     * @description Soft deletes records from a table
+     * @default column - 'deletedAt'
+     * @default value - The current date and time in UTC timezone in the format "YYYY-MM-DD HH:mm:ss"
+     * @returns the number of affected rows
+     */
+    softDelete(options?: SoftDeleteOptions<T>): Promise<number>;
+    /**
+     * @description Returns the query with the parameters bound to the query
+     */
+    toQuery(dbType?: SqlDataSourceType): string;
+    /**
+     * @description Returns the query with database driver placeholders and the params
+     */
+    unWrap(dbType?: SqlDataSourceType): ReturnType<typeof AstParser.prototype.parse>;
+    /**
+     * @description Returns a deep clone of the query builder instance.
+     */
+    clone(): this;
+    protected clearLockQuery(): this;
+    protected clearUnionQuery(): this;
+    protected clearWithQuery(): this;
+    extractQueryNodes(): QueryNode[];
+    protected clearForFunctions(): this;
+    /**
+     * @description Makes a many query and returns the time that took to execute that query
+     */
+    private manyWithPerformance;
+    /**
+     * @description Makes a one query and returns the time that took to execute that query
+     */
+    private oneWithPerformance;
+    /**
+     * @alias oneWithPerformance
+     */
+    private firstWithPerformance;
+    /**
+     * @alias oneOrFailWithPerformance
+     */
+    private firstOrFailWithPerformance;
+    private paginateWithPerformance;
+    private paginateWithCursorWithPerformance;
+    /**
+     * @description Makes a one or fail query and returns the time that took to execute that query
+     */
+    private oneOrFailWithPerformance;
+}
+
+type UnionCallBack<T extends Model> = (queryBuilder: QueryBuilder<T>) => QueryBuilder<T>;
+type SqlMethod = "sum" | "avg" | "max" | "min" | "count" | "upper" | "lower" | "trim" | "length" | "cast" | "convert" | "abs" | "round" | "floor" | "ceil";
+
+type ModelInstanceType<O> = O extends typeof Model ? InstanceType<O> : never;
+type FetchHooks = "beforeFetch" | "afterFetch";
+type OneOptions = {
+    ignoreHooks?: FetchHooks[];
+};
+type ManyOptions = {
+    ignoreHooks?: FetchHooks[];
+};
+type AnnotatedModel<T extends Model, A extends object = {}, R extends object = {}> = [keyof A] extends [never] ? ModelWithoutRelations<T> & R : ModelWithoutRelations<T> & {
+    $annotations: A;
+} & R;
+type CommonSqlMethodReturnType<T extends SqlMethod> = T extends "count" | "sum" | "avg" | "min" | "max" ? number : T extends "upper" | "lower" | "trim" ? string : T extends "length" ? number : T extends "cast" | "convert" ? any : T extends "abs" | "round" | "floor" | "ceil" ? number : any;
+type RelatedInstance<M extends Model, K extends ModelRelation<M>> = M[K] extends (infer R)[] ? R extends Model ? R : never : M[K] extends Model ? M[K] : never;
+
+declare class BelongsTo extends Relation {
+    type: RelationEnum;
+    foreignKey: string;
+    constructor(relatedModel: typeof Model, columnName: string, foreignKey: string);
+}
+
+declare class HasMany extends Relation {
+    type: RelationEnum;
+    foreignKey: string;
+    constructor(relatedModel: typeof Model, columnName: string, foreignKey: string);
+}
+
+declare class HasOne extends Relation {
+    type: RelationEnum;
+    foreignKey: string;
+    constructor(relatedModel: typeof Model, columnName: string, foreignKey: string);
+}
+
+declare class ManyToMany extends Relation {
+    type: RelationEnum;
+    /**
+     * @description The model that establishes the relation
+     */
+    primaryModel: string;
+    /**
+     * @description The model that is being related to
+     */
+    relatedModel: string;
+    /**
+     * @description The foreign key of the related model in the through table
+     */
+    rightForeignKey: string;
+    /**
+     * @description The table that joins the two models
+     */
+    throughModel: string;
+    /**
+     * @description The foreign key of the primary model in the through table
+     */
+    leftForeignKey: string;
+    constructor(model: typeof Model, columnName: string, data: {
+        primaryModel: string;
+        throughModel: string;
+        leftForeignKey: string;
+        rightForeignKey: string;
+    });
+}
+
+type UpsertOptions<T extends Model> = {
+    ignoreHooks?: boolean;
+    updateOnConflict?: boolean;
+    returning?: ModelKey<T>[];
+};
+type InsertOptions<T extends Model> = {
+    ignoreHooks?: boolean;
+    returning?: ModelKey<T>[];
+};
+type ExcludeRelations<T> = {
+    [K in keyof T]: T[K] extends (Model[] | HasMany) | (Model | HasMany) | (Model | BelongsTo) | (Model[] | BelongsTo) | (Model | HasOne) | (Model[] | HasOne) | (Model | ManyToMany) | (Model[] | ManyToMany) | ((...args: any[]) => any) ? never : K;
+}[keyof T];
+type OnlyRelations<T> = {
+    [K in keyof T]: T[K] extends Model[] | Model ? K : never;
+}[keyof T];
+type OnlyM2MRelations<T> = {
+    [K in keyof T]: K extends string ? (T[K] extends Model[] ? K : never) : never;
+}[keyof T];
+type WhereType<T> = {
+    [K in keyof T]?: T[K];
+};
+type ModelKey<T extends Model> = {
+    [K in keyof T]: T[K] extends (Model[] | HasMany) | (Model | HasMany) | (Model | BelongsTo) | (Model[] | BelongsTo) | (Model | HasOne) | (Model[] | HasOne) ? never : K extends "*" ? never : K;
+}[keyof T];
+type ModelRelation<T extends Model> = OnlyRelations<T>;
+type OrderByChoices = "asc" | "desc";
+type OrderByType<T extends Model> = {
+    [K in keyof T]?: OrderByChoices;
+} & {
+    [K in string]?: OrderByChoices;
+};
+type UnrestrictedFindOneType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = {
+    select?: S;
+    relations?: R;
+    ignoreHooks?: FetchHooks[];
+    where?: Record<string, any>;
+    orderBy?: OrderByType<T>;
+    groupBy?: string[];
+    offset?: number;
+};
+type UnrestrictedFindType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = Omit<UnrestrictedFindOneType<T, S, R>, "throwErrorOnNull"> & {
+    limit?: number;
+};
+type FindOneType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = {
+    select?: S;
+    offset?: number;
+    relations?: R;
+    orderBy?: OrderByType<T>;
+    groupBy?: ModelKey<T>[];
+    where?: WhereType<T>;
+    ignoreHooks?: FetchHooks[];
+};
+type FindType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = Omit<FindOneType<T, S, R>, "throwErrorOnNull"> & {
+    limit?: number;
+};
+type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = S extends readonly any[] ? S[number] extends never ? ModelWithoutRelations<T> & {
+    [K in R[number] & keyof T]: T[K];
+} : {
+    [K in S[number] & keyof T]: T[K];
+} & {
+    [K in R[number] & keyof T]: T[K];
+} : ModelWithoutRelations<T> & {
+    [K in R[number] & keyof T]: T[K];
+};
+
+/**
+ * @description Represents a Table in the Database
+ */
+declare abstract class Model extends Entity {
+    private "*";
+    /**
+     * @description The column used to soft delete a record, default is deletedAt
+     */
+    static softDeleteColumn: string;
+    /**
+     * @description The value used to soft delete a record, default is the current date and time
+     * @default format: "YYYY-MM-DD HH:mm:ss" in UTC timezone
+     */
+    static softDeleteValue: string;
+    /**
+     * @description The sql sqlInstance generated by SqlDataSource.connect
+     */
+    static sqlInstance: SqlDataSource;
+    /**
+     * @description Getter for the table name of the model
+     */
+    static get table(): string;
+    /**
+     * @description Setter for the table name of the model
+     */
+    static set table(value: string);
+    /**
+     * @description Getter for the primary key of the model
+     */
+    static get primaryKey(): string | undefined;
+    /**
+     * @description Constructor for the model, it's not meant to be used directly, it just initializes the $annotations, it's advised to only use the static methods to interact with the database to save the model
+     * @description Using the constructor could lead to unexpected behavior, if you want to create a new record use the insert method
+     * @deprecated
+     */
+    constructor();
+    /**
+     * @description Returns all the records for the given model
+     */
+    static all<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<AnnotatedModel<T, {}>[]>;
+    /**
+     * @description Gives a query sqlInstance for the given model
+     */
+    static query<T extends Model>(this: new () => T | typeof Model, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): ModelQueryBuilder<T>;
+    /**
+     * @description Finds the first record in the database
+     * @deprecated Used only for debugging purposes, use findOne or query instead
+     */
+    static first<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<AnnotatedModel<T, {}> | null>;
+    /**
+     * @description Finds records for the given model
+     */
+    static find<T extends Model, S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(this: new () => T | typeof Model, findOptions?: FindType<T, S, R> | UnrestrictedFindType<T, S, R>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<FindReturnType<T, S, R>[]>;
+    /**
+     * @description Finds a record for the given model or throws an error if it doesn't exist
+     */
+    static findOneOrFail<T extends Model, S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(this: new () => T | typeof Model, findOneOptions: (FindOneType<T, S, R> | UnrestrictedFindOneType<T, S, R>) & {
+        customError?: Error;
+    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<FindReturnType<T, S, R>>;
+    /**
+     * @description Finds a record for the given model
+     */
+    static findOne<T extends Model, S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(this: new () => T | typeof Model, findOneOptions: (FindOneType<T, S, R> | UnrestrictedFindOneType<T, S, R>) & BaseModelMethodOptions, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<FindReturnType<T, S, R> | null>;
+    /**
+     * @description Finds records for the given column and value
+     */
+    static findBy<T extends Model, S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(this: new () => T | typeof Model, column: S, value: string | number | boolean | Date | null, options?: BaseModelMethodOptions): Promise<FindReturnType<T, S, R>[]>;
+    /**
+     * @description Finds the first record for the given column and value
+     */
+    static findOneBy<T extends Model, S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(this: new () => T | typeof Model, column: ModelKey<T>, value: string | number | boolean | Date | null, options?: BaseModelMethodOptions): Promise<FindReturnType<T, S, R> | null>;
+    /**
+     * @description Finds a record for the given model for the given value, the model must have a primary key defined else it will throw an error
+     */
+    static findOneByPrimaryKey<T extends Model, S extends ModelKey<T>[] = never[], R extends ModelRelation<T>[] = never[]>(this: new () => T | typeof Model, value: string | number, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<FindReturnType<T, S, R> | null>;
+    /**
+     * @description Refreshes a model from the database, the model must have a primary key defined
+     */
+    static refresh<T extends Model>(this: new () => T | typeof Model, model: T, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<AnnotatedModel<T, {}> | null>;
+    /**
+     * @description Saves a new record to the database
+     * @description $annotations will be ignored if set in the modelData and won't be returned in the response
+     * @warning If not using postgres and the model has no primary key, the model will be saved, but it won't be possible to retrieve it so at that point it will be returned as null, this is not typed as Model | null for type safety reasons
+     * @mysql If no Primary Key is present in the model definition, the exact input model will be returned
+     * @sqlite If no Primary Key is present in the model definition, the exact input will be returned
+     * @sqlite Returning Not supported and won't have effect
+     */
+    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Saves multiple records to the database
+     * @description $annotations will be ignored if set in the modelData and won't be returned in the response
+     * @warning If not using postgres and the model has no primary key, the models will be saved, but it won't be possible to retrieve them so at that point they will be returned as an empty array
+     * @mysql If no Primary Key is present in the model definition, the exact input model will be returned
+     * @sqlite If no Primary Key is present in the model definition, the exact input will be returned
+     * @sqlite Returning Not supported and won't have effect
+     */
+    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): Promise<AnnotatedModel<T, {}>[]>;
+    /**
+     * @description Syncs in the through table the given models for the given relation
+     * @param relation The many to many relation to sync, this is not type safe since many to many relations defined at a decorator level
+     * @param leftModel The source (left) model instance to synchronize in the many-to-many relation.
+     * @param rightModels The target (right) model instances to associate with the left model in the join table.
+     * @param joinTableCustomData Optional function that returns custom data for each join table row (receives rightModel and index)
+     * @param options.caseConvention Optional. Controls naming convention for left/right foreign keys in the join table. Defaults to the left model's convention; set to `none` to disable.
+     * @warning Use only when the join table contains no business logic beyond foreign keys. For business logic, define and use a dedicated join model.
+     * @warning This method does not trigger hooks on the join table, even if a Model exists. Use the join model's `insertMany` for hook support.
+     * @throws {HysteriaError} If the specified relation does not exist on the model.
+     * @throws {HysteriaError} If the specified relation is not a many-to-many relation.
+     */
+    static sync<T extends Model, R extends OnlyM2MRelations<T>>(this: new () => T | typeof Model, relation: R, leftModel: T, rightModels: T[R] extends any[] ? T[R] : T[R][], joinTableCustomData?: (rightModel: T[R] extends any[] ? T[R][number] : T[R], index: number) => Record<string, any>, options?: BaseModelMethodOptions & {
+        caseConvention?: CaseConvention;
+    }): Promise<void>;
+    /**
+     * @description Updates a record, returns the updated record
+     * @description Model is retrieved from the database using the primary key regardless of any model hooks
+     * @description Can only be used if the model has a primary key, use a massive update if the model has no primary key
+     * @throws {HysteriaError} If the model has no primary key
+     */
+    static updateRecord<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: Partial<T>, updatePayload?: ModelWithoutRelations<T>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Finds the first record or creates a new one if it doesn't exist
+     */
+    static firstOrInsert<T extends Model, O extends boolean = false>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, createData: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks"> & {
+        fullResponse?: O;
+    }): Promise<O extends true ? {
+        isNew: boolean;
+        model: T;
+    } : T>;
+    /**
+     * @description Updates or creates a new record
+     */
+    static upsert<T extends Model>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, data: Partial<ModelWithoutRelations<T>>, options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Updates or creates multiple records
+     * @param {updateOnConflict} If true, the record will be updated if it exists, otherwise it will be ignored
+     */
+    static upsertMany<T extends Model>(this: new () => T | typeof Model, conflictColumns: ModelKey<T>[], data: Partial<ModelWithoutRelations<T>>[], options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<AnnotatedModel<T, {}>[]>;
+    /**
+     * @description Deletes a record to the database
+     */
+    static deleteRecord<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: T, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<void>;
+    /**
+     * @description Soft Deletes a record to the database
+     * @description default column: deletedAt
+     * @description default value: The current date and time in UTC timezone in the format "YYYY-MM-DD HH:mm:ss"
+     * @description You can override the column and value by providing the column and value on the static properties of the model `softDeleteColumn` and `softDeleteValue`
+     */
+    static softDelete<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: T, softDeleteOptions?: {
+        column?: ModelKey<T>;
+        value?: string | number | boolean | Date;
+    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<AnnotatedModel<T, {}>>;
+    /**
+     * @description Truncates the table for the given model
+     */
+    static truncate<T extends Model>(this: new () => T | typeof Model, options?: BaseModelMethodOptions): Promise<void>;
+    /**
+     * @description Returns the table info for the model form the database
+     */
+    static getTableInfo(): Promise<TableColumnInfo[]>;
+    /**
+     * @description Returns the index info for the model form the database
+     */
+    static getIndexInfo(): Promise<TableIndexInfo[]>;
+    /**
+     * @description Returns the table schema for the model form the database
+     */
+    static getTableSchema(): Promise<TableSchemaInfo>;
+    /**
+     * @description Merges the provided data with the model instance
+     */
+    static combineProps<T extends Model>(sqlInstance: Partial<T>, data: Partial<T>): void;
+    /**
+     * @description Adds a beforeFetch clause to the model, adding the ability to modify the query before fetching the data
+     */
+    static beforeFetch?(queryBuilder: ModelQueryBuilder<any>): void;
+    /**
+     * @description Adds a beforeInsert clause to the model, adding the ability to modify the data before inserting the data
+     * @param {Model} data The single model to be inserted, in insertMany the hook will be called for each model
+     * @example
+     * ```typescript
+     * static async beforeInsert?(data: User): Promise<void> {
+     *   data.name = data.name.toUpperCase();
+     * }
+     * ```
+     */
+    static beforeInsert?(data: any): Promise<void> | void;
+    /**
+     * @description Adds a beforeUpdate clause to the model, adding the ability to modify the query before updating the data
+     */
+    static beforeUpdate?(queryBuilder: ModelQueryBuilder<any>): void;
+    /**
+     * @description Adds a beforeDelete clause to the model, adding the ability to modify the query before deleting the data
+     */
+    static beforeDelete?(queryBuilder: ModelQueryBuilder<any>): void;
+    /**
+     * @description Adds a afterFetch clause to the model, adding the ability to modify the data after fetching the data
+     * @param {Model} data The single model to be fetched, in queries that return multiple models the hook will be called for each model
+     * @example
+     * ```typescript
+     * static async afterFetch?(data: User): Promise<User> {
+     *   return data;
+     * }
+     * ```
+     */
+    static afterFetch?(data: any): Promise<any> | any;
+    /**
+     * @description Returns the columns of the model
+     */
+    static getColumns(): ColumnType[];
+    /**
+     * @description Returns the relations of the model
+     */
+    static getRelations(): LazyRelationType[];
+    /**
+     * @description Returns the indexes metadata of the model
+     */
+    static getIndexes(): IndexType[];
+    static getUniques(): UniqueType[];
+    /**
+     * @description Defines a column in the model, useful in javascript in order to not have to rely on decorators since are not supported without a transpiler like babel
+     * @javascript
+     */
+    static column(columnName: string, ...args: Parameters<typeof column>): void;
+    /**
+     * @description Defines an hasOne relation
+     * @javascript
+     */
+    static hasOne(columnName: string, ...args: Parameters<typeof hasOne>): void;
+    /**
+     * @description Defines an hasMany
+     * @javascript
+     */
+    static hasMany(columnName: string, ...args: Parameters<typeof hasMany>): void;
+    /**
+     * @description Defines a belongsTo
+     * @javascript
+     */
+    static belongsTo(columnName: string, ...args: Parameters<typeof belongsTo>): void;
+    /**
+     * @description Defines a many to many
+     * @javascript
+     */
+    static manyToMany(columnName: string, ...args: Parameters<typeof manyToMany>): void;
+    /**
+     * @description Establishes a connection to the database instantiated from the SqlDataSource.connect method, this is done automatically when using the static methods
+     * @description This method is meant to be used only if you want to establish sql sqlInstance of the model directly
+     * @internal
+     */
+    private static establishConnection;
+    /**
+     * @description Gives the correct model manager with the correct connection based on the options provided
+     */
+    private static dispatchModelManager;
+}
+
+type BaseModelRelationType = {
+    onDelete?: OnUpdateOrDelete;
+    onUpdate?: OnUpdateOrDelete;
+    constraintName?: string;
+};
+/**
+ * @description Class decorator to define indexes on the model
+ * @description If no indexName is provided, the index name will be the model name plus the columns joined by underscores
+ * @example User will have an index named "user_name_index" on the "name" column
+ * @example User will have an index named "user_name_email_index" on the "name" and "email" columns
+ * ```ts
+ * @index(["name", "email"], "user_name_email_index")
+ * class User extends Model {
+ *   @column()
+ *   name!: string;
+ * }
+ *
+ * @index(["name", "email"])
+ * class User extends Model {
+ *   @column()
+ *   name!: string;
+ * }
+ * ```
+ */
+declare function index(indexes: string | string[], indexName?: string): ClassDecorator;
+declare function unique(columns: string | string[], constraintName?: string): ClassDecorator;
+/**
+ * @description Decorator to define a view on the model
+ * @description This will automatically create a view on the database with the given statement
+ * @description Since a view is intended to get data from other tables, a migration is not necessary
+ * @example
+ * ```ts
+ * @view((query) => {
+ *   query.select("*").from("users");
+ * })
+ * class User extends Model {
+ *   @column()
+ *   name!: string;
+ * }
+ * ```
+ */
+declare function view(statement: (query: ModelQueryBuilder<any>) => void): ClassDecorator;
+/**
+ * @description Decorator to define a column in the model
+ */
+declare function column(options?: ColumnOptions): PropertyDecorator;
+declare namespace column {
+    var primary: typeof primaryKeyColumn;
+    var date: typeof dateColumn;
+    var boolean: typeof booleanColumn;
+    var json: typeof jsonColumn;
+    var uuid: typeof uuidColumn;
+    var ulid: typeof ulidColumn;
+    var integer: typeof integerColumn;
+    var float: typeof floatColumn;
+    var encryption: {
+        symmetric: typeof symmetric;
+        asymmetric: typeof asymmetric;
+    };
+}
+declare function primaryKeyColumn(options?: Omit<ColumnOptions, "primaryKey">): PropertyDecorator;
+declare function floatColumn(options?: Omit<ColumnOptions, "serialize">): PropertyDecorator;
+/**
+ * @description Decorator to define a integer column in the model, this will automatically convert the integer to the correct format for the database
+ * @description Useful in databases like postgres where the integer is returned as a string by the driver
+ * @description Defaults type to integer for migration generation
+ */
+declare function integerColumn(options?: Omit<ColumnOptions, "serialize">): PropertyDecorator;
+/**
+ * @description Decorator to define a uuid column in the model
+ * @description This will automatically generate a uuid if no value is provided
+ * @description Defaults type to uuid for migration generation
+ */
+declare function uuidColumn(options?: Omit<ColumnOptions, "prepare">): PropertyDecorator;
+/**
+ * @description Decorator to define a ulid column in the model
+ * @description This will automatically generate a ulid if no value is provided
+ * @description Defaults type to ulid for migration generation
+ */
+declare function ulidColumn(options?: Omit<ColumnOptions, "prepare">): PropertyDecorator;
+/**
+ * @description Decorator to define a symmetric encrypted column in the model with a key
+ * @description This will automatically encrypt the value before it is inserted or updated in the database and decrypt it when it is retrieved from the database
+ * @description If no value is provided, the value will be returned as is
+ */
+declare function symmetric(options: Omit<SymmetricEncryptionOptions, "prepare" | "serialize">): PropertyDecorator;
+/**
+ * @description Decorator to define a asymmetric encrypted column in the model with public and private keys
+ * @description This will automatically encrypt the value before it is inserted or updated in the database and decrypt it when it is retrieved from the database
+ * @description If no value is provided, the value will be returned as is
+ */
+declare function asymmetric(options: Omit<AsymmetricEncryptionOptions, "prepare" | "serialize">): PropertyDecorator;
+/**
+ * @description Decorator to define a boolean column in the model
+ * @description This will automatically convert the boolean to the correct format for the database, useful for mysql since it stores booleans as tinyint(1)
+ * @description Defaults type to boolean for migration generation
+ */
+declare function booleanColumn(options?: Omit<ColumnOptions, "prepare" | "serialize">): PropertyDecorator;
+/**
+ * @description Decorator to define a date column in the model
+ * @description This will automatically convert the date to the correct format for the database
+ * @description Supports both ISO format (YYYY-MM-DD HH:mm:ss) and Unix timestamp
+ * @description Handles timezone conversion between UTC and local time
+ * @description Can automatically update/create timestamps
+ * @param options Configuration options for the date column
+ * @param options.format The format to store dates in ('ISO' or 'TIMESTAMP')
+ * @param options.timezone The timezone to use ('UTC' or 'LOCAL')
+ * @param options.autoUpdate Whether to automatically update the timestamp on record updates
+ * @param options.autoCreate Whether to automatically set the timestamp on record creation
+ */
+declare function dateColumn(options?: Omit<DateColumnOptions, "prepare" | "serialize">): PropertyDecorator;
+/**
+ * @description Decorator to define a json column in the model
+ * @description This will automatically convert the json to the correct format for the database
+ * @throws json parse error if the value from the database is not valid json
+ * @description Defaults type to jsonb for migration generation
+ */
+declare function jsonColumn(options?: Omit<ColumnOptions, "prepare" | "serialize">): PropertyDecorator;
+declare function getModelColumns(target: typeof Model): ColumnType[];
+/**
+ * relations
+ */
+/**
+ * @description Establishes a belongs to relation with the given model
+ * @default foreignKey by default will be the singular of the model that establishes the relation name plus "_id"
+ * @example Post that has a user will have foreignKey "user_id" on the  model
+ * ```typescript
+ * belongsTo<typeof Post>(() => User, 'userId')
+ * ```
+ */
+declare function belongsTo<M extends typeof Model = any, R extends typeof Model = any>(model: () => R, foreignKey?: ModelKey<InstanceType<M>>, options?: BaseModelRelationType): PropertyDecorator;
+/**
+ * @description Establishes a has one relation with the given model
+ * @default foreignKey by default will be the singular of the model name plus "_id"
+ * @example User will have foreignKey "user_id" on the Post model
+ */
+declare function hasOne<T extends typeof Model>(model: () => T, foreignKey?: ModelKey<InstanceType<T>>): PropertyDecorator;
+/**
+ * @description Establishes a has many relation with the given model
+ * @default foreignKey by default will be the singular of the model name plus "_id"
+ * @example User will have foreignKey "user_id" on the Post model
+ */
+declare function hasMany<T extends typeof Model>(model: () => T, foreignKey?: ModelKey<InstanceType<T>>): PropertyDecorator;
+/**
+ * @description Establishes a many to many relation with the given model
+ * @default foreignKey by default will be the singular of the model that establishes the relation name plus "_id"
+ * @param model The model that establishes the relation
+ * @param throughModel The model that is used to join the two models
+ * @param throughModelKeys The keys of the through model
+ * @param throughModelKeys.leftForeignKey The foreign key of the through model from the primary model (where you are defining the many to many relation)
+ * @param throughModelKeys.rightForeignKey The foreign key of the through model from the related model (the model you are joining to)
+ * @example User will have foreignKey "user_id" on the Join table by default
+ */
+declare function manyToMany<R extends typeof Model, T extends typeof Model, TM extends ThroughModel<T>>(model: () => R, throughModel: TM, throughModelKeys?: ManyToManyOptions<T, TM>, options?: BaseModelRelationType): PropertyDecorator;
+declare function getRelationsMetadata(target: typeof Model): LazyRelationType[];
+/**
+ * @description Returns the relations of the model
+ */
+declare function getRelations(target: typeof Model): Relation[];
+/**
+ * @description Returns the primary key of the model
+ */
+declare function getPrimaryKey(target: typeof Model): string;
+declare function getIndexes(target: typeof Model): IndexType[];
+declare function getUniques(target: typeof Model): UniqueType[];
+
+type FactoryReturnType<T extends number, O extends Model> = T extends 1 ? O : O[];
+
+declare class ModelFactory<M extends Model> {
+    typeofModel: typeof Model;
+    modelData: Partial<M>;
+    /**
+     * @description Constructor for the model factory
+     */
+    constructor(typeofModel: typeof Model, modelData: Partial<M>);
+    /**
+     * @description Merges the provided data with the model data
+     */
+    merge(modelData: Partial<ModelWithoutRelations<M>>): void;
+    /**
+     * @description Create a model
+     * @param howMany - The number of models to create
+     * @returns The created model(s) where howMany = 1 returns a single model and howMany !== 1 returns an array of models
+     */
+    create<T extends number>(howMany: T): Promise<FactoryReturnType<T, M>>;
+}
+declare const createModelFactory: <M extends Model>(typeofModel: typeof Model, modelData: Partial<ModelWithoutRelations<M>>) => ModelFactory<M>;
+
+/**
+ * @description Mixin to add createdAt, updatedAt and deletedAt columns to a model
+ */
+declare class TimestampedModel extends Model {
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+}
+
+/**
+ * @description Mixin to add a uuid column to a model
+ */
+declare class UuidModel extends Model {
+    id: string;
+}
+
+/**
+ * @description Mixin to add an autogenerated id column to a model
+ */
+declare class AutogeneratedModel extends Model {
+    id: BigInt;
+}
+
+/**
+ * @description Mixin to add a user model with id, email, createdAt, updatedAt and deletedAt columns
+ */
+declare class User extends Model {
+    id: BigInt;
+    email: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+}
+
+/**
+ * @description The RedisStorable type is a type that can be stored in redis
+ */
+type RedisStorable = string | number | boolean | Buffer | Array<any> | Record<string, any>;
+/**
+ * @description The RedisFetchable type is a type that can be fetched from redis
+ */
+type RedisFetchable = string | number | boolean | Record<string, any> | Array<any> | null;
+/**
+ * @description The RedisDataSource class is a wrapper around the ioredis library that provides a simple interface to interact with a redis database
+ */
+declare class RedisDataSource {
+    static isConnected: boolean;
+    protected static redisDataSourceInstance: RedisDataSource;
+    isConnected: boolean;
+    protected ioRedisConnection: Redis;
+    constructor(ioRedisConnection: Redis);
+    /**
+     * @description Returns the raw ioredis connection
+     * @returns {Redis}
+     */
+    static get ioredis(): Redis;
+    /**
+     * @description Returns the raw ioredis connection
+     * @returns {Redis}
+     */
+    get ioredis(): Redis;
+    /**
+     * @description Connects to the redis database establishing a connection. If no connection details are provided, the default values from the env will be taken instead
+     * @description The User input connection details will always come first
+     * @description This is intended as a singleton connection to the redis database, if you need multiple connections, use the getConnection method
+     */
+    static connect(input?: RedisOptions): Promise<void>;
+    /**
+     * @description Establishes a connection to the redis database and returns the connection
+     * @param input
+     * @returns
+     */
+    static getConnection(input?: RedisOptions): Promise<RedisDataSource>;
+    /**
+     * @description Sets a key-value pair in the redis database
+     * @param {string} key - The key
+     * @param {string} value - The value
+     * @param {number} expirationTime - The expiration time in milliseconds
+     */
+    static set(key: string, value: RedisStorable, expirationTime?: number): Promise<void>;
+    /**
+     * @description Gets the value of a key in the redis database
+     * @param {string} key - The key
+     * @returns {Promise<string>}
+     */
+    static get<T = RedisFetchable>(key: string): Promise<T | null>;
+    /**
+     * @description Gets the value of a key in the redis database as a buffer
+     */
+    static getBuffer(key: string): Promise<Buffer | null>;
+    /**
+     * @description Gets the value of a key in the redis database and deletes the key
+     * @param {string} key - The key
+     * @returns {Promise
+     * <T | null>}
+     */
+    static consume<T = RedisFetchable>(key: string): Promise<T | null>;
+    /**
+     * @description Deletes a key from the redis database
+     * @param {string} key - The key
+     * @returns {Promise<void>}
+     */
+    static delete(key: string): Promise<void>;
+    /**
+     * @description Flushes all the data in the redis database
+     * @returns {Promise<void>}
+     */
+    static flushAll(): Promise<void>;
+    /**
+     * @description Disconnects from the redis database
+     * @returns {Promise<void>}
+     */
+    static disconnect(): Promise<void>;
+    /**
+     * @description Sets a key-value pair in the redis database
+     * @param {string} key - The key
+     * @param {string} value - The value
+     * @param {number} expirationTime - The expiration time in milliseconds
+     * @returns {Promise<void>}
+     */
+    set(key: string, value: RedisStorable, expirationTime?: number): Promise<void>;
+    /**
+     * @description Gets the value of a key in the redis database
+     * @param {string} key - The key
+     * @returns {Promise<string>}
+     */
+    get<T = RedisFetchable>(key: string): Promise<T | null>;
+    /**
+     * @description Gets the value of a key in the redis database as a buffer
+     */
+    getBuffer(key: string): Promise<Buffer | null>;
+    /**
+     * @description Gets the value of a key in the redis database and deletes the key
+     * @param {string} key - The key
+     * @returns {Promise
+     * <T | null>}
+     */
+    consume<T = RedisFetchable>(key: string): Promise<T | null>;
+    /**
+     * @description Deletes a key from the redis database
+     * @param {string} key - The key
+     * @returns {Promise<void>}
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * @description Flushes all the data in the redis database
+     * @returns {Promise<void>}
+     */
+    flushAll(): Promise<void>;
+    /**
+     * @description Disconnects from the redis database
+     * @returns {Promise<void>}
+     */
+    disconnect(forceError?: boolean): Promise<void>;
+    protected static getValue<T = RedisFetchable>(value: string | null): T | null;
+}
+
+declare abstract class Migration {
+    dbType: SqlDataSourceType;
+    migrationName: string;
+    schema: Schema;
+    constructor(dbType: SqlDataSourceType);
+    /**
+     * @description This method is called when the migration is to be run
+     */
+    abstract up(): Promise<void>;
+    /**
+     * @description This method is called when the migration is to be rolled back
+     */
+    abstract down(): Promise<void>;
+    /**
+     * @description This method is called after the migration has been run
+     */
+    afterMigration?(sqlDataSource: SqlDataSource): Promise<void>;
+}
+
+/**
+ * @description Can be used to run migrations programmatically
+ */
+declare class ClientMigrator {
+    protected migrationPath: string;
+    protected sqlDataSourceInput?: SqlDataSource["inputDetails"] | SqlDataSource;
+    constructor(migrationPath?: string, sqlDataSourceInput?: SqlDataSource["inputDetails"] | SqlDataSource);
+    /**
+     * @description Runs programmatic migrations up
+     */
+    up(): Promise<void>;
+    /**
+     * @description Runs programmatic migrations down
+     */
+    down(): Promise<void>;
+    /**
+     * @description Runs programmatic migrations up or down
+     * @param direction - The direction to migrate, either "up" or "down"
+     */
+    private migrate;
+}
+/**
+ * @description Defines a programmatic migrator, can be used to run migrations programmatically
+ * @param migrationPath - The path to the migrations
+ * @param sqlDataSourceInput - The sql data source input, if not provided, env variables will be used
+ */
+declare const defineMigrator: (migrationPath: string, sqlDataSourceInput?: SqlDataSource["inputDetails"] | SqlDataSource) => ClientMigrator;
+
+type CustomLogger = {
+    info(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+};
+declare class HysteriaLogger {
+    static loggerInstance: CustomLogger;
+    static setCustomLogger(customLogger: CustomLogger): void;
+    static info(message: string): void;
+    static error(message: string | Error): void;
+    static warn(message: string): void;
+}
+
+type WithPerformanceResult<R = any> = [string, R];
+/**
+ * @description executes the async function with a timer to check how long it took
+ * @param `returnType` of the performance in milliseconds or seconds
+ * @param `fix` Number of digits in the decimal part of the performance result
+ * @returns An array with the millis or seconds that the function took as first element, and the result of the async function as second element
+ */
+declare const withPerformance: <R = any>(fn: (...params: any) => Promise<R>, returnType?: "millis" | "seconds", fix?: number) => Promise<WithPerformanceResult<R>>;
+
+type HysteriaErrorCode = "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}` | `SQLITE_NOT_SUPPORTED` | `COCKROACHDB_NOT_SUPPORTED` | `RELATION_NOT_FOUND` | `POSTGRES_TABLE_REQUIRED` | `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";
+
+declare class HysteriaError extends Error {
+    code: HysteriaErrorCode;
+    caller: string;
+    error?: Error;
+    constructor(caller: string, code: HysteriaErrorCode, error?: Error);
+}
+
+/**
+ * Generates OpenAPI schemas for multiple models
+ */
+declare const generateOpenApiModel: <T extends new () => Model>(models: T[]) => OpenApiModelType[];
+/**
+ * Generates OpenAPI schema for a single model
+ */
+declare const generateOpenApiModelSchema: <T extends new () => Model>(model: T) => OpenApiModelType;
+/**
+ * Generates OpenAPI schemas with additional metadata
+ */
+declare const generateOpenApiModelWithMetadata: <T extends new () => Model>(models: T[]) => Array<OpenApiModelType & {
+    modelName: string;
+}>;
+
+export { type AnnotatedModel, type AsymmetricEncryptionOptions, type AugmentedSqlDataSource, AutogeneratedModel, type BaseModelMethodOptions, type BaseModelRelationType, 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, type FetchHooks, type GetConnectionReturnType, HysteriaError, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, Migration, Model, type ModelInstanceType, ModelQueryBuilder, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type SqlCloneOptions, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDataSourceWithoutTransaction, type SqlDriverSpecificOptions, type SqlPoolType, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type ThroughModel, TimestampedModel, Transaction, type TransactionExecutionOptions, type UniqueType, type UseConnectionInput, User, 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 };