@spinajs/orm 2.0.180 → 2.0.181

package/lib/mjs/interfaces.d.ts

@@ -1,920 +1,920 @@
-import { Op } from './enums.js';
-import { QueryBuilder, RawQuery } from './builders.js';
-import { SortOrder, WhereBoolean } from './enums.js';
-import { IQueryStatement, Wrap } from './statements.js';
-import { ModelData, ModelDataWithRelationData, ModelDataWithRelationDataSearchable, PartialArray, PickRelations, Unbox, WhereFunction } from './types.js';
-import { IOrmRelation } from './relations.js';
-import { OrmDriver } from './driver.js';
-import { Constructor, IContainer } from '@spinajs/di';
-import { ModelBase } from './model.js';
-import { DateTime } from 'luxon';
-import { Relation } from './relation-objects.js';
-export declare enum QueryContext {
-    Insert = 0,
-    Select = 1,
-    Update = 2,
-    Delete = 3,
-    Schema = 4,
-    Transaction = 5
-}
-export declare enum ColumnAlterationType {
-    Add = 0,
-    Modify = 1,
-    Rename = 2
-}
-export interface IRelation {
-    TargetModelDescriptor: IModelDescriptor;
-    /**
-     * Indicates if data was fetched  from db
-     */
-    Populated: boolean;
-}
-export declare abstract class DefaultValueBuilder<T> {
-    Query: RawQuery;
-    Value: string | number;
-    /**
-     * fills by default with current date
-     */
-    abstract date(): T;
-    /**
-     * fills by default with current datetime
-     */
-    abstract dateTime(): T;
-    /**
-     * Fills column with default value
-     *
-     * @param val - value to fill
-     */
-    abstract value(val: string | number): T;
-    /**
-     * Fills column with result of query provided
-     *
-     * @param query - raw query instance
-     */
-    abstract raw(query: RawQuery): T;
-}
-export declare enum InsertBehaviour {
-    /**
-     * Ignores if primary key exists in db
-     */
-    InsertOrIgnore = 0,
-    /**
-     * Updates entry if pk exists
-     */
-    InsertOrUpdate = 1,
-    /**
-     * Replaces entry if pk exists
-     */
-    InsertOrReplace = 2,
-    None = 3
-}
-/**
- * Foreign key referential actions
- */
-export declare enum ReferentialAction {
-    Cascade = "CASCADE",
-    SetNull = "SET NULL",
-    Restrict = "RESTRICT",
-    NoAction = "NO ACTION",
-    SetDefault = "SET DEFAULT"
-}
-/**
- * Transaction mode when migration DB
- */
-export declare enum MigrationTransactionMode {
-    /**
-     * Migration is run whithout transaction
-     */
-    None = 0,
-    /**
-     * On transaction for one migration - every migration has its own
-     */
-    PerMigration = 1
-}
-/**
- * Configuration options to set in configuration file and used in OrmDriver
- */
-export interface IDriverOptions {
-    /**
-     * Max connections limit
-     */
-    PoolLimit?: number;
-    /**
-     * Database name associated with this connection
-     */
-    Database?: string;
-    /**
-     * User associatet with this connection
-     */
-    User?: string;
-    /**
-     * Password to database
-     */
-    Password?: string;
-    /**
-     * DB Host
-     */
-    Host?: string;
-    /**
-     * Connection port
-     */
-    Port?: number;
-    /**
-     * Connection encoding eg. utf-8
-     */
-    Encoding?: string;
-    /**
-     * Database filename eg. for Sqlite driver
-     */
-    Filename?: string;
-    /**
-     * Driver name eg. mysql, sqlite, mssql etc.
-     */
-    Driver: string;
-    /**
-     * Connection name for identification
-     */
-    Name: string;
-    /**
-     * Additional driver-specific options
-     */
-    Options?: any;
-    /**
-     * If this is set, database connection will be made by ssh tunnel
-     */
-    SSH?: {
-        Host: string;
-        Port: number;
-        PrivateKey: string;
-        User: string;
-    };
-    Migration?: {
-        /**
-         * Should run migration on startup
-         */
-        OnStartup?: boolean;
-        /**
-         * Migration table name, if not set default is spinajs_orm_migrations
-         */
-        Table?: string;
-        /**
-         * Migration transaction options
-         */
-        Transaction?: {
-            /**
-             * How to run migration - with or without transaction
-             */
-            Mode?: MigrationTransactionMode;
-        };
-    };
-    /**
-     * When building queries with auto generated tables & fields
-     * we wrap them in special caharacter eg. $
-     * Different sql engines allows different characters,
-     * SQLITE & MYSQL allow to use $ in queries, but MSSQL its special characted used to create pseudocolumn
-     *
-     * Example: SELECT $users$.Name FROM users as $users$
-     */
-    AliasSeparator?: string;
-    /**
-     * Is this connection default. Later can be referenced under 'default' name
-     * eg. @Connection('default')
-     */
-    DefaultConnection?: boolean;
-}
-export interface IMigrationDescriptor {
-    /**
-     * Whitch connection migration will be executed
-     */
-    Connection: string;
-}
-export interface IValueConverterDescriptor {
-    Class: Constructor<ValueConverter>;
-    Options?: any;
-}
-/**
- * Describes model, used internally
- */
-export interface IModelDescriptor {
-    /**
-     * Primary key name
-     */
-    PrimaryKey: string;
-    /**
-     * Connection name, must be avaible in db config
-     */
-    Connection: string;
-    /**
-     * Table name in database for this model
-     */
-    TableName: string;
-    /**
-     * Optional, describes timestamps in model
-     */
-    Timestamps: IModelTimestampDescriptor;
-    /**
-     * Optional, describes soft delete
-     */
-    SoftDelete: IModelSoftDeleteDescriptor;
-    /**
-     * Optional, is archive mode enabled
-     */
-    Archived: IModelArchivedDescriptor;
-    /**
-     * Column  / fields list in model
-     */
-    Columns: IColumnDescriptor[];
-    /**
-     * Converters attached to fields
-     */
-    Converters: Map<string, IValueConverterDescriptor>;
-    /**
-     * List of unique columns ( UNIQUE constraint )
-     */
-    JunctionModelProperties: IJunctionProperty[];
-    /**
-     * List of relations in model
-     */
-    Relations: Map<string, IRelationDescriptor>;
-    /** Name of model */
-    Name: string;
-    /**
-     * Model discrimination map that  allows to create different models based on db field value
-     */
-    DiscriminationMap: IDiscriminationMap;
-    /**
-     * Orm driver that this model
-     */
-    Driver: OrmDriver;
-    /**
-     * Json schema for validation
-     */
-    Schema: any;
-}
-export interface IDiscriminationMap {
-    /**
-     * DB field that holds inheritance value
-     */
-    Field: string;
-    /**
-     * Field values mapped for proper models
-     */
-    Models: Map<string, Constructor<ModelBase>>;
-}
-export interface IDiscriminationEntry {
-    Key: string;
-    Value: Constructor<ModelBase>;
-}
-export declare enum RelationType {
-    One = 0,
-    Many = 1,
-    ManyToMany = 2
-}
-export type ForwardRefFunction = () => Constructor<ModelBase>;
-/**
- * Returns result of last insert or affected rows ( eg. rows affected would be 0 if insert is ignored )
- */
-export interface IUpdateResult {
-    RowsAffected: number;
-    LastInsertId: number;
-}
-export interface IRelationDescriptor {
-    /**
-     * Name of relations, defaults for property name in model that owns relation
-     */
-    Name: string;
-    /**
-     * Is it one-to-one, one-to-many or many-to-many
-     */
-    Type: RelationType;
-    TargetModelType: Constructor<ModelBase> | ForwardRefFunction | string;
-    /**
-     * Relation model (  foreign )
-     */
-    TargetModel: Constructor<ModelBase> & IModelStatic;
-    /**
-     * Relation owner
-     */
-    SourceModel: Constructor<ModelBase> & IModelStatic;
-    /**
-     * Relation foreign key (one to one, one to many)
-     */
-    ForeignKey: string;
-    /**
-     * Relation primary key (one to one, one to many)
-     */
-    PrimaryKey: string;
-    /**
-     * Used in many to many relations, model for join table
-     */
-    JunctionModel?: Constructor<ModelBase>;
-    /**
-     * Join table foreign keys, defaults to auto generated field names. Can be override.
-     */
-    JunctionModelTargetModelFKey_Name?: string;
-    JunctionModelSourceModelFKey_Name?: string;
-    /**
-     * Is this relation recursive ? Used for hierarchical / paren one-to-one relations
-     */
-    Recursive: boolean;
-    /**
-     * Relation factory, sometimes we dont want to create standard relation object
-     */
-    Factory?: (model: ModelBase<unknown>, relation: IRelationDescriptor, container: IContainer) => Relation<ModelBase<unknown>, ModelBase<unknown>>;
-    /**
-     *  sometimes we dont want to create standard relation object, so we create type
-     *  that is passed in this property
-     */
-    RelationClass?: Constructor<Relation<ModelBase<unknown>, ModelBase<unknown>>>;
-}
-export interface IModelStatic extends Constructor<ModelBase<unknown>> {
-    where<T extends typeof ModelBase>(val: boolean): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(val: PartialArray<InstanceType<T>> | PickRelations<T>): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(func: WhereFunction<InstanceType<T>>): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(column: string, operator: Op, value: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(column: string, value: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(statement: Wrap): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(column: string | boolean | WhereFunction<InstanceType<T>> | RawQuery | PartialArray<InstanceType<T>> | Wrap | PickRelations<T>, operator?: Op | any, value?: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    where<T extends typeof ModelBase>(column: string | boolean | WhereFunction<InstanceType<T>> | RawQuery | PartialArray<InstanceType<T>> | Wrap | PickRelations<T>, _operator?: Op | any, _value?: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    destroy<T extends typeof ModelBase>(pk?: any | any[]): IDeleteQueryBuilder<InstanceType<T>> & Promise<IUpdateResult>;
-    create<T extends typeof ModelBase>(data: Partial<InstanceType<T>>): Promise<InstanceType<T>>;
-    query<T extends typeof ModelBase>(): ISelectQueryBuilder<Array<InstanceType<T>>>;
-    count<T extends typeof ModelBase>(callback?: (builder: IWhereBuilder<T>) => void): Promise<number>;
-    count(): Promise<number>;
-    update<T extends typeof ModelBase>(data: Partial<InstanceType<T>>): IUpdateQueryBuilder<InstanceType<T>>;
-    exists(pk: any): Promise<boolean>;
-    get<T extends typeof ModelBase>(pk: any): Promise<InstanceType<T>>;
-    insert<T extends typeof ModelBase>(data: InstanceType<T> | Partial<InstanceType<T>> | Array<InstanceType<T>> | Array<Partial<InstanceType<T>>>, insertBehaviour?: InsertBehaviour): Promise<IUpdateResult>;
-    getModelDescriptor(): IModelDescriptor;
-    getRelationDescriptor(relation: string): IRelationDescriptor;
-}
-export interface IModelBase {
-    ModelDescriptor: IModelDescriptor;
-    Container: IContainer;
-    PrimaryKeyName: string;
-    PrimaryKeyValue: any;
-    getFlattenRelationModels(): IModelBase[];
-    /**
-     * Fills model with data. It only fills properties that exists in database
-     *
-     * @param data - data to fill
-     */
-    hydrate(data: Partial<this>): void;
-    /**
-     *
-     * Attachess model to proper relation an sets foreign key
-     *
-     * @param data - model to attach
-     */
-    attach(data: ModelBase): void;
-    /**
-     * Extracts all data from model. It takes only properties that exists in DB. Does not dehydrate related data.
-     *
-     * @param omit - fields to omit
-     */
-    dehydrate(omit?: string[]): ModelData<this>;
-    /**
-     *
-     * Extracts all data from model with relation data. Relation data are dehydrated recursively.
-     *
-     * @param omit - fields to omit
-     */
-    dehydrateWithRelations(omit?: string[]): ModelDataWithRelationData<this>;
-    /**
-     * deletes enitt from db. If model have SoftDelete decorator, model is marked as deleted
-     */
-    destroy(): Promise<void>;
-    /**
-     * If model can be in achived state - sets archived at date and saves it to db
-     */
-    archive(): Promise<void>;
-    /**
-     * Updates model to db
-     */
-    update(): Promise<void>;
-    /**
-     * Save all changes to db. It creates new entry id db or updates existing one if
-     * primary key exists
-     */
-    insert(insertBehaviour: InsertBehaviour): Promise<IUpdateResult>;
-    /**
-     * Gets model data from database and returns as fresh instance.
-     *
-     * If primary key is not fetched, tries to load by columns with unique constraint.
-     * If there is no unique columns or primary key, throws error
-     */
-    fresh(): Promise<this>;
-    /**
-     * Refresh model from database.
-     *
-     * If no primary key is set, tries to fetch data base on columns
-     * with unique constraints. If none exists, throws exception
-     */
-    refresh(): Promise<void>;
-    /**
-     * Used for JSON serialization
-     */
-    toJSON(): any;
-    driver(): OrmDriver;
-}
-export interface IJunctionProperty {
-    Name: string;
-    Model: Constructor<ModelBase>;
-}
-/**
- * Table column description, used in models to build schema, validate & other stuff
- */
-export interface IColumnDescriptor {
-    /**
-     * Columnt  type eg int, varchar, text
-     */
-    Type: string;
-    /**
-     * Max character lenght handled in column
-     */
-    MaxLength: number;
-    /**
-     * Column comment, use it for documentation purposes.
-     */
-    Comment: string;
-    /**
-     * Default column value
-     */
-    DefaultValue: any;
-    /**
-     * Full database type with size/length info & sign eg. int(10) unsigned if avaible
-     */
-    NativeType: string;
-    /**
-     * Numeric types sign
-     */
-    Unsigned: boolean;
-    /**
-     * Is column nullable (can be null)
-     */
-    Nullable: boolean;
-    /**
-     * Is column primary key
-     */
-    PrimaryKey: boolean;
-    /**
-     * Is column auto increment
-     */
-    AutoIncrement: boolean;
-    /**
-     * Column name
-     */
-    Name: string;
-    /**
-     * Value converter between database & model
-     */
-    Converter: IValueConverter;
-    /**
-     * JSON schema definition build for this column. Used to automate data validation
-     */
-    Schema: any;
-    /**
-     * Does have unique constraint
-     */
-    Unique: boolean;
-    /**
-     * Is uuid generated column
-     */
-    Uuid: boolean;
-    Ignore: boolean;
-    IsForeignKey: boolean;
-    ForeignKeyDescription: {
-        From: string;
-        To: string;
-        Table: string;
-    };
-}
-/**
- * Value converter between model & database data types
- */
-export interface IValueConverter {
-    /**
-     * Converts value to database type
-     *
-     * @param value - value to convert
-     */
-    toDB(value: any, model: ModelBase, options: any): any;
-    /**
-     * Converts value from database type eg. mysql timestamp to DateTime
-     *
-     * @param value - value to convert
-     */
-    fromDB(value: any, rawData: any, options: any): any;
-}
-/**
- * Model timestamps description
- */
-export interface IModelTimestampDescriptor {
-    /**
-     * Created at column name
-     */
-    CreatedAt: string;
-    /**
-     * Updated at column name
-     */
-    UpdatedAt: string;
-}
-/**
- * Model soft delete description
- */
-export interface IModelSoftDeleteDescriptor {
-    /**
-     * Deleted at column name
-     */
-    DeletedAt: string;
-}
-export declare abstract class OrmMigration {
-    /**
-     *
-     * Migrate up - create tables, indices etc.
-     * Be aware that model function are not avaible yet. To fill tables with
-     * data use fill function
-     */
-    abstract up(connection: OrmDriver): Promise<void>;
-    /**
-     * Migrate down - undo changes made in up
-     */
-    abstract down(connection: OrmDriver): Promise<void>;
-}
-/**
- * Model archived description
- */
-export interface IModelArchivedDescriptor {
-    /**
-     * Archived at column name
-     */
-    ArchivedAt: string;
-}
-export interface IQueryLimit {
-    limit?: number;
-    offset?: number;
-}
-export interface ISort {
-    column: string;
-    order: SortOrder;
-}
-export interface IQueryBuilder {
-    Table: string;
-    TableAlias: string;
-    Database: string;
-    database(database: string): IQueryBuilder;
-    from(table: string, alias?: string): this;
-    setAlias(alias: string): this;
-    Driver: OrmDriver;
-    Container: IContainer;
-}
-export interface ILimitBuilder<T> {
-    take(count: number): this;
-    skip(count: number): this;
-    first(): Promise<Unbox<T>>;
-    takeFirst(): this;
-    firstOrFail(): Promise<Unbox<T>>;
-    firstOrThrow(error: Error): Promise<Unbox<T>>;
-    orThrow(error: Error): Promise<Unbox<T>>;
-    getLimits(): IQueryLimit;
-}
-export interface IOrderByBuilder {
-    orderBy(column: string): this;
-    orderByDescending(column: string): this;
-    order(column: string, direction: 'ASC' | 'DESC'): this;
-    getSort(): ISort;
-}
-export interface IColumnsBuilder {
-    /**
-     * clears selected columns
-     */
-    clearColumns(): this;
-    /**
-     *
-     * Select columns from db result ( multiple at once )
-     *
-     * @param names - column names to select
-     */
-    columns(names: string[]): this;
-    /**
-     * Return selected columns in this query
-     */
-    getColumns(): IQueryStatement[];
-    /**
-     * Selects single column from DB result with optional alias
-     * Can be used multiple times
-     *
-     * @param column - column to select
-     * @param alias - column alias ( optional )
-     */
-    select(column: string, alias?: string): this;
-    /**
-     * Selects custom values from DB. eg. Count(*)
-     *
-     * @param rawQuery - raw query to be executed
-     */
-    select(rawQuery: RawQuery): this;
-    /**
-     * Selects multiple columns at once with aliases. Map key property is column name, value is its alias
-     *
-     * @param columns - column list with aliases
-     */
-    select(columns: Map<string, string>): this;
-}
-export interface IWhereBuilder<T> {
-    Statements: IQueryStatement[];
-    Op: WhereBoolean;
-    when(condition: boolean, callback?: WhereFunction<T>, callbackElse?: WhereFunction<T>): this;
-    where(val: boolean): this;
-    where(val: Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>): this;
-    where(func: WhereFunction<T>): this;
-    where(column: string, operator: Op, value: any): this;
-    where(column: string, value: any): this;
-    where(statement: Wrap): this;
-    where(column: string | boolean | WhereFunction<T> | RawQuery | Partial<ModelDataWithRelationDataSearchable<Unbox<T>>> | Wrap, operator?: Op | any, value?: any): this;
-    orWhere(val: boolean): this;
-    orWhere(val: Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>): this;
-    orWhere(func: WhereFunction<T>): this;
-    orWhere(column: string, operator: Op, value: any): this;
-    orWhere(column: string, value: any): this;
-    orWhere(statement: Wrap): this;
-    orWhere(column: string | boolean | WhereFunction<T> | RawQuery | Wrap | Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>, operator?: Op | any, value?: any): this;
-    andWhere(val: boolean): this;
-    andWhere(val: Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>): this;
-    andWhere(func: WhereFunction<T>): this;
-    andWhere(column: string, operator: Op, value: any): this;
-    andWhere(column: string, value: any): this;
-    andWhere(statement: Wrap): this;
-    andWhere(column: string | boolean | WhereFunction<T> | RawQuery | Wrap | Partial<ModelData<Unbox<T>>>, operator?: Op | any, value?: any): this;
-    whereObject(obj: Partial<ModelData<Unbox<T>>>): this;
-    whereNotNull(column: string): this;
-    whereNull(column: string): this;
-    whereNot(column: string, val: unknown): this;
-    whereIn(column: string, val: unknown[]): this;
-    whereNotIn(column: string, val: unknown[]): this;
-    whereExist(query: ISelectQueryBuilder<T>): this;
-    whereNotExists(query: ISelectQueryBuilder<T>): this;
-    whereBetween(column: string, val: unknown[]): this;
-    whereNotBetween(column: string, val: unknown[]): this;
-    whereInSet(column: string, val: unknown[]): this;
-    whereNotInSet(column: string, val: unknown[]): this;
-    clearWhere(): this;
-}
-export interface IWithRecursiveBuilder {
-    CteRecursive: IQueryStatement;
-    withRecursive(recKeyName: string, pkKeyName: string): this;
-}
-export interface IGroupByBuilder {
-    GroupStatements: IQueryStatement[];
-    clearGroupBy(): this;
-    groupBy(expression: RawQuery | string): this;
-}
-/**
- * Dummy abstract class for allowing to add extensions for builder via declaration merging & mixins
- */
-export interface ISelectBuilderExtensions<T> {
-}
-export interface IJoinBuilder {
-    JoinStatements: IQueryStatement[];
-    clearJoins(): this;
-    innerJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    innerJoin(query: RawQuery): this;
-    innerJoin(table: string, foreignKey: string, primaryKey: string): this;
-    innerJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string): this;
-    leftJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    leftJoin(query: RawQuery): this;
-    leftJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
-    leftJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
-    leftOuterJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    leftOuterJoin(query: RawQuery): this;
-    leftOuterJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
-    leftOuterJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
-    rightJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    rightJoin(query: RawQuery): this;
-    rightJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
-    rightJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
-    rightOuterJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    rightOuterJoin(query: RawQuery): this;
-    rightOuterJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
-    rightOuterJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
-    fullOuterJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    fullOuterJoin(query: RawQuery): this;
-    fullOuterJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
-    fullOuterJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
-    crossJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
-    crossJoin(query: RawQuery): this;
-    crossJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
-    crossJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
-}
-export interface IBuilder<T> extends PromiseLike<T> {
-    middleware(middleware: IBuilderMiddleware<T>): this;
-    toDB(): ICompilerOutput | ICompilerOutput[];
-}
-export interface IUpdateQueryBuilder<T> extends IColumnsBuilder, IWhereBuilder<T> {
-}
-export interface IDeleteQueryBuilder<T> extends IWhereBuilder<T>, ILimitBuilder<T> {
-}
-export interface ISelectQueryBuilder<T = unknown> extends IColumnsBuilder, IOrderByBuilder, ILimitBuilder<T>, IWhereBuilder<T>, IJoinBuilder, IWithRecursiveBuilder, IGroupByBuilder, IQueryBuilder, IBuilder<T> {
-    min(column: string, as?: string): this;
-    max(column: string, as?: string): this;
-    count(column: string, as?: string): this;
-    sum(column: string, as?: string): this;
-    avg(column: string, as?: string): this;
-    setAlias(alias: string): this;
-    setTable(table: string, alias?: string): this;
-    distinct(): this;
-    clone(): this;
-    populate<R = this>(relation: {} | null, callback?: (this: ISelectQueryBuilder<R>, relation: IOrmRelation) => void): this;
-    populate<R = this>(relation: string, callback?: (this: ISelectQueryBuilder<R>, relation: IOrmRelation) => void): this;
-    asRaw<T>(): Promise<T>;
-    /**
-     * Returns all records. Its for type castin when using with scopes mostly.
-     */
-    all(): Promise<T[]>;
-}
-export interface ICompilerOutput {
-    expression: string;
-    bindings: any[];
-}
-export interface IQueryCompiler {
-    compile(): ICompilerOutput | ICompilerOutput[];
-}
-export interface ILimitCompiler {
-    limit(builder: ILimitBuilder<any>): ICompilerOutput;
-}
-export interface IGroupByCompiler {
-    group(builder: IGroupByBuilder): ICompilerOutput;
-}
-export interface IRecursiveCompiler {
-    recursive(builder: IWithRecursiveBuilder): ICompilerOutput;
-}
-export interface IColumnsCompiler {
-    columns(builder: IColumnsBuilder): ICompilerOutput;
-}
-export interface IWhereCompiler {
-    where(builder: IWhereBuilder<any>): ICompilerOutput;
-}
-export interface IJoinCompiler {
-    join(builder: IJoinBuilder): ICompilerOutput;
-}
-/**
- *  Definitions of query compiler are needed for DI resolving
- * ==========================================================
- */
-export declare abstract class RecursiveQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class SelectQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class JoinQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class IndexQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class LimitQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class ForeignKeyQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class DeleteQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class UpdateQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class InsertQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class OnDuplicateQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class TableQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput[] | ICompilerOutput;
-}
-export declare abstract class TableHistoryQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput[];
-}
-export declare abstract class TruncateTableQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class TableCloneQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput[];
-}
-export declare abstract class EventQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput[];
-}
-export declare abstract class DropEventQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput[];
-}
-export declare abstract class AlterTableQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput[];
-}
-export declare abstract class TableExistsCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class DropTableCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class ColumnQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class AlterColumnQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class OrderByQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-export declare abstract class GroupByQueryCompiler implements IQueryCompiler {
-    abstract compile(): ICompilerOutput;
-}
-/**
- * ==========================================================
- */
-/**
- * Middlewares for query builders
- */
-export interface IBuilderMiddleware<T = any[]> {
-    /**
-     *
-     * Executed AFTER query is executed in DB and raw data is fetched
-     * Use it to transform DB data before everything else
-     *
-     * @param data - raw data fetched from DB
-     */
-    afterQuery(data: T): T;
-    /**
-     * Executed when model is about to create. Use it to
-     * override model creation logic. If null is returned, default model
-     * is executed
-     *
-     * @param data - raw data to create
-     */
-    modelCreation(data: any): ModelBase;
-    /**
-     * executed after model was created ( all returned data by query is executed)
-     *
-     * @param data - hydrated data. Models are created and hydrated with data
-     */
-    afterHydration(data: ModelBase[]): Promise<any[] | void>;
-}
-export declare abstract class QueryMiddleware {
-    abstract afterQueryCreation(query: QueryBuilder): void;
-    abstract beforeQueryExecution(query: QueryBuilder): void;
-}
-export declare abstract class ModelMiddleware {
-    abstract onDelete(model: ModelBase): Promise<void>;
-    abstract onUpdate(model: ModelBase): Promise<void>;
-    abstract onInsert(model: ModelBase): Promise<void>;
-    abstract onSelect(model: ModelBase): Promise<void>;
-}
-export declare class ValueConverter implements IValueConverter {
-    /**
-     * Converts value to database type
-     *
-     * @param value - value to convert
-     */
-    toDB(_value: any, _model: ModelBase<any>, _options: any): any;
-    /**
-     * Converts value from database type eg. mysql timestamp to DateTime
-     *
-     * @param value - value to convert
-     */
-    fromDB(_value: any, _rawData: any, _options: any): any;
-}
-/**
- * Converter for DATETIME field (eg. mysql datetime)
- */
-export declare class DatetimeValueConverter extends ValueConverter {
-}
-/**
- * Converter for set field (eg. mysql SET)
- */
-export declare class SetValueConverter extends ValueConverter {
-}
-export declare abstract class TableAliasCompiler {
-    abstract compile(builder: QueryBuilder, tbl?: string): string;
-}
-export interface IUniversalConverterOptions {
-    TypeColumn: string;
-}
-/**
- * base class for select & where builder for defining scopes
- */
-export declare abstract class QueryScope {
-}
-export interface IHistoricalModel {
-    readonly __action__: 'insert' | 'update' | 'delete';
-    readonly __revision__: number;
-    readonly __start__: DateTime;
-    readonly __end__: DateTime;
-}
-export declare abstract class ModelToSqlConverter {
-    abstract toSql(model: ModelBase<unknown>): unknown;
-}
-export declare abstract class ObjectToSqlConverter {
-    abstract toSql(model: unknown): unknown;
-}
+import { Op } from './enums.js';
+import { QueryBuilder, RawQuery } from './builders.js';
+import { SortOrder, WhereBoolean } from './enums.js';
+import { IQueryStatement, Wrap } from './statements.js';
+import { ModelData, ModelDataWithRelationData, ModelDataWithRelationDataSearchable, PartialArray, PickRelations, Unbox, WhereFunction } from './types.js';
+import { IOrmRelation } from './relations.js';
+import { OrmDriver } from './driver.js';
+import { Constructor, IContainer } from '@spinajs/di';
+import { ModelBase } from './model.js';
+import { DateTime } from 'luxon';
+import { Relation } from './relation-objects.js';
+export declare enum QueryContext {
+    Insert = 0,
+    Select = 1,
+    Update = 2,
+    Delete = 3,
+    Schema = 4,
+    Transaction = 5
+}
+export declare enum ColumnAlterationType {
+    Add = 0,
+    Modify = 1,
+    Rename = 2
+}
+export interface IRelation {
+    TargetModelDescriptor: IModelDescriptor;
+    /**
+     * Indicates if data was fetched  from db
+     */
+    Populated: boolean;
+}
+export declare abstract class DefaultValueBuilder<T> {
+    Query: RawQuery;
+    Value: string | number;
+    /**
+     * fills by default with current date
+     */
+    abstract date(): T;
+    /**
+     * fills by default with current datetime
+     */
+    abstract dateTime(): T;
+    /**
+     * Fills column with default value
+     *
+     * @param val - value to fill
+     */
+    abstract value(val: string | number): T;
+    /**
+     * Fills column with result of query provided
+     *
+     * @param query - raw query instance
+     */
+    abstract raw(query: RawQuery): T;
+}
+export declare enum InsertBehaviour {
+    /**
+     * Ignores if primary key exists in db
+     */
+    InsertOrIgnore = 0,
+    /**
+     * Updates entry if pk exists
+     */
+    InsertOrUpdate = 1,
+    /**
+     * Replaces entry if pk exists
+     */
+    InsertOrReplace = 2,
+    None = 3
+}
+/**
+ * Foreign key referential actions
+ */
+export declare enum ReferentialAction {
+    Cascade = "CASCADE",
+    SetNull = "SET NULL",
+    Restrict = "RESTRICT",
+    NoAction = "NO ACTION",
+    SetDefault = "SET DEFAULT"
+}
+/**
+ * Transaction mode when migration DB
+ */
+export declare enum MigrationTransactionMode {
+    /**
+     * Migration is run whithout transaction
+     */
+    None = 0,
+    /**
+     * On transaction for one migration - every migration has its own
+     */
+    PerMigration = 1
+}
+/**
+ * Configuration options to set in configuration file and used in OrmDriver
+ */
+export interface IDriverOptions {
+    /**
+     * Max connections limit
+     */
+    PoolLimit?: number;
+    /**
+     * Database name associated with this connection
+     */
+    Database?: string;
+    /**
+     * User associatet with this connection
+     */
+    User?: string;
+    /**
+     * Password to database
+     */
+    Password?: string;
+    /**
+     * DB Host
+     */
+    Host?: string;
+    /**
+     * Connection port
+     */
+    Port?: number;
+    /**
+     * Connection encoding eg. utf-8
+     */
+    Encoding?: string;
+    /**
+     * Database filename eg. for Sqlite driver
+     */
+    Filename?: string;
+    /**
+     * Driver name eg. mysql, sqlite, mssql etc.
+     */
+    Driver: string;
+    /**
+     * Connection name for identification
+     */
+    Name: string;
+    /**
+     * Additional driver-specific options
+     */
+    Options?: any;
+    /**
+     * If this is set, database connection will be made by ssh tunnel
+     */
+    SSH?: {
+        Host: string;
+        Port: number;
+        PrivateKey: string;
+        User: string;
+    };
+    Migration?: {
+        /**
+         * Should run migration on startup
+         */
+        OnStartup?: boolean;
+        /**
+         * Migration table name, if not set default is spinajs_orm_migrations
+         */
+        Table?: string;
+        /**
+         * Migration transaction options
+         */
+        Transaction?: {
+            /**
+             * How to run migration - with or without transaction
+             */
+            Mode?: MigrationTransactionMode;
+        };
+    };
+    /**
+     * When building queries with auto generated tables & fields
+     * we wrap them in special caharacter eg. $
+     * Different sql engines allows different characters,
+     * SQLITE & MYSQL allow to use $ in queries, but MSSQL its special characted used to create pseudocolumn
+     *
+     * Example: SELECT $users$.Name FROM users as $users$
+     */
+    AliasSeparator?: string;
+    /**
+     * Is this connection default. Later can be referenced under 'default' name
+     * eg. @Connection('default')
+     */
+    DefaultConnection?: boolean;
+}
+export interface IMigrationDescriptor {
+    /**
+     * Whitch connection migration will be executed
+     */
+    Connection: string;
+}
+export interface IValueConverterDescriptor {
+    Class: Constructor<ValueConverter>;
+    Options?: any;
+}
+/**
+ * Describes model, used internally
+ */
+export interface IModelDescriptor {
+    /**
+     * Primary key name
+     */
+    PrimaryKey: string;
+    /**
+     * Connection name, must be avaible in db config
+     */
+    Connection: string;
+    /**
+     * Table name in database for this model
+     */
+    TableName: string;
+    /**
+     * Optional, describes timestamps in model
+     */
+    Timestamps: IModelTimestampDescriptor;
+    /**
+     * Optional, describes soft delete
+     */
+    SoftDelete: IModelSoftDeleteDescriptor;
+    /**
+     * Optional, is archive mode enabled
+     */
+    Archived: IModelArchivedDescriptor;
+    /**
+     * Column  / fields list in model
+     */
+    Columns: IColumnDescriptor[];
+    /**
+     * Converters attached to fields
+     */
+    Converters: Map<string, IValueConverterDescriptor>;
+    /**
+     * List of unique columns ( UNIQUE constraint )
+     */
+    JunctionModelProperties: IJunctionProperty[];
+    /**
+     * List of relations in model
+     */
+    Relations: Map<string, IRelationDescriptor>;
+    /** Name of model */
+    Name: string;
+    /**
+     * Model discrimination map that  allows to create different models based on db field value
+     */
+    DiscriminationMap: IDiscriminationMap;
+    /**
+     * Orm driver that this model
+     */
+    Driver: OrmDriver;
+    /**
+     * Json schema for validation
+     */
+    Schema: any;
+}
+export interface IDiscriminationMap {
+    /**
+     * DB field that holds inheritance value
+     */
+    Field: string;
+    /**
+     * Field values mapped for proper models
+     */
+    Models: Map<string, Constructor<ModelBase>>;
+}
+export interface IDiscriminationEntry {
+    Key: string;
+    Value: Constructor<ModelBase>;
+}
+export declare enum RelationType {
+    One = 0,
+    Many = 1,
+    ManyToMany = 2
+}
+export type ForwardRefFunction = () => Constructor<ModelBase>;
+/**
+ * Returns result of last insert or affected rows ( eg. rows affected would be 0 if insert is ignored )
+ */
+export interface IUpdateResult {
+    RowsAffected: number;
+    LastInsertId: number;
+}
+export interface IRelationDescriptor {
+    /**
+     * Name of relations, defaults for property name in model that owns relation
+     */
+    Name: string;
+    /**
+     * Is it one-to-one, one-to-many or many-to-many
+     */
+    Type: RelationType;
+    TargetModelType: Constructor<ModelBase> | ForwardRefFunction | string;
+    /**
+     * Relation model (  foreign )
+     */
+    TargetModel: Constructor<ModelBase> & IModelStatic;
+    /**
+     * Relation owner
+     */
+    SourceModel: Constructor<ModelBase> & IModelStatic;
+    /**
+     * Relation foreign key (one to one, one to many)
+     */
+    ForeignKey: string;
+    /**
+     * Relation primary key (one to one, one to many)
+     */
+    PrimaryKey: string;
+    /**
+     * Used in many to many relations, model for join table
+     */
+    JunctionModel?: Constructor<ModelBase>;
+    /**
+     * Join table foreign keys, defaults to auto generated field names. Can be override.
+     */
+    JunctionModelTargetModelFKey_Name?: string;
+    JunctionModelSourceModelFKey_Name?: string;
+    /**
+     * Is this relation recursive ? Used for hierarchical / paren one-to-one relations
+     */
+    Recursive: boolean;
+    /**
+     * Relation factory, sometimes we dont want to create standard relation object
+     */
+    Factory?: (model: ModelBase<unknown>, relation: IRelationDescriptor, container: IContainer) => Relation<ModelBase<unknown>, ModelBase<unknown>>;
+    /**
+     *  sometimes we dont want to create standard relation object, so we create type
+     *  that is passed in this property
+     */
+    RelationClass?: Constructor<Relation<ModelBase<unknown>, ModelBase<unknown>>>;
+}
+export interface IModelStatic extends Constructor<ModelBase<unknown>> {
+    where<T extends typeof ModelBase>(val: boolean): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(val: PartialArray<InstanceType<T>> | PickRelations<T>): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(func: WhereFunction<InstanceType<T>>): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(column: string, operator: Op, value: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(column: string, value: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(statement: Wrap): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(column: string | boolean | WhereFunction<InstanceType<T>> | RawQuery | PartialArray<InstanceType<T>> | Wrap | PickRelations<T>, operator?: Op | any, value?: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    where<T extends typeof ModelBase>(column: string | boolean | WhereFunction<InstanceType<T>> | RawQuery | PartialArray<InstanceType<T>> | Wrap | PickRelations<T>, _operator?: Op | any, _value?: any): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    destroy<T extends typeof ModelBase>(pk?: any | any[]): IDeleteQueryBuilder<InstanceType<T>> & Promise<IUpdateResult>;
+    create<T extends typeof ModelBase>(data: Partial<InstanceType<T>>): Promise<InstanceType<T>>;
+    query<T extends typeof ModelBase>(): ISelectQueryBuilder<Array<InstanceType<T>>>;
+    count<T extends typeof ModelBase>(callback?: (builder: IWhereBuilder<T>) => void): Promise<number>;
+    count(): Promise<number>;
+    update<T extends typeof ModelBase>(data: Partial<InstanceType<T>>): IUpdateQueryBuilder<InstanceType<T>>;
+    exists(pk: any): Promise<boolean>;
+    get<T extends typeof ModelBase>(pk: any): Promise<InstanceType<T>>;
+    insert<T extends typeof ModelBase>(data: InstanceType<T> | Partial<InstanceType<T>> | Array<InstanceType<T>> | Array<Partial<InstanceType<T>>>, insertBehaviour?: InsertBehaviour): Promise<IUpdateResult>;
+    getModelDescriptor(): IModelDescriptor;
+    getRelationDescriptor(relation: string): IRelationDescriptor;
+}
+export interface IModelBase {
+    ModelDescriptor: IModelDescriptor;
+    Container: IContainer;
+    PrimaryKeyName: string;
+    PrimaryKeyValue: any;
+    getFlattenRelationModels(): IModelBase[];
+    /**
+     * Fills model with data. It only fills properties that exists in database
+     *
+     * @param data - data to fill
+     */
+    hydrate(data: Partial<this>): void;
+    /**
+     *
+     * Attachess model to proper relation an sets foreign key
+     *
+     * @param data - model to attach
+     */
+    attach(data: ModelBase): void;
+    /**
+     * Extracts all data from model. It takes only properties that exists in DB. Does not dehydrate related data.
+     *
+     * @param omit - fields to omit
+     */
+    dehydrate(omit?: string[]): ModelData<this>;
+    /**
+     *
+     * Extracts all data from model with relation data. Relation data are dehydrated recursively.
+     *
+     * @param omit - fields to omit
+     */
+    dehydrateWithRelations(omit?: string[]): ModelDataWithRelationData<this>;
+    /**
+     * deletes enitt from db. If model have SoftDelete decorator, model is marked as deleted
+     */
+    destroy(): Promise<void>;
+    /**
+     * If model can be in achived state - sets archived at date and saves it to db
+     */
+    archive(): Promise<void>;
+    /**
+     * Updates model to db
+     */
+    update(): Promise<void>;
+    /**
+     * Save all changes to db. It creates new entry id db or updates existing one if
+     * primary key exists
+     */
+    insert(insertBehaviour: InsertBehaviour): Promise<IUpdateResult>;
+    /**
+     * Gets model data from database and returns as fresh instance.
+     *
+     * If primary key is not fetched, tries to load by columns with unique constraint.
+     * If there is no unique columns or primary key, throws error
+     */
+    fresh(): Promise<this>;
+    /**
+     * Refresh model from database.
+     *
+     * If no primary key is set, tries to fetch data base on columns
+     * with unique constraints. If none exists, throws exception
+     */
+    refresh(): Promise<void>;
+    /**
+     * Used for JSON serialization
+     */
+    toJSON(): any;
+    driver(): OrmDriver;
+}
+export interface IJunctionProperty {
+    Name: string;
+    Model: Constructor<ModelBase>;
+}
+/**
+ * Table column description, used in models to build schema, validate & other stuff
+ */
+export interface IColumnDescriptor {
+    /**
+     * Columnt  type eg int, varchar, text
+     */
+    Type: string;
+    /**
+     * Max character lenght handled in column
+     */
+    MaxLength: number;
+    /**
+     * Column comment, use it for documentation purposes.
+     */
+    Comment: string;
+    /**
+     * Default column value
+     */
+    DefaultValue: any;
+    /**
+     * Full database type with size/length info & sign eg. int(10) unsigned if avaible
+     */
+    NativeType: string;
+    /**
+     * Numeric types sign
+     */
+    Unsigned: boolean;
+    /**
+     * Is column nullable (can be null)
+     */
+    Nullable: boolean;
+    /**
+     * Is column primary key
+     */
+    PrimaryKey: boolean;
+    /**
+     * Is column auto increment
+     */
+    AutoIncrement: boolean;
+    /**
+     * Column name
+     */
+    Name: string;
+    /**
+     * Value converter between database & model
+     */
+    Converter: IValueConverter;
+    /**
+     * JSON schema definition build for this column. Used to automate data validation
+     */
+    Schema: any;
+    /**
+     * Does have unique constraint
+     */
+    Unique: boolean;
+    /**
+     * Is uuid generated column
+     */
+    Uuid: boolean;
+    Ignore: boolean;
+    IsForeignKey: boolean;
+    ForeignKeyDescription: {
+        From: string;
+        To: string;
+        Table: string;
+    };
+}
+/**
+ * Value converter between model & database data types
+ */
+export interface IValueConverter {
+    /**
+     * Converts value to database type
+     *
+     * @param value - value to convert
+     */
+    toDB(value: any, model: ModelBase, options: any): any;
+    /**
+     * Converts value from database type eg. mysql timestamp to DateTime
+     *
+     * @param value - value to convert
+     */
+    fromDB(value: any, rawData: any, options: any): any;
+}
+/**
+ * Model timestamps description
+ */
+export interface IModelTimestampDescriptor {
+    /**
+     * Created at column name
+     */
+    CreatedAt: string;
+    /**
+     * Updated at column name
+     */
+    UpdatedAt: string;
+}
+/**
+ * Model soft delete description
+ */
+export interface IModelSoftDeleteDescriptor {
+    /**
+     * Deleted at column name
+     */
+    DeletedAt: string;
+}
+export declare abstract class OrmMigration {
+    /**
+     *
+     * Migrate up - create tables, indices etc.
+     * Be aware that model function are not avaible yet. To fill tables with
+     * data use fill function
+     */
+    abstract up(connection: OrmDriver): Promise<void>;
+    /**
+     * Migrate down - undo changes made in up
+     */
+    abstract down(connection: OrmDriver): Promise<void>;
+}
+/**
+ * Model archived description
+ */
+export interface IModelArchivedDescriptor {
+    /**
+     * Archived at column name
+     */
+    ArchivedAt: string;
+}
+export interface IQueryLimit {
+    limit?: number;
+    offset?: number;
+}
+export interface ISort {
+    column: string;
+    order: SortOrder;
+}
+export interface IQueryBuilder {
+    Table: string;
+    TableAlias: string;
+    Database: string;
+    database(database: string): IQueryBuilder;
+    from(table: string, alias?: string): this;
+    setAlias(alias: string): this;
+    Driver: OrmDriver;
+    Container: IContainer;
+}
+export interface ILimitBuilder<T> {
+    take(count: number): this;
+    skip(count: number): this;
+    first(): Promise<Unbox<T>>;
+    takeFirst(): this;
+    firstOrFail(): Promise<Unbox<T>>;
+    firstOrThrow(error: Error): Promise<Unbox<T>>;
+    orThrow(error: Error): Promise<Unbox<T>>;
+    getLimits(): IQueryLimit;
+}
+export interface IOrderByBuilder {
+    orderBy(column: string): this;
+    orderByDescending(column: string): this;
+    order(column: string, direction: 'ASC' | 'DESC'): this;
+    getSort(): ISort;
+}
+export interface IColumnsBuilder {
+    /**
+     * clears selected columns
+     */
+    clearColumns(): this;
+    /**
+     *
+     * Select columns from db result ( multiple at once )
+     *
+     * @param names - column names to select
+     */
+    columns(names: string[]): this;
+    /**
+     * Return selected columns in this query
+     */
+    getColumns(): IQueryStatement[];
+    /**
+     * Selects single column from DB result with optional alias
+     * Can be used multiple times
+     *
+     * @param column - column to select
+     * @param alias - column alias ( optional )
+     */
+    select(column: string, alias?: string): this;
+    /**
+     * Selects custom values from DB. eg. Count(*)
+     *
+     * @param rawQuery - raw query to be executed
+     */
+    select(rawQuery: RawQuery): this;
+    /**
+     * Selects multiple columns at once with aliases. Map key property is column name, value is its alias
+     *
+     * @param columns - column list with aliases
+     */
+    select(columns: Map<string, string>): this;
+}
+export interface IWhereBuilder<T> {
+    Statements: IQueryStatement[];
+    Op: WhereBoolean;
+    when(condition: boolean, callback?: WhereFunction<T>, callbackElse?: WhereFunction<T>): this;
+    where(val: boolean): this;
+    where(val: Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>): this;
+    where(func: WhereFunction<T>): this;
+    where(column: string, operator: Op, value: any): this;
+    where(column: string, value: any): this;
+    where(statement: Wrap): this;
+    where(column: string | boolean | WhereFunction<T> | RawQuery | Partial<ModelDataWithRelationDataSearchable<Unbox<T>>> | Wrap, operator?: Op | any, value?: any): this;
+    orWhere(val: boolean): this;
+    orWhere(val: Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>): this;
+    orWhere(func: WhereFunction<T>): this;
+    orWhere(column: string, operator: Op, value: any): this;
+    orWhere(column: string, value: any): this;
+    orWhere(statement: Wrap): this;
+    orWhere(column: string | boolean | WhereFunction<T> | RawQuery | Wrap | Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>, operator?: Op | any, value?: any): this;
+    andWhere(val: boolean): this;
+    andWhere(val: Partial<ModelDataWithRelationDataSearchable<Unbox<T>>>): this;
+    andWhere(func: WhereFunction<T>): this;
+    andWhere(column: string, operator: Op, value: any): this;
+    andWhere(column: string, value: any): this;
+    andWhere(statement: Wrap): this;
+    andWhere(column: string | boolean | WhereFunction<T> | RawQuery | Wrap | Partial<ModelData<Unbox<T>>>, operator?: Op | any, value?: any): this;
+    whereObject(obj: Partial<ModelData<Unbox<T>>>): this;
+    whereNotNull(column: string): this;
+    whereNull(column: string): this;
+    whereNot(column: string, val: unknown): this;
+    whereIn(column: string, val: unknown[]): this;
+    whereNotIn(column: string, val: unknown[]): this;
+    whereExist(query: ISelectQueryBuilder<T>): this;
+    whereNotExists(query: ISelectQueryBuilder<T>): this;
+    whereBetween(column: string, val: unknown[]): this;
+    whereNotBetween(column: string, val: unknown[]): this;
+    whereInSet(column: string, val: unknown[]): this;
+    whereNotInSet(column: string, val: unknown[]): this;
+    clearWhere(): this;
+}
+export interface IWithRecursiveBuilder {
+    CteRecursive: IQueryStatement;
+    withRecursive(recKeyName: string, pkKeyName: string): this;
+}
+export interface IGroupByBuilder {
+    GroupStatements: IQueryStatement[];
+    clearGroupBy(): this;
+    groupBy(expression: RawQuery | string): this;
+}
+/**
+ * Dummy abstract class for allowing to add extensions for builder via declaration merging & mixins
+ */
+export interface ISelectBuilderExtensions<T> {
+}
+export interface IJoinBuilder {
+    JoinStatements: IQueryStatement[];
+    clearJoins(): this;
+    innerJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    innerJoin(query: RawQuery): this;
+    innerJoin(table: string, foreignKey: string, primaryKey: string): this;
+    innerJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string): this;
+    leftJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    leftJoin(query: RawQuery): this;
+    leftJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
+    leftJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
+    leftOuterJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    leftOuterJoin(query: RawQuery): this;
+    leftOuterJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
+    leftOuterJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
+    rightJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    rightJoin(query: RawQuery): this;
+    rightJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
+    rightJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
+    rightOuterJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    rightOuterJoin(query: RawQuery): this;
+    rightOuterJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
+    rightOuterJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
+    fullOuterJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    fullOuterJoin(query: RawQuery): this;
+    fullOuterJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
+    fullOuterJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
+    crossJoin<M extends ModelBase>(model: Constructor<M>, where?: (this: ISelectQueryBuilder<M>) => void): this;
+    crossJoin(query: RawQuery): this;
+    crossJoin(table: string, foreignKey: string, primaryKey: string, database?: string): this;
+    crossJoin(table: string, tableAlias: string, foreignKey: string, primaryKey: string, database?: string): this;
+}
+export interface IBuilder<T> extends PromiseLike<T> {
+    middleware(middleware: IBuilderMiddleware<T>): this;
+    toDB(): ICompilerOutput | ICompilerOutput[];
+}
+export interface IUpdateQueryBuilder<T> extends IColumnsBuilder, IWhereBuilder<T> {
+}
+export interface IDeleteQueryBuilder<T> extends IWhereBuilder<T>, ILimitBuilder<T> {
+}
+export interface ISelectQueryBuilder<T = unknown> extends IColumnsBuilder, IOrderByBuilder, ILimitBuilder<T>, IWhereBuilder<T>, IJoinBuilder, IWithRecursiveBuilder, IGroupByBuilder, IQueryBuilder, IBuilder<T> {
+    min(column: string, as?: string): this;
+    max(column: string, as?: string): this;
+    count(column: string, as?: string): this;
+    sum(column: string, as?: string): this;
+    avg(column: string, as?: string): this;
+    setAlias(alias: string): this;
+    setTable(table: string, alias?: string): this;
+    distinct(): this;
+    clone(): this;
+    populate<R = this>(relation: {} | null, callback?: (this: ISelectQueryBuilder<R>, relation: IOrmRelation) => void): this;
+    populate<R = this>(relation: string, callback?: (this: ISelectQueryBuilder<R>, relation: IOrmRelation) => void): this;
+    asRaw<T>(): Promise<T>;
+    /**
+     * Returns all records. Its for type castin when using with scopes mostly.
+     */
+    all(): Promise<T[]>;
+}
+export interface ICompilerOutput {
+    expression: string;
+    bindings: any[];
+}
+export interface IQueryCompiler {
+    compile(): ICompilerOutput | ICompilerOutput[];
+}
+export interface ILimitCompiler {
+    limit(builder: ILimitBuilder<any>): ICompilerOutput;
+}
+export interface IGroupByCompiler {
+    group(builder: IGroupByBuilder): ICompilerOutput;
+}
+export interface IRecursiveCompiler {
+    recursive(builder: IWithRecursiveBuilder): ICompilerOutput;
+}
+export interface IColumnsCompiler {
+    columns(builder: IColumnsBuilder): ICompilerOutput;
+}
+export interface IWhereCompiler {
+    where(builder: IWhereBuilder<any>): ICompilerOutput;
+}
+export interface IJoinCompiler {
+    join(builder: IJoinBuilder): ICompilerOutput;
+}
+/**
+ *  Definitions of query compiler are needed for DI resolving
+ * ==========================================================
+ */
+export declare abstract class RecursiveQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class SelectQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class JoinQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class IndexQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class LimitQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class ForeignKeyQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class DeleteQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class UpdateQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class InsertQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class OnDuplicateQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class TableQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput[] | ICompilerOutput;
+}
+export declare abstract class TableHistoryQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput[];
+}
+export declare abstract class TruncateTableQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class TableCloneQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput[];
+}
+export declare abstract class EventQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput[];
+}
+export declare abstract class DropEventQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput[];
+}
+export declare abstract class AlterTableQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput[];
+}
+export declare abstract class TableExistsCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class DropTableCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class ColumnQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class AlterColumnQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class OrderByQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+export declare abstract class GroupByQueryCompiler implements IQueryCompiler {
+    abstract compile(): ICompilerOutput;
+}
+/**
+ * ==========================================================
+ */
+/**
+ * Middlewares for query builders
+ */
+export interface IBuilderMiddleware<T = any[]> {
+    /**
+     *
+     * Executed AFTER query is executed in DB and raw data is fetched
+     * Use it to transform DB data before everything else
+     *
+     * @param data - raw data fetched from DB
+     */
+    afterQuery(data: T): T;
+    /**
+     * Executed when model is about to create. Use it to
+     * override model creation logic. If null is returned, default model
+     * is executed
+     *
+     * @param data - raw data to create
+     */
+    modelCreation(data: any): ModelBase;
+    /**
+     * executed after model was created ( all returned data by query is executed)
+     *
+     * @param data - hydrated data. Models are created and hydrated with data
+     */
+    afterHydration(data: ModelBase[]): Promise<any[] | void>;
+}
+export declare abstract class QueryMiddleware {
+    abstract afterQueryCreation(query: QueryBuilder): void;
+    abstract beforeQueryExecution(query: QueryBuilder): void;
+}
+export declare abstract class ModelMiddleware {
+    abstract onDelete(model: ModelBase): Promise<void>;
+    abstract onUpdate(model: ModelBase): Promise<void>;
+    abstract onInsert(model: ModelBase): Promise<void>;
+    abstract onSelect(model: ModelBase): Promise<void>;
+}
+export declare class ValueConverter implements IValueConverter {
+    /**
+     * Converts value to database type
+     *
+     * @param value - value to convert
+     */
+    toDB(_value: any, _model: ModelBase<any>, _options: any): any;
+    /**
+     * Converts value from database type eg. mysql timestamp to DateTime
+     *
+     * @param value - value to convert
+     */
+    fromDB(_value: any, _rawData: any, _options: any): any;
+}
+/**
+ * Converter for DATETIME field (eg. mysql datetime)
+ */
+export declare class DatetimeValueConverter extends ValueConverter {
+}
+/**
+ * Converter for set field (eg. mysql SET)
+ */
+export declare class SetValueConverter extends ValueConverter {
+}
+export declare abstract class TableAliasCompiler {
+    abstract compile(builder: QueryBuilder, tbl?: string): string;
+}
+export interface IUniversalConverterOptions {
+    TypeColumn: string;
+}
+/**
+ * base class for select & where builder for defining scopes
+ */
+export declare abstract class QueryScope {
+}
+export interface IHistoricalModel {
+    readonly __action__: 'insert' | 'update' | 'delete';
+    readonly __revision__: number;
+    readonly __start__: DateTime;
+    readonly __end__: DateTime;
+}
+export declare abstract class ModelToSqlConverter {
+    abstract toSql(model: ModelBase<unknown>): unknown;
+}
+export declare abstract class ObjectToSqlConverter {
+    abstract toSql(model: unknown): unknown;
+}
 //# sourceMappingURL=interfaces.d.ts.map