@h3ravel/arquebus 0.1.6 → 0.2.1

package/dist/index.d.ts

@@ -1,334 +1,968 @@
-import Knex from 'knex';
-import { Collection as Collection$1 } from 'collect.js';
+import { Collection as Collection$2 } from 'collect.js';
+import Knex$1, { Knex } from 'knex';
 
-declare class ModelNotFoundError extends BaseError {
-    model: any;
-    ids: any;
-    setModel(model: any, ids?: any[]): this;
-    getModel(): any;
-    getIds(): any;
+declare class Collection$1<I extends Model$2 | Model$1> extends Collection$2<I> implements ICollection<I> {
+    private newConstructor;
+    getConstructor<T extends typeof Collection$1<I>>(this: InstanceType<T>): T;
+    load(...relations: I[]): Promise<Collection$1<I>>;
+    loadAggregate<I>(relations: I, column: string, action?: string | null | TFunction): Promise<this>;
+    loadCount(relations: I): Promise<this>;
+    loadMax(relation: I, column: string): Promise<this>;
+    loadMin(relation: I, column: string): Promise<this>;
+    loadSum(relation: I, column: string): Promise<this>;
+    loadAvg(relation: I, column: string): Promise<this>;
+    mapThen(callback: () => void): Promise<void[]>;
+    modelKeys(): any[];
+    contains<K, V>(key: keyof I | K | TFunction, value?: V): boolean;
+    diff(items: ICollection<any> | any[]): any;
+    except(keys: any[]): any;
+    intersect(items: I[]): any;
+    unique(key?: TFunction | keyof I, _strict?: boolean): any;
+    find(key: any, defaultValue?: null): any;
+    fresh(...args: any[]): Promise<any>;
+    makeVisible(attributes: any): this;
+    makeHidden(attributes: any): this;
+    append(attributes: any): this;
+    only(keys: any[]): any;
+    getDictionary(items?: ICollection<any> | any[]): TGeneric;
+    toQuery(): any;
+    toData(): (I | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    })[];
+    toJSON(): (I | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    })[];
+    toJson(...args: any[]): string;
+    [Symbol.iterator]: () => Iterator<I>;
 }
-declare class RelationNotFoundError extends BaseError {
+
+interface SchemaBuilder extends Knex.SchemaBuilder {
+    [k: string]: any;
 }
-declare class InvalidArgumentError extends BaseError {
+interface AsMethod<QB extends AnyQueryBuilder> {
+    (alias: string): QB;
 }
-declare class BaseError extends Error {
-    constructor(message: any, entity: any);
-    message: any;
+interface IStatement {
+    grouping: string;
+    direction: string;
+    type: string;
+    value: () => any;
+    not: boolean;
+    nulls: boolean;
+    bool: 'and' | 'or' | 'not';
+}
+interface IQueryBuilder<M extends Model$2 | Model$1 = Model$2, R = M[] | M> {
+    schema: SchemaBuilder;
+    _statements: IStatement[];
+    table(name: string): IQueryBuilder<M, R>;
+    select: SelectMethod<this>;
+    columns: SelectMethod<this>;
+    column: SelectMethod<this>;
+    distinct: SelectMethod<this>;
+    distinctOn: SelectMethod<this>;
+    as: AsMethod<this>;
+    asProxy(): IQueryBuilder<M, R>;
+    where: WhereMethod<this>;
+    andWhere: WhereMethod<this>;
+    orWhere(...args: any[]): this;
+    whereNot: WhereMethod<this>;
+    andWhereNot: WhereMethod<this>;
+    orWhereNot: WhereMethod<this>;
+    whereRaw: WhereRawMethod<this>;
+    orWhereRaw: WhereRawMethod<this>;
+    andWhereRaw: WhereRawMethod<this>;
+    whereWrapped: WhereWrappedMethod<this>;
+    havingWrapped: WhereWrappedMethod<this>;
+    whereExists: WhereExistsMethod<this>;
+    orWhereExists: WhereExistsMethod<this>;
+    whereNotExists: WhereExistsMethod<this>;
+    orWhereNotExists: WhereExistsMethod<this>;
+    whereIn: WhereInMethod<this>;
+    orWhereIn: WhereInMethod<this>;
+    whereNotIn: WhereInMethod<this>;
+    orWhereNotIn: WhereInMethod<this>;
+    whereBetween: WhereBetweenMethod<this>;
+    orWhereBetween: WhereBetweenMethod<this>;
+    andWhereBetween: WhereBetweenMethod<this>;
+    whereNotBetween: WhereBetweenMethod<this>;
+    orWhereNotBetween: WhereBetweenMethod<this>;
+    andWhereNotBetween: WhereBetweenMethod<this>;
+    whereNull: WhereNullMethod<this>;
+    orWhereNull: WhereNullMethod<this>;
+    whereNotNull: WhereNullMethod<this>;
+    orWhereNotNull: WhereNullMethod<this>;
+    whereColumn: WhereColumnMethod<this>;
+    orWhereColumn: WhereColumnMethod<this>;
+    andWhereColumn: WhereColumnMethod<this>;
+    whereNotColumn: WhereColumnMethod<this>;
+    orWhereNotColumn: WhereColumnMethod<this>;
+    andWhereNotColumn: WhereColumnMethod<this>;
+    whereJsonIsArray: WhereFieldExpressionMethod<this>;
+    orWhereJsonIsArray: WhereFieldExpressionMethod<this>;
+    whereJsonNotArray: WhereFieldExpressionMethod<this>;
+    orWhereJsonNotArray: WhereFieldExpressionMethod<this>;
+    whereJsonIsObject: WhereFieldExpressionMethod<this>;
+    orWhereJsonIsObject: WhereFieldExpressionMethod<this>;
+    whereJsonNotObject: WhereFieldExpressionMethod<this>;
+    orWhereJsonNotObject: WhereFieldExpressionMethod<this>;
+    whereJsonHasAny: WhereJsonExpressionMethod<this>;
+    orWhereJsonHasAny: WhereJsonExpressionMethod<this>;
+    whereJsonHasAll: WhereJsonExpressionMethod<this>;
+    orWhereJsonHasAll: WhereJsonExpressionMethod<this>;
+    having: WhereMethod<this>;
+    andHaving: WhereMethod<this>;
+    orHaving: WhereMethod<this>;
+    havingRaw: WhereRawMethod<this>;
+    orHavingRaw: WhereRawMethod<this>;
+    havingIn: WhereInMethod<this>;
+    orHavingIn: WhereInMethod<this>;
+    havingNotIn: WhereInMethod<this>;
+    orHavingNotIn: WhereInMethod<this>;
+    havingNull: WhereNullMethod<this>;
+    orHavingNull: WhereNullMethod<this>;
+    havingNotNull: WhereNullMethod<this>;
+    orHavingNotNull: WhereNullMethod<this>;
+    havingExists: WhereExistsMethod<this>;
+    orHavingExists: WhereExistsMethod<this>;
+    havingNotExists: WhereExistsMethod<this>;
+    orHavingNotExists: WhereExistsMethod<this>;
+    havingBetween: WhereBetweenMethod<this>;
+    orHavingBetween: WhereBetweenMethod<this>;
+    havingNotBetween: WhereBetweenMethod<this>;
+    orHavingNotBetween: WhereBetweenMethod<this>;
+    union: UnionMethod<this>;
+    unionAll: UnionMethod<this>;
+    intersect: SetOperationsMethod<this>;
+    join: JoinMethod<this>;
+    joinRaw: JoinRawMethod<this>;
+    innerJoin: JoinMethod<this>;
+    leftJoin: JoinMethod<this>;
+    leftOuterJoin: JoinMethod<this>;
+    rightJoin: JoinMethod<this>;
+    rightOuterJoin: JoinMethod<this>;
+    outerJoin: JoinMethod<this>;
+    fullOuterJoin: JoinMethod<this>;
+    crossJoin: JoinMethod<this>;
+    orderBy: OrderByMethod<this>;
+    orderByRaw: OrderByRawMethod<this>;
+    groupBy: GroupByMethod<this>;
+    groupByRaw: RawInterface<this>;
+    transaction(callback?: TFunction): Promise<Knex.Transaction> | undefined;
+    destroy(callback: TFunction): Promise<number>;
+    destroy(): Promise<number>;
+    clone(): IQueryBuilder<M, R>;
+    raw: Knex.RawQueryBuilder<TGeneric, M>;
+    get(columns?: string[]): Promise<any>;
+    first(columns?: string[]): Promise<M | null | undefined>;
+    find(key: string | number, columns?: string[]): Promise<M | null | undefined>;
+    insert(attributes: any): Promise<unknown>;
+    update(...attributes: any[]): Promise<number>;
+    delete(): Promise<boolean | number>;
+    exists(): Promise<boolean>;
+    count(column?: string): Promise<number>;
+    min(column: string): Promise<number>;
+    max(column: string): Promise<number>;
+    sum(column: string): Promise<number>;
+    avg(column: string): Promise<number>;
+    skip(count: number): this;
+    take(count: number): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    pluck<X extends Model$2 = any>(column: string): Promise<ICollection<X>>;
+    chunk(count: number, callback: (rows: M[]) => any): Promise<boolean>;
+    forPage(page: number, perPage?: number): this;
+    paginate<F extends IPaginatorParams>(page?: number, perPage?: number): Promise<IPaginator<M, F>>;
 }
 
-/**
- * Compose functional mixins
- *
- * @param Base
- * @param mixins
- * @returns
- */
-declare function compose(Base: any, ...mixins: any[]): any;
-declare function now(format?: string): string;
-declare function getRelationName(relationMethod: any): string;
-declare function getScopeName(scopeMethod: any): string;
-declare function getRelationMethod(relation: any): string;
-declare function getScopeMethod(scope: any): string;
-declare function getAttrMethod(attr: any): string;
-declare function getGetterMethod(attr: any): string;
-declare function getSetterMethod(attr: any): string;
-declare function getAttrName(attrMethod: any): any;
-declare function tap(instance: any, callback: any): any;
-declare function flattenDeep(arr: any): any;
-declare function kebabCase(str: any): string;
-declare function snakeCase(str: any): string;
+type Operator = string;
+type ColumnRef = string | Raw;
+type FieldExpression = string;
+type TableRef<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
+type Selection<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
+type QBOrCallback<QB extends AnyQueryBuilder> = AnyQueryBuilder | CallbackVoid<QB>;
+interface CallbackVoid<T> {
+    (this: T, arg: T): void;
+}
+type Raw = Knex.Raw;
+type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
+interface OrderByDescriptor {
+    column: ColumnRef;
+    order?: OrderByDirection;
+}
+type AnyQueryBuilder<M extends Model$2 = any, R = any> = IQueryBuilder<M, R> | IBuilder<M, R>;
+type Expression<T> = T | Raw | AnyQueryBuilder;
+type ColumnRefOrOrderByDescriptor = ColumnRef | OrderByDescriptor;
+interface RawInterface<R> {
+    (sql: string, ...bindings: any[]): R;
+}
+interface BaseSetOperations<QB extends AnyQueryBuilder> {
+    (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB;
+    (callbacksOrBuilders: QBOrCallback<QB>[], wrap?: boolean): QB;
+}
+type JoinRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {};
+type OrderByRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {};
+type WhereRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {};
+interface GroupByMethod<QB extends AnyQueryBuilder> {
+    (...columns: ColumnRef[]): QB;
+    (columns: ColumnRef[]): QB;
+}
+type WithRelationType = {
+    [key: string]: <T extends IBuilder<any>>(builder: T) => T | void;
+} | string | string[];
+interface SetOperationsMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
+    (...callbacksOrBuilders: QBOrCallback<QB>[]): QB;
+}
+interface SelectMethod<QB extends AnyQueryBuilder> {
+    <QBP extends QB>(...columns: Selection<QBP>[]): QB;
+    <QBP extends QB>(columns: Selection<QBP>[]): QB;
+}
+interface WhereMethod<QB extends AnyQueryBuilder> {
+    (col: ColumnRef, op: Operator, expr: Expression<PrimitiveValue>): QB;
+    (col: ColumnRef, expr: Expression<PrimitiveValue>): QB;
+    (condition: boolean): QB;
+    (cb: CallbackVoid<QB>): QB;
+    (raw: Raw): QB;
+    <QBA extends AnyQueryBuilder>(qb: QBA): QB;
+    (obj: object): QB;
+}
+interface WhereWrappedMethod<QB extends AnyQueryBuilder> {
+    (cb: CallbackVoid<QB>): QB;
+}
+interface WhereFieldExpressionMethod<QB extends AnyQueryBuilder> {
+    (fieldExpression: FieldExpression): QB;
+}
+interface WhereExistsMethod<QB extends AnyQueryBuilder> {
+    (cb: CallbackVoid<QB>): QB;
+    (raw: Raw): QB;
+    <QBA extends AnyQueryBuilder>(qb: QBA): QB;
+}
+interface WhereInMethod<QB extends AnyQueryBuilder> {
+    (col: ColumnRef | ColumnRef[], expr: Expression<PrimitiveValue>[]): QB;
+    (col: ColumnRef | ColumnRef[], cb: CallbackVoid<QB>): QB;
+    (col: ColumnRef | ColumnRef[], qb: AnyQueryBuilder): QB;
+}
+interface WhereBetweenMethod<QB extends AnyQueryBuilder> {
+    (column: ColumnRef, range: [Expression<PrimitiveValue>, Expression<PrimitiveValue>]): QB;
+}
+interface WhereNullMethod<QB extends AnyQueryBuilder> {
+    (column: ColumnRef): QB;
+}
+interface OrderByMethod<QB extends AnyQueryBuilder> {
+    (column: ColumnRef, order?: OrderByDirection): QB;
+    (columns: ColumnRefOrOrderByDescriptor[]): QB;
+}
+interface WhereJsonExpressionMethod<QB extends AnyQueryBuilder> {
+    (fieldExpression: FieldExpression, keys: string | string[]): QB;
+}
+interface WhereColumnMethod<QB extends AnyQueryBuilder> {
+    (col1: ColumnRef, op: Operator, col2: ColumnRef): QB;
+    (col1: ColumnRef, col2: ColumnRef): QB;
+}
+interface UnionMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
+    (arg1: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, arg5: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, arg5: QBOrCallback<QB>, arg6: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, arg5: QBOrCallback<QB>, arg6: QBOrCallback<QB>, arg7: QBOrCallback<QB>, wrap?: boolean): QB;
+}
+interface JoinMethod<QB extends AnyQueryBuilder> {
+    (table: TableRef<QB>, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, leftCol: ColumnRef, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, cb: CallbackVoid<Knex.JoinClause>): QB;
+    (table: TableRef<QB>, raw: Raw): QB;
+    (raw: Raw): QB;
+}
+interface JoinMethod<QB extends AnyQueryBuilder> {
+    (table: TableRef<QB>, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, leftCol: ColumnRef, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, cb: CallbackVoid<Knex.JoinClause>): QB;
+    (table: TableRef<QB>, raw: Raw): QB;
+    (raw: Raw): QB;
+}
 
-declare class arquebus {
-    static connectorFactory: null;
-    static instance: null;
-    static getInstance(): null;
-    static connection(connection?: null): any;
-    static setConnectorFactory(connectorFactory: any): void;
-    static getConnectorFactory(): typeof Knex;
-    static addConnection(config: any, name?: string): any;
-    static beginTransaction(connection?: null): any;
-    static transaction(callback: any, connection?: null): any;
-    static table(name: any, connection?: null): any;
-    static schema(connection?: null): any;
-    static destroyAll(): Promise<void>;
-    static createModel(name: any, options: any): any;
-    manager: {};
-    connections: {};
-    models: {};
-    connection(connection?: null): any;
-    getConnection(name?: null): any;
-    addConnection(config: any, name?: string): void;
-    beginTransaction(connection?: null): any;
-    transaction(callback: any, connection?: null): any;
-    table(name: any, connection?: null): any;
-    schema(connection?: null): any;
-    destroyAll(): Promise<void>;
-    createModel(name: any, options?: {}): any;
+declare const Inference$2: {
+    new <M extends Model$2 = Model$2, R = M[] | M>(): IQueryBuilder<M, R>;
+};
+declare class QueryBuilder<M extends Model$2 = Model$2, R = M[] | M> extends Inference$2<M, R> {
+    model: M;
+    schema: SchemaBuilder;
+    private connector;
+    constructor(config: TConfig | null, connector: TFunction);
+    asProxy(): any;
+    beginTransaction(): Promise<Knex.Transaction<any, any[]> | undefined>;
+    table<X extends M>(table: string): IQueryBuilder<X, R>;
+    transaction(callback?: TFunction): Promise<Knex.Transaction> | undefined;
+    find(id: string | number, columns?: string[]): Promise<any>;
+    get(_columns?: string[]): Promise<any>;
+    exists(): Promise<boolean>;
+    skip(this: any, ...args: any[]): any;
+    take(this: any, ...args: any[]): any;
+    chunk(count: number, callback: TFunction): Promise<boolean>;
+    paginate<F extends IPaginatorParams>(this: any, page?: number, perPage?: number): Promise<IPaginator<M, F>>;
+    forPage(this: any, page?: number, perPage?: number): any;
+    toSQL(...args: Parameters<typeof this$1.connector.toSQL>): Knex.Sql;
+    count(column: string): Promise<number>;
+    min(column: string): Promise<number>;
+    max(column: string): Promise<number>;
+    sum(column: string): Promise<number>;
+    avg(column: string): Promise<number>;
+    clone(): IQueryBuilder<M, R>;
+    delete(): Promise<number | boolean>;
+    insert(...args: Parameters<typeof this$1.connector.insert>): Promise<unknown>;
+    update(...args: Parameters<typeof this$1.connector.update>): Promise<number>;
+    destroy(...args: Parameters<typeof this$1.connector.destroy>): Promise<number>;
+    get _statements(): IStatement[] & any[];
+    get _single(): any;
+    get from(): Knex.Table<any, any>;
+}
+
+declare class Relation$1 {
+    query: QueryBuilder;
+    parent: any;
+    related: any;
+    eagerKeysWereEmpty: boolean;
+    static constraints: boolean;
+    static selfJoinCount: number;
+    constructor(query: any, parent: any);
+    static extend(trait: Record<string, any>): void;
+    static noConstraints(callback: () => any): any;
+    asProxy(): any;
+    getRelated(): any;
+    getKeys(models: any[], key?: string | null): any[];
+    getRelationQuery(): any;
+    whereInEager(whereIn: string, key: string, modelKeys: any[], query?: any): void;
+    whereInMethod(model: any, key: string): string;
+    getEager(): any;
+    get(columns?: string | string[]): Promise<any>;
+    first(columns?: string[]): Promise<any>;
+    paginate(...args: any[]): Promise<any>;
+    count(...args: any[]): Promise<any>;
+    toSql(): string;
+    addConstraints(): void;
+    getRelationCountHash(incrementJoinCount?: boolean): string;
+    getRelationExistenceQuery(query: any, parentQuery: any, columns?: string[]): any;
+    getRelationExistenceCountQuery(query: any, parentQuery: any): any;
+    getQualifiedParentKeyName(): string;
+    getExistenceCompareKey(this: any): string;
+}
+
+interface TBaseConfig {
+    client: 'mysql' | 'mysql2' | 'sqlite3' | 'oracle' | 'mariadb' | 'pg';
+    connection: {
+        typeCast?(field: TField, next: TFunction): any;
+        dateStrings?: boolean;
+    };
+    pool?: {
+        afterCreate: (connection: TConfig, callback: (val: any, con: any) => void) => Promise<any>;
+    } | undefined;
+    connections?: arquebus['connections'];
+    migrations?: {
+        table: string;
+        path: string;
+    };
+    factories?: {
+        path: string;
+    };
+    seeders?: {
+        path: string;
+    };
+    models?: {
+        path: string;
+    };
+}
+type TConfig = TBaseConfig & ({
+    client: 'pg';
+    connection: Knex.PgConnectionConfig;
+} | {
+    client: 'oracle';
+    connection: Knex.OracleDbConnectionConfig;
+} | {
+    client: 'mysql2';
+    connection: Knex.MySql2ConnectionConfig;
+} | {
+    client: 'mysql';
+    connection: Knex.MySqlConnectionConfig;
+} | {
+    client: 'sqlite3';
+    connection: Knex.Sqlite3ConnectionConfig;
+    useNullAsDefault?: boolean;
+} | {
+    client: 'mariadb';
+    connection: Knex.MariaSqlConnectionConfig;
+    useNullAsDefault?: boolean;
+});
+interface ModelOptions<M extends Model$2 = Model$2> {
+    table?: string;
+    scopes?: TGeneric<(...args: any[]) => Builder<M>>;
+    plugins?: (<X extends MixinConstructor<M>>(Model: X) => MixinConstructor<M>)[];
+    relations?: TGeneric<(...args: any[]) => Relation$1>;
+    attributes?: TGeneric<Attribute$1>;
+    CREATED_AT?: string;
+    UPDATED_AT?: string;
+    DELETED_AT?: string;
+    connection?: TBaseConfig['client'];
+    timestamps?: boolean;
+    primaryKey?: string;
+    incrementing?: boolean;
+    keyType?: 'int' | 'string';
+    with?: Model$2['with'];
+    casts?: Model$2['casts'];
+}
+interface TField {
+    type: 'VAR_STRING' | 'BLOB' | 'DATETIME' | 'TIMESTAMP' | 'LONG' | 'JSON';
+    length: number;
+    db: string;
+    table: string;
+    name: string;
+    string: TFunction;
+    buffer: TFunction;
+    geometry: TFunction;
+}
+
+interface Attribute$1 {
+    make(config: {
+        get?: TFunction | null;
+        set?: TFunction | null;
+    }): Attribute$1;
+    get: TFunction | null;
+    set: TFunction | null;
+    withCaching?: boolean;
+    withObjectCaching?: boolean;
+}
+type Relation<M extends Model$2> = IBuilder<M, any> & {};
+interface HasOneOrMany<M extends Model$2> extends Relation<M> {
+    save(model: M): Promise<M>;
+    saveMany(models: M[] | ICollection<M>): Promise<ICollection<M>>;
+    create(attributes?: any): Promise<M>;
+    createMany(records: any[]): Promise<ICollection<M>>;
+}
+interface HasOne<M extends Model$2> extends HasOneOrMany<M> {
+    getResults(): Promise<M | null>;
+    withDefault(callback?: TFunction | object): this;
+}
+interface HasMany<M extends Model$2> extends HasOneOrMany<M> {
+    getResults(): Promise<ICollection<M>>;
+}
+interface BelongsTo<M extends Model$2> extends Relation<M> {
+    getResults(): Promise<M | null>;
+    withDefault(callback?: TFunction | object): this;
+}
+interface BelongsToMany<M extends Model$2> extends Relation<M> {
+    getResults(): Promise<ICollection<M>>;
+    withTimestamps(): this;
+    wherePivot(column: any, operator?: any, value?: any, boolean?: string, ...args: any[]): this;
+    wherePivotBetween(column: any, values: any, boolean?: string, not?: boolean): this;
+    orWherePivotBetween(column: any, values: any): this;
+    wherePivotNotBetween(column: any, values: any, boolean?: string): this;
+    orWherePivotNotBetween(column: any, values: any): this;
+    wherePivotIn(column: any, values: any, boolean?: string, not?: boolean): this;
+    orWherePivot(column: any, operator?: any, value?: any): this;
+    orWherePivotIn(column: any, values: any): this;
+    wherePivotNotIn(column: any, values: any, boolean?: string): this;
+    orWherePivotNotIn(column: any, values: any): this;
+    wherePivotNull(column: any, boolean?: string, not?: boolean): this;
+    wherePivotNotNull(column: any, boolean?: string): this;
+    orWherePivotNull(column: any, not?: boolean): this;
+    orWherePivotNotNull(column: any): this;
+    orderByPivot(column: any, direction?: string): this;
+}
+interface IModel {
+    [value: string]: any;
+    attributes: any;
+    relations: any;
+    exists: boolean;
+    primaryKey: string;
+    builder?: IBuilder<any, any> | null;
+    table: string | null;
+    connection?: TBaseConfig['client'] | null;
+    keyType: string;
+    incrementing: boolean;
+    perPage: number;
+    with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
+    withCount: string[];
+    trx: AnyQueryBuilder | null;
+    timestamps: boolean;
+    dateFormat: string;
+    visible: string[];
+    hidden: string[];
+    query<T extends {
+        prototype: unknown;
+    }>(this: T, client?: AnyQueryBuilder | null): IBuilder<Model$2>;
+    on<T extends {
+        prototype: unknown;
+    }>(this: T, connection: string | null): IBuilder<Model$2>;
+    boot(): void;
+    make<T extends IModel>(this: new () => T, attributes?: TGeneric): T;
+    addHook(hook: Hook, callback: TFunction): void;
+    creating(callback: TFunction): void;
+    created(callback: TFunction): void;
+    updating(callback: TFunction): void;
+    updated(callback: TFunction): void;
+    deleting(callback: TFunction): void;
+    deleted(callback: TFunction): void;
+    saving(callback: TFunction): void;
+    saved(callback: TFunction): void;
+    restoring(callback: TFunction): void;
+    restored(callback: TFunction): void;
+    trashed(callback: TFunction): void;
+    forceDeleted(callback: TFunction): void;
+    bootIfNotBooted(): void;
+    initialize(): void;
+    initializePlugins(): void;
+    addPluginInitializer(method: any): void;
+    newInstance(attributes?: TGeneric, exists?: boolean): any;
+    getKey(): string | number | null | undefined;
+    getKeyName(): string;
+    getConnectionName(): string;
+    getConnection(): any;
+    setConnection(connection: TBaseConfig['client'] | null): this;
+    usesUniqueIds(): boolean;
+    uniqueIds(): string[];
+    newUniqueId(): string;
+    setUniqueIds(): void;
+    getKeyType(): string;
+    getIncrementing(): boolean;
+    setIncrementing(value: boolean): this;
+    getTable(): string;
+    setTable(table: string): this;
+    getDates(): string[];
+    getDateFormat(): string;
+    getAttributes(): object;
+    getAttribute(key: string): any;
+    setAttribute(key: string, value: any): this;
+    fill(attributes: any): this;
+    setAppends(appends: string[]): this;
+    append(key: string | string[]): this;
+    getRelation<T extends Model$2>(relation: string): T | ICollection<T> | null | undefined;
+    setRelation<T extends Model$2>(relation: string, value: T | ICollection<T> | null): this;
+    unsetRelation(relation: string): this;
+    relationLoaded(relation: string): boolean;
+    makeVisible(attributes: string | string[]): this;
+    makeHidden(attributes: string | string[]): this;
+    newCollection(models?: any[]): ICollection<Model$2>;
+    load(relations: WithRelationType): Promise<this>;
+    load(...relations: WithRelationType[]): Promise<this>;
+    loadAggregate(relations: WithRelationType, column: any, callback?: any): Promise<this>;
+    loadCount(...relations: WithRelationType[]): Promise<this>;
+    loadMax(relations: WithRelationType, column: string): Promise<this>;
+    loadMin(relations: WithRelationType, column: string): Promise<this>;
+    loadSum(relations: WithRelationType, column: string): Promise<this>;
+    usesTimestamps(): boolean;
+    updateTimestamps(): this;
+    getCreatedAtColumn(): string;
+    getUpdatedAtColumn(): string;
+    getDeletedAtColumn(): string;
+    setCreatedAt(value: string): this;
+    setUpdatedAt(value: string): this;
+    freshTimestamp(): Date;
+    freshTimestampString(): string;
+    fromDateTime(value: Date | number | null): string;
+    useSoftDeletes(): boolean;
+    toData(): any;
+    attributesToData(): any;
+    relationsToData(): any;
+    toJSON(): any;
+    toJson(): string;
+    toString(): string;
+    isDirty(attributes?: string | string[]): boolean;
+    getDirty(): string[];
+    save(options?: any): Promise<boolean>;
+    update(attributes?: any, options?: any): Promise<boolean>;
+    increment(column: string, amount?: number, extra?: any): Promise<boolean>;
+    decrement(column: string, amount?: number, extra?: any): Promise<boolean>;
+    serializeDate(date: any): string;
+    delete(options?: any): Promise<boolean>;
+    softDelete(options?: any): Promise<boolean>;
+    forceDelete(options?: any): Promise<boolean>;
+    restore(options?: any): Promise<boolean>;
+    trashed(): boolean;
+    fresh(): Promise<this>;
+    refresh(): Promise<this | undefined>;
+    push(): Promise<boolean>;
+    is(model: this): boolean;
+    isNot(model: this): boolean;
+    related<T extends RelationNames<this>>(relation: T): ReturnTypeOfMethod<this, `relation${Capitalize<SnakeToCamelCase<T>>}`>;
+    getRelated<T extends RelationNames<this>>(relation: T): ReturnTypeOfMethod<ReturnTypeOfMethod<this, `relation${Capitalize<SnakeToCamelCase<T>>}`>, any>;
+    hasOne<T extends Model$2>(model: new () => T, foreignKey?: string, localKey?: string): HasOne<T>;
+    hasMany<T extends Model$2>(model: new () => T, foreignKey?: string, localKey?: string): HasMany<T>;
+    belongsTo<T extends Model$2>(model: new () => T, foreignKey?: string, ownerKey?: string, relation?: string): BelongsTo<T>;
+    belongsToMany<T extends Model$2>(model: new () => T, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToMany<T>;
 }
 
-declare class Paginator {
-    static formatter: null;
-    static setFormatter(formatter: any): void;
-    constructor(items: any, total: any, perPage: any, currentPage?: null, options?: {});
-    _items: any;
-    _total: any;
+declare class Paginator<T extends Model$2, K extends IPaginatorParams = IPaginatorParams> implements IPaginator<T, K> {
+    static formatter: (paginator: IPaginator<any>) => any | null;
+    _items: Collection$1<T>;
+    _total: number;
     _perPage: number;
     _lastPage: number;
-    _currentPage: any;
-    options: {};
-    setItems(items: any): void;
-    hasMore: boolean | undefined;
+    _currentPage: number;
+    hasMore: boolean;
+    options: TGeneric;
+    static setFormatter(formatter: (paginator: IPaginator<any>) => any | null): void;
+    constructor(items: T[], total: number, perPage: number, currentPage?: number, options?: TGeneric);
+    setItems(items: T[]): void;
     firstItem(): number | null;
     lastItem(): number | null;
     hasMorePages(): boolean;
-    get(index: any): any;
-    count(): any;
-    items(): any;
-    map(callback: any): any;
-    currentPage(): any;
+    get(index: number): T | null;
+    count(): number;
+    items(): Collection$1<T>;
+    map(callback: (value: T, index: number) => T): Collection$1<T>;
+    currentPage(): number;
     onFirstPage(): boolean;
     perPage(): number;
     lastPage(): number;
-    total(): any;
+    total(): number;
     toData(): any;
     toJSON(): any;
     toJson(...args: any[]): string;
 }
 
-declare class Collection extends Collection$1<any> {
-    constructor(collection?: Object | any[] | undefined);
-    load(...relations: any[]): Promise<any>;
-    loadAggregate(relations: any, column: any, action?: null): Promise<this>;
-    loadCount(relations: any): Promise<this>;
-    loadMax(relation: any, column: any): Promise<this>;
-    loadMin(relation: any, column: any): Promise<this>;
-    loadSum(relation: any, column: any): Promise<this>;
-    loadAvg(relation: any, column: any): Promise<this>;
-    mapThen(callback: any): Promise<any[]>;
-    modelKeys(): any[];
-    contains(key: any, operator?: null, value?: null, ...args: any[]): boolean;
-    diff(items: any): any;
-    except(keys: any): any;
-    intersect(items: any): any;
-    unique(key?: null, strict?: boolean): any;
-    find(key: any, defaultValue?: null): any;
-    fresh(...args: any[]): Promise<any>;
-    makeVisible(attributes: any): this;
-    makeHidden(attributes: any): this;
-    append(attributes: any): this;
-    only(keys: any): any;
-    getDictionary(items?: null): {};
-    toQuery(): any;
-    toData(): any[];
-    toJSON(): any[];
-    toJson(...args: any[]): string;
-    [Symbol.iterator](): {
-        next(): {
-            value: any;
-            done: boolean;
-        } | {
-            done: boolean;
-            value?: undefined;
-        };
-    };
-}
-
-declare class QueryBuilder {
-    constructor(config: any, connector: any);
-    connector: null;
-    asProxy(): any;
-    beginTransaction(): Promise<QueryBuilder>;
-    table(table: any): QueryBuilder;
-    transaction(callback: any): any;
-    find(id: any, columns?: string[]): Promise<any>;
-    get(columns?: string[]): Promise<null>;
-    exists(): Promise<boolean>;
-    skip(...args: any[]): any;
-    take(...args: any[]): any;
-    chunk(count: any, callback: any): Promise<boolean>;
-    paginate(page?: number, perPage?: number): Promise<Paginator>;
-    forPage(page?: number, perPage?: number): any;
-    toSQL(...args: any[]): any;
-    count(column: any): Promise<number>;
-    min(column: any): Promise<number>;
-    max(column: any): Promise<number>;
-    sum(column: any): Promise<number>;
-    avg(column: any): Promise<number>;
-    clone(): QueryBuilder;
-    delete(): Promise<any>;
-    insert(...args: any[]): Promise<any>;
-    update(...args: any[]): Promise<any>;
-    destroy(...args: any[]): any;
-    get _statements(): any;
-    get _single(): any;
-    get from(): any;
+declare class Scope<M extends Model$2 = Model$2> implements IScope {
+    constructor();
+    apply(_builder: Builder<M>, _model: M): void;
 }
 
-declare class Builder {
-    constructor(query: any);
-    query: any;
+declare const Inference$1: {
+    new <M extends Model$2 = Model$2, R = IModel | ICollection<M>>(): IBuilder<M, R>;
+};
+declare class Builder<M extends Model$2 = Model$2, R = IModel | ICollection<M>> extends Inference$1 {
+    query: IBuilder<M, R>;
     connection: any;
-    model: any;
-    actions: any;
-    localMacros: {};
-    eagerLoad: {};
-    globalScopes: {};
-    asProxy(): any;
+    model: M;
+    actions: any[];
+    localMacros: TGeneric<(...args: any[]) => any, keyof Omit<IBuilder<M, R>, number>>;
+    eagerLoad: TGeneric<(...args: any[]) => any>;
+    globalScopes: TGeneric<Scope<M> | ((arg: Builder<M, R>) => Builder<M, R>)>;
+    onDeleteCallback?: (builder: Builder<M, R>) => Promise<boolean | number>;
+    constructor(query: IBuilder<M, R>);
+    asProxy(): Builder<M, R>;
     orWhere(...args: any[]): this;
-    chunk(count: any, callback: any): Promise<boolean>;
-    enforceOrderBy(): void;
-    clone(): any;
-    forPage(page: any, perPage?: number): any;
-    insert(...args: any[]): any;
-    update(values: any): any;
-    increment(column: any, amount?: number, extra?: {}): any;
-    decrement(column: any, amount?: number, extra?: {}): any;
-    addUpdatedAtColumn(values: any): any;
-    delete(): any;
-    onDelete(callback: any): void;
-    onDeleteCallback: any;
-    forceDelete(): any;
+    chunk<C extends TFunction>(count: number, callback: C): Promise<boolean>;
+    enforceOrderBy(this: any): void;
+    clone(this: any): any;
+    forPage(this: any, page: number, perPage?: number): any;
+    insert(...args: Parameters<typeof this$1.query.insert>): Promise<any>;
+    update<T extends TGeneric>(values: T): Promise<any>;
+    increment(column: string, amount?: number, extra?: {}): Promise<any>;
+    decrement(column: string, amount?: number, extra?: {}): Promise<any>;
+    addUpdatedAtColumn(values: TGeneric<string>): TGeneric<string>;
+    delete(): Promise<number | boolean>;
+    onDelete<C extends TFunction<any, Promise<number | boolean>>>(callback: C): void;
+    forceDelete(): Promise<number | boolean>;
     create(attributes?: {}): Promise<any>;
     newModelInstance(attributes?: {}): any;
-    getQuery(): any;
-    getModel(): any;
-    setModel(model: any): this;
-    qualifyColumn(column: any): any;
-    setTable(table: any): this;
+    getQuery(): IBuilder<M, R>;
+    getModel(): M;
+    setModel<MO extends Model$2>(model: MO): this;
+    qualifyColumn(column: string): string;
+    setTable(table: string): this;
     applyScopes(): this;
-    hasNamedScope(name: any): any;
-    callNamedScope(scope: any, parameters: any): any;
-    callScope(scope: any, parameters?: any[]): any;
-    scopes(scopes: any): this;
-    withGlobalScope(identifier: any, scope: any): this;
-    withoutGlobalScope(scope: any): this;
-    macro(name: any, callback: any): void;
-    hasMacro(name: any): boolean;
-    getMacro(name: any): any;
+    hasNamedScope(name: string): boolean;
+    callNamedScope(scope: string, parameters: any[]): any;
+    callScope(scope: (builder: this, ...args: any[]) => this, parameters?: never[]): this;
+    scopes(scopes: string[]): this;
+    withGlobalScope(identifier: string, scope: any): this;
+    withoutGlobalScope(scope: Scope | string): this;
+    macro<N extends string>(name: N, callback: (builder: TGeneric & IBuilder<M>, attrs: any, vals: any) => any): this;
+    hasMacro(name: string): boolean;
+    getMacro(name: string): (...args: any[]) => any;
     with(...args: any[]): this;
-    has(relation: any, operator?: string, count?: number, boolean?: string, callback?: null): any;
+    has(relation: any, operator?: string, count?: number, boolean?: string, callback?: TFunction | null): any;
     orHas(relation: any, operator?: string, count?: number): any;
-    doesntHave(relation: any, boolean?: string, callback?: null): any;
+    doesntHave(relation: any, boolean?: string, callback?: TFunction | null): any;
     orDoesntHave(relation: any): any;
-    whereHas(relation: any, callback?: null, operator?: string, count?: number): any;
-    orWhereHas(relation: any, callback?: null, operator?: string, count?: number): any;
+    whereHas(relation: any, callback?: TFunction | null, operator?: string, count?: number): any;
+    orWhereHas(relation: any, callback?: TFunction | null, operator?: string, count?: number): any;
     whereRelation(relation: any, ...args: any[]): any;
     orWhereRelation(relation: any, ...args: any[]): any;
-    hasNested(relations: any, operator?: string, count?: number, boolean?: string, callback?: null): any;
-    canUseExistsForExistenceCheck(operator: any, count: any): boolean;
-    addHasWhere(hasQuery: any, relation: any, operator: any, count: any, boolean: any): any;
-    addWhereExistsQuery(query: any, boolean?: string, not?: boolean): this;
-    addWhereCountQuery(query: any, operator?: string, count?: number, boolean?: string): any;
-    withAggregate(relations: any, column: any, action?: null): this;
+    hasNested(relations: any, operator?: string, count?: number, boolean?: string, callback?: TFunction | null): any;
+    canUseExistsForExistenceCheck(operator: string, count: number): boolean;
+    addHasWhere(hasQuery: any, relation: any, operator: string, count: number, boolean: string): any;
+    addWhereExistsQuery(this: any, query: any, boolean?: string, not?: boolean): any;
+    addWhereCountQuery(this: any, query: any, operator?: string, count?: number, boolean?: string): any;
+    withAggregate(relations: any, column: string, action?: string | null): this;
     toSql(): any;
-    mergeConstraintsFrom(from: any): any;
-    selectSub(query: any, as: any): any;
+    mergeConstraintsFrom(_from: any): this;
+    selectSub(query: Builder<M>, as: string): any;
     createSub(query: any): any[];
     parseSub(query: any): any[];
     prependDatabaseNameIfCrossDatabaseQuery(query: any): any;
-    getRelationWithoutConstraints(relation: any): any;
+    getRelationWithoutConstraints(relation: string): any;
     withCount(...args: any[]): this;
-    withMax(relation: any, column: any): this;
-    withMin(relation: any, column: any): this;
-    withAvg(relation: any, column: any): this;
-    withSum(relation: any, column: any): this;
+    withMax(relation: any, column: string): this;
+    withMin(relation: any, column: string): this;
+    withAvg(relation: any, column: string): this;
+    withSum(relation: any, column: string): this;
     withExists(relation: any): this;
-    parseWithRelations(relations: any): {};
-    addNestedWiths(name: any, results: any): any;
-    prepareNestedWithRelationships(relations: any, prefix?: string): {};
-    combineConstraints(constraints: any): (builder: any) => any;
-    parseNameAndAttributeSelectionConstraint(name: any, value: any): any[];
-    createSelectWithConstraint(name: any): any[];
-    related(relation: any): any;
-    take(...args: any[]): any;
-    skip(...args: any[]): any;
-    first(...columns: any[]): Promise<any>;
-    firstOrFail(...columns: any[]): Promise<any>;
-    findOrFail(ids: any, columns?: string): Promise<any>;
-    findOrNew(id: any, columns?: string[]): Promise<any>;
-    firstOrNew(attributes?: {}, values?: {}): Promise<any>;
-    firstOrCreate(attributes?: {}, values?: {}): Promise<any>;
-    updateOrCreate(attributes: any, values?: {}): Promise<any>;
-    latest(column?: null): this;
-    oldest(column?: null): this;
-    find(id: any, columns?: string): Promise<any>;
-    findMany(ids: any, columns?: string): Promise<any>;
-    pluck(column: any): Promise<Collection>;
-    destroy(ids: any, ...args: any[]): Promise<number>;
-    get(columns?: string): Promise<Collection>;
-    all(columns?: string): Promise<any>;
-    paginate(page: any, perPage: any): Promise<Paginator>;
+    parseWithRelations(relations: TGeneric): TGeneric | never[];
+    addNestedWiths(name: string, results: TGeneric): TGeneric;
+    prepareNestedWithRelationships(relations: TGeneric, prefix?: string): TGeneric;
+    combineConstraints(constraints: TFunction[]): (builder: Builder<M>) => Builder<M, IModel | ICollection<M>>;
+    parseNameAndAttributeSelectionConstraint(name: string, value: string): (string | ((query: any) => void))[];
+    createSelectWithConstraint(name: string): (string | ((query: any) => void))[];
+    related(relation: string): any;
+    take(this: any, ...args: any[]): any;
+    skip(this: any, ...args: any[]): any;
+    first(this: any, ...columns: any[]): Promise<M | null>;
+    firstOrFail(...columns: any[]): Promise<M>;
+    findOrFail(this: any, ...args: any[]): Promise<M>;
+    findOrNew(id: string, columns?: string[]): Promise<any>;
+    firstOrNew(this: any, attributes?: {}, values?: {}): Promise<any>;
+    firstOrCreate(this: any, attributes?: TGeneric, values?: {}): Promise<any>;
+    updateOrCreate(attributes: TGeneric, values?: {}): Promise<any>;
+    latest(column?: string): this;
+    oldest(column?: string): this;
+    find(this: any, id: string | number | Collection$1<M>, columns?: string[]): Promise<any>;
+    findMany(this: any, ids: string[] | number[] | ICollection<any>, columns?: string[]): Promise<any>;
+    pluck(column: string): Promise<any>;
+    destroy(this: any, ids?: (string | number)[] | TFunction | Collection$1<M>): Promise<number>;
+    get<M extends Model$2>(columns?: string | string[]): Promise<Collection$1<M>>;
+    all(columns?: string[]): Promise<any>;
+    paginate(this: any, page?: number, perPage?: number): Promise<Paginator<any, IPaginatorParams>>;
     getModels(...columns: any[]): Promise<any[]>;
-    getRelation(name: any): any;
-    relationsNestedUnder(relation: any): {};
-    isNestedUnder(relation: any, name: any): any;
-    eagerLoadRelation(models: any, name: any, constraints: any): Promise<any>;
-    eagerLoadRelations(models: any): Promise<any>;
-    hydrate(items: any): Collection;
+    getRelation(name: string): any;
+    relationsNestedUnder(relation: string): TGeneric;
+    isNestedUnder(relation: string, name: string): boolean;
+    eagerLoadRelation<M extends Model$2>(models: M[], name: string, constraints: any): Promise<any>;
+    eagerLoadRelations<M extends Model$2>(models: M[]): Promise<M[]>;
+    hydrate(items: any[]): Collection$1<any>;
+}
+
+interface IScope {
+    apply(builder: Builder<any>, model: Model$2): void;
+}
+interface IBuilder<M extends Model$2 | Model$1, R = ICollection<M> | IModel> extends IQueryBuilder<M, R> {
+    asProxy(): IQueryBuilder<M, R>;
+    enforceOrderBy(): void;
+    insert(attributes: any): Promise<any>;
+    update(attributes: any): Promise<any>;
+    increment(column: string, amount?: number, extra?: any): Promise<any>;
+    decrement(column: string, amount?: number, extra?: any): Promise<any>;
+    addUpdatedAtColumn(values: any): any;
+    delete(): Promise<boolean | number>;
+    softDelete(): boolean | Promise<any>;
+    forceDelete(): boolean | Promise<any>;
+    restore(): boolean | Promise<any>;
+    withTrashed(): this;
+    withoutTrashed(): this;
+    onlyTrashed(): this;
+    getDeletedAtColumn(): string;
+    create(attributes?: any): Promise<M>;
+    newModelInstance(attributes?: any): M;
+    count(columns?: string): Promise<number>;
+    getQuery(): AnyQueryBuilder;
+    getModel(): M;
+    setModel(model: M): this;
+    setTable(table: string): this;
+    applyScopes(): this;
+    scopes(scopes: string[]): this;
+    withGlobalScope(identifier: string | number, scope: string | (() => void)): this;
+    withoutGlobalScope(scope: IScope | string): this;
+    with(relation: WithRelationType): this;
+    with(...relations: WithRelationType[]): this;
+    has(relation: string, operator?: any, count?: number, boolean?: any, callback?: (builder: IBuilder<any>) => void | null): this;
+    orHas(relation: string, operator?: any, count?: number): this;
+    doesntHave(relation: string, boolean?: any, callback?: (builder: IBuilder<any>) => void | null): this;
+    orDoesntHave(relation: string): this;
+    whereHas(relation: string, callback?: (builder: IBuilder<any>) => void | IBuilder<any> | null, operator?: any, count?: number): this;
+    orWhereHas(relation: string, callback?: (builder: IBuilder<any>) => void | IBuilder<any> | null, operator?: any, count?: number): this;
+    whereRelation(relation: string, column: string, operator?: any, value?: any): this;
+    hasNested(relation: string, operator?: any, count?: number, boolean?: any, callback?: (builder: IBuilder<any>) => void | null): this;
+    canUseExistsForExistenceCheck(operator: string, count: number): boolean;
+    addHasWhere(hasQuery: IBuilder<any>, relation: string, operator?: string, count?: number, boolean?: string): this;
+    withAggregate(relations: string | string[] | object, column: string, action?: string | null): this;
+    toSql(): object;
+    withCount(...relations: WithRelationType[]): this;
+    withMax(relation: WithRelationType, column: string): this;
+    withMin(relation: WithRelationType, column: string): this;
+    withAvg(relation: WithRelationType, column: string): this;
+    withSum(relation: WithRelationType, column: string): this;
+    withExists(relation: WithRelationType): this;
+    related(relation: string): this;
+    first(column?: string | string[]): Promise<M | null | undefined>;
+    firstOrFail(column?: string | string[]): Promise<M>;
+    findOrFail(key: string | number, columns?: string[]): Promise<M>;
+    findOrFail(key: string[] | number[] | ICollection<any>, columns?: string[]): Promise<M>;
+    findOrFail(key: string | number | string[] | number[] | ICollection<any>, columns?: string[]): Promise<M>;
+    findOrNew(id: string | number, columns?: string[]): Promise<M>;
+    firstOrNew(attributes?: object, values?: object): Promise<M>;
+    firstOrCreate(attributes?: object, values?: object): Promise<M>;
+    updateOrCreate(attributes: object, values?: object): Promise<M>;
+    latest(column?: string): this;
+    oldest(column?: string): this;
+    find(key: string | number, columns?: string[]): Promise<M | null | undefined>;
+    findMany(keys: string[] | number[] | ICollection<any>, columns?: string[]): Promise<ICollection<M>>;
+    pluck<X extends Model$2 = any | M>(column: string): Promise<ICollection<X>>;
+    all(columns?: string[]): Promise<ICollection<M>>;
+    paginate<F extends IPaginatorParams>(page?: number, perPage?: number): Promise<IPaginator<M, F>>;
+    [value: string]: any;
+}
+
+interface ICollection<T extends Model$2 | Model$1> extends Collection$2<T> {
+    items?: T[];
+    load(...relations: T[]): Promise<ICollection<T>>;
+    loadAggregate(relations: T | T[], column: string, action?: string | null): Promise<this>;
+    loadCount(relation: T, column: string): Promise<this>;
+    loadMax(relation: T, column: string): Promise<this>;
+    loadMin(relation: T, column: string): Promise<this>;
+    loadSum(relation: T, column: string): Promise<this>;
+    loadAvg(relation: T, column: string): Promise<this>;
+    mapThen(callback: () => void): Promise<any>;
+    modelKeys(): string[] | number[];
+    contains(key: IModel | any, operator?: any, value?: any): boolean;
+    diff(items: ICollection<T> | any[]): ICollection<T>;
+    except(keys: any[]): ICollection<T>;
+    intersect(items: T[]): ICollection<T>;
+    unique(key?: any, strict?: boolean): ICollection<T>;
+    find(key: any, defaultValue?: any): any;
+    fresh(withs?: any[]): Promise<ICollection<T>>;
+    makeVisible(attributes: string | string[]): this;
+    makeHidden(attributes: string | string[]): this;
+    append(attributes: string[]): this;
+    only(keys: null | any[]): this;
+    getDictionary(items?: any[]): TGeneric;
+    toQuery(): IBuilder<T, any>;
+    toData(): any;
+    toJSON(): any;
+    toJson(): string;
+    toString(): string;
+    [key: string]: any;
+    [Symbol.iterator]: () => Iterator<T>;
+}
+interface IPaginatorParams {
+    current_page: number;
+    data: any[];
+    per_page: number;
+    total: number;
+    last_page: number;
+    count: number;
+}
+interface IPaginator<T extends Model$2 | Model$1, K extends IPaginatorParams = IPaginatorParams> {
+    formatter?(paginator: IPaginator<any>): any | null;
+    setFormatter?(formatter: (paginator: IPaginator<any>) => any | null): void;
+    setItems(items: T[] | Collection$1<T>): void;
+    hasMorePages(): boolean;
+    get(index: number): T | null;
+    count(): number;
+    items(): Collection$1<T>;
+    map(callback: (value: T, index: number) => T): Collection$1<T>;
+    currentPage(): number;
+    perPage(): number;
+    lastPage(): number;
+    firstItem(): number | null;
+    lastItem(): number | null;
+    total(): number;
+    toData<U = K>(): U;
+    toJSON<U = K>(): U;
+    toJson(): string;
+    [Symbol.iterator]?(): {
+        next: () => {
+            value: T;
+            done: boolean;
+        };
+    };
+}
+
+declare class arquebus<M extends Model$2 = Model$2> {
+    static connectorFactory: typeof Knex$1 | null;
+    static instance: arquebus | null;
+    manager: Record<string, QueryBuilder<M>>;
+    connections: Record<string, TConfig>;
+    models: Record<string, typeof Model$2>;
+    constructor();
+    getConstructor<T extends typeof arquebus>(this: InstanceType<T>): T;
+    static getInstance(): arquebus<Model$2>;
+    static connection(connection?: TBaseConfig['client'] | null): QueryBuilder<Model$2, Model$2 | Model$2[]>;
+    static setConnectorFactory(connectorFactory: typeof Knex$1): void;
+    static getConnectorFactory(): typeof Knex$1;
+    static addConnection(config: TConfig | TBaseConfig, name?: string): void;
+    static beginTransaction(connection?: null): Promise<Knex$1.Knex.Transaction<any, any[]> | undefined>;
+    static transaction(callback: TFunction, connection?: null): Promise<Knex$1.Knex.Transaction<any, any[]>> | undefined;
+    static table(name: string, connection?: null): IQueryBuilder<Model$2, Model$2 | Model$2[]>;
+    static schema(connection?: null): SchemaBuilder;
+    static destroyAll(): Promise<void>;
+    static createModel<X extends TGeneric>(name: string, options: X): typeof Model$2;
+    connection(connection?: string | null): QueryBuilder<M, M | M[]>;
+    getConnection(name?: string | null): QueryBuilder<M, M | M[]>;
+    addConnection(config: TConfig | TBaseConfig, name?: string): void;
+    beginTransaction(connection?: null): Promise<Knex$1.Knex.Transaction<any, any[]> | undefined>;
+    transaction(callback: TFunction, connection?: null): Promise<Knex$1.Knex.Transaction<any, any[]>> | undefined;
+    table(name: string, connection?: null): IQueryBuilder<M, M | M[]>;
+    schema(connection?: null): SchemaBuilder;
+    destroyAll(): Promise<void>;
+    createModel(name: string, options?: ModelOptions): typeof Model$2;
 }
 
-declare const Model_base: any;
-declare class Model extends Model_base {
+declare const BaseModel$1: (new (...args: any[]) => any) & {
     [x: string]: any;
+};
+declare class Model$2 extends BaseModel$1 {
+    protected primaryKey: string;
+    protected builder: IBuilder<any, any> | null;
+    protected table: string | null;
+    protected keyType: string;
+    protected incrementing: boolean;
+    protected withCount: never[];
+    perPage: number;
     static globalScopes: {};
     static pluginInitializers: {};
     static _booted: {};
-    static resolver: null;
-    static query(trx?: null): any;
-    static on(connection?: null): any;
-    static init(attributes?: {}): Model;
-    static extend(plugin: any, options: any): void;
-    static make(attributes?: {}): Model;
+    static resolver: arquebus;
+    connection: TBaseConfig['client'] | null;
+    eagerLoad: {};
+    exists: boolean;
+    with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
+    trx: null;
+    constructor(attributes?: {});
+    static query(trx?: null): Builder<Model$2, IModel | ICollection<Model$2>>;
+    static on(connection?: TBaseConfig['client'] | null): Builder<Model$2, IModel | ICollection<Model$2>>;
+    static init(attributes?: {}): Model$2;
+    static extend(plugin: TFunction, options: TGeneric): void;
+    static make(attributes?: TGeneric): Model$2;
+    getConstructor<T extends typeof Model$2>(this: InstanceType<T>): T;
+    bootIfNotBooted(this: any): void;
     static booting(): void;
     static boot(): void;
     static booted(): void;
-    static setConnectionResolver(resolver: any): void;
-    constructor(attributes?: {});
-    primaryKey: string;
-    builder: null;
-    table: null;
-    connection: null;
-    keyType: string;
-    incrementing: boolean;
-    perPage: number;
-    exists: boolean;
-    eagerLoad: {};
-    with: any[];
-    withCount: any[];
-    trx: null;
-    bootIfNotBooted(): void;
+    static setConnectionResolver(resolver: arquebus): void;
     initialize(): void;
-    initializePlugins(): void;
-    addPluginInitializer(method: any): void;
-    newInstance(attributes?: {}, exists?: boolean): any;
-    newFromBuilder(attributes?: {}, connection?: null): any;
-    asProxy(): any;
+    initializePlugins(this: any): void;
+    addPluginInitializer(this: any, method: any): void;
+    newInstance(this: any, attributes?: TGeneric, exists?: boolean): any;
+    newFromBuilder(attributes?: TGeneric, connection?: null): any;
+    asProxy(): this;
     getKey(): any;
     getKeyName(): string;
     getForeignKey(): string;
-    getConnectionName(): null;
+    getConnectionName(): "mysql" | "mysql2" | "sqlite3" | "oracle" | "mariadb" | "pg";
     getTable(): string;
-    getConnection(): any;
-    setConnection(connection: any): this;
+    getConnection(this: any): any;
+    setConnection(connection: TBaseConfig['client'] | null): this;
     getKeyType(): string;
-    newQuery(trx?: null): any;
-    newQueryWithoutScopes(trx?: null): Builder;
-    newModelQuery(trx?: null): Builder;
-    addGlobalScopes(builder: any): any;
-    hasNamedScope(name: any): boolean;
-    callNamedScope(scope: any, parameters: any): any;
-    setTable(table: any): this;
-    newCollection(models?: any[]): Collection;
-    load(...relations: any[]): Promise<this>;
-    loadAggregate(relations: any, column: any, callback?: null): Promise<this>;
-    loadCount(...relations: any[]): Promise<this>;
-    loadMax(relations: any, column: any): Promise<this>;
-    loadMin(relations: any, column: any): Promise<this>;
-    loadSum(relations: any, column: any): Promise<this>;
-    increment(column: any, amount?: number, extra?: {}, options?: {}): Promise<any>;
-    decrement(column: any, amount?: number, extra?: {}, options?: {}): Promise<any>;
-    incrementOrDecrement(column: any, amount: any, extra: any, method: any, options: any): Promise<any>;
+    newQuery(trx?: null): Builder<Model$2, IModel | ICollection<Model$2>>;
+    newQueryWithoutScopes(trx?: null): Builder<Model$2, IModel | ICollection<Model$2>>;
+    newModelQuery(trx?: null): Builder<Model$2, IModel | ICollection<Model$2>>;
+    addGlobalScopes(this: any, builder: Builder<Model$2>): Builder<Model$2, IModel | ICollection<Model$2>>;
+    hasNamedScope(name: string): boolean;
+    callNamedScope(scope: string, parameters: any[]): any;
+    setTable(table: string): this;
+    newCollection(this: any, models?: never[]): Collection$1<Model$2>;
+    load<R extends WithRelationType>(this: any, ...relations: R[]): Promise<any>;
+    loadAggregate<R extends WithRelationType>(relations: R[], column: string, callback?: TFunction | string | null): Promise<this>;
+    loadCount<R extends WithRelationType>(...relations: R[]): Promise<this>;
+    loadMax<R extends WithRelationType>(relations: R[], column: string): Promise<this>;
+    loadMin<R extends WithRelationType>(relations: R[], column: string): Promise<this>;
+    loadSum<R extends WithRelationType>(relations: R[], column: string): Promise<this>;
+    increment(column: string, amount?: number, extra?: TGeneric, options?: TGeneric): Promise<any>;
+    decrement(column: string, amount?: number, extra?: TGeneric, options?: TGeneric): Promise<any>;
+    incrementOrDecrement(column: string, amount: number, extra: TGeneric, method: string, options: TGeneric): Promise<any>;
     toData(): {
         [x: string]: any;
         [x: number]: any;
@@ -341,117 +975,475 @@ declare class Model extends Model_base {
     };
     toJson(...args: any[]): string;
     toString(): string;
-    fill(attributes: any): this;
+    fill(attributes: TGeneric): this;
     transacting(trx: any): this;
     trashed(): boolean;
     getIncrementing(): boolean;
-    setIncrementing(value: any): this;
-    save(options?: {}): Promise<boolean>;
-    update(attributes?: {}, options?: {}): Promise<boolean>;
+    setIncrementing(value: boolean): this;
+    save(options?: TGeneric): Promise<boolean>;
+    update(attributes?: TGeneric, options?: TGeneric): Promise<boolean>;
     delete(options?: {}): Promise<boolean>;
-    performDeleteOnModel(options?: {}): Promise<void>;
+    performDeleteOnModel(options?: TGeneric): Promise<void>;
     setKeysForSaveQuery(query: any): any;
     forceDelete(options?: {}): Promise<boolean>;
-    fresh(): any;
-    refresh(): Promise<this | undefined>;
-    attributes: any;
-    newPivot(parent: any, attributes: any, table: any, exists: any, using?: null): any;
-    qualifyColumn(column: any): any;
-    getQualifiedKeyName(): any;
+    fresh(this: any): any;
+    refresh(this: any): Promise<any>;
+    newPivot<E extends Model$2>(parent: E, attributes: TGeneric, table: string, exists: boolean, using?: typeof Pivot$1 | null): Pivot$1;
+    qualifyColumn(column: string): string;
+    getQualifiedKeyName(): string;
     push(options?: {}): Promise<boolean>;
     is(model: any): any;
     isNot(model: any): boolean;
 }
-declare class Pivot extends Model {
-    static fromRawAttributes(parent: any, attributes: any, table: any, exists?: boolean): Pivot;
-    static fromAttributes(parent: any, attributes: any, table: any, exists?: boolean): Pivot;
-    guarded: any[];
-    pivotParent: null;
-    foreignKey: null;
-    relatedKey: null;
-    setPivotKeys(foreignKey: any, relatedKey: any): this;
-    hasTimestampAttributes(attributes?: null): boolean;
+declare class Pivot$1 extends Model$2 {
+    incrementing: boolean;
+    guarded: never[];
+    pivotParent: Model$2 | null;
+    foreignKey: string | null;
+    relatedKey: string | null;
+    setPivotKeys(foreignKey: string, relatedKey: string): this;
+    static fromRawAttributes<E extends Model$2>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot$1;
+    static fromAttributes<E extends Model$2>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot$1;
+    hasTimestampAttributes(this: any, attributes?: TGeneric | null): boolean;
+}
+
+type TGeneric<V = any, K extends string = string> = Record<K, V>;
+type XGeneric<V = TGeneric, T = any> = {
+    [key: string]: T;
+} & V;
+type Hook = 'creating' | 'created' | 'updating' | 'updated' | 'saving' | 'saved' | 'deleting' | 'deleted' | 'restoring' | 'restored' | 'trashed' | 'forceDeleted';
+type TFunction<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => TReturn;
+type PrimitiveValue = string | number | boolean | Date | string[] | number[] | boolean[] | Date[] | null | Buffer;
+type ReturnTypeOfMethod<T, K extends keyof T> = T[K] extends (...args: any[]) => infer R ? R : never;
+type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
+type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Uncapitalize<T>}${CamelToSnakeCase<U>}` : `${Uncapitalize<T>}_${CamelToSnakeCase<U>}` : S;
+type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+type RelationNames<T> = FunctionPropertyNames<T> extends infer R ? R extends `relation${infer P}` ? P extends ('sToData' | 'loaded') ? never : CamelToSnakeCase<P> : never : never;
+type MixinConstructor<T = TGeneric> = new (...args: any[]) => T;
+
+declare class Collection<I extends Model$1> extends Collection$2<I> {
+    mapThen(callback: TFunction): Promise<any[]>;
+    modelKeys(): any[];
+    contains<K, V>(key: keyof I | K | TFunction, value?: V): boolean;
+    diff(items: ICollection<any> | any[]): any;
+    except(keys: any[]): any;
+    intersect(items: I[]): any;
+    unique(key?: TFunction | keyof I, _strict?: boolean): any;
+    find(key: any, defaultValue?: null): any;
+    makeVisible(attributes: any): this;
+    makeHidden(attributes: any): this;
+    append(attributes: any): this;
+    only(keys: any[]): any;
+    getDictionary(items?: ICollection<any> | any[]): TGeneric;
+    toData(): (I | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    })[];
+    toJSON(): (I | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    })[];
+    toJson(...args: any[]): string;
+    [Symbol.iterator]: () => Iterator<I>;
+}
+
+declare const BaseModel: (new (...args: any[]) => any) & {
+    [x: string]: any;
+};
+declare class Model$1 extends BaseModel {
+    protected primaryKey: string;
+    protected perPage: number;
+    static globalScopes: {};
+    static pluginInitializers: {};
+    static _booted: {};
+    static resolver: arquebus;
+    static browser: boolean;
+    connection: TBaseConfig['client'] | null;
+    constructor(attributes?: {});
+    static init(attributes?: {}): Model$1;
+    static extend(plugin: TFunction, options: TGeneric): void;
+    static make(attributes?: TGeneric): Model$1;
+    bootIfNotBooted(this: any): void;
+    static booting(): void;
+    static boot(): void;
+    static booted(): void;
+    static setConnectionResolver(resolver: arquebus): void;
+    initialize(): void;
+    initializePlugins(this: any): void;
+    addPluginInitializer(this: any, method: any): void;
+    newInstance(this: any, attributes?: TGeneric, exists?: boolean): any;
+    asProxy(): this;
+    getKey(): any;
+    getKeyName(): string;
+    getForeignKey(): string;
+    getConnectionName(): "mysql" | "mysql2" | "sqlite3" | "oracle" | "mariadb" | "pg" | null;
+    getTable(): any;
+    setConnection(connection: TBaseConfig['client']): this;
+    getKeyType(): any;
+    hasNamedScope(name: string): boolean;
+    callNamedScope(scope: string, parameters: any): any;
+    setTable(table: string): this;
+    newCollection(models?: never[]): Collection<never>;
+    getIncrementing(): any;
+    setIncrementing(value: boolean): this;
+    toData(): {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    };
+    toJSON(): {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    };
+    toJson(...args: any[]): string;
+    toString(): string;
+    fill(attributes: TGeneric): this;
+    transacting(trx: any): this;
+    trashed(): boolean;
+    newPivot<E extends Model$1>(parent: E, attributes: TGeneric, table: string, exists: boolean, using?: typeof Pivot | null): Pivot;
+    qualifyColumn(column: string): string;
+    getQualifiedKeyName(): string;
+    is(model: any): any;
+    isNot(model: any): boolean;
+}
+declare class Pivot extends Model$1 {
+    incrementing: boolean;
+    guarded: never[];
+    pivotParent: Model$1 | null;
+    foreignKey: string | null;
+    relatedKey: string | null;
+    setPivotKeys(foreignKey: string, relatedKey: string): this;
+    static fromRawAttributes<E extends Model$1>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot;
+    static fromAttributes<E extends Model$1>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot;
+    hasTimestampAttributes(this: any, attributes?: TGeneric | null): boolean;
 }
 
+interface IAttribute {
+    get?: null | (<A extends TGeneric>(value: string, attr: A) => string);
+    set?: null | (<A extends TGeneric>(value: string, attr: A) => string | TGeneric);
+}
 declare class Attribute {
-    static make(get?: null, set?: null): Attribute;
-    static get(get: any): Attribute;
-    static set(set: any): Attribute;
-    constructor({ get, set }: {
-        get?: null | undefined;
-        set?: null | undefined;
-    });
-    get: any;
-    set: any;
+    get: IAttribute['get'];
+    set: IAttribute['set'];
     withCaching: boolean;
     withObjectCaching: boolean;
+    constructor({ get, set }: IAttribute);
+    static make({ get, set }: IAttribute): Attribute;
+    static get(get: IAttribute['get']): Attribute;
+    static set(set: IAttribute['set']): Attribute;
     withoutObjectCaching(): this;
     shouldCache(): this;
 }
 
-declare class CastsAttributes {
-    static get(): void;
-    static set(): void;
+interface ICastsAttributes {
+    get?(model: Model$2, key: string, value: string, attributes: TGeneric): string | null | undefined;
+    set?(model: Model$2, key: string, value: string, attributes: TGeneric): string | null | undefined;
+}
+declare class CastsAttributes implements ICastsAttributes {
+    constructor();
+    static get(_model: Model$2, _key: string, _value: string, _attributes: TGeneric): string | null | undefined;
+    static set(_model: Model$2, _key: string, _value: string, _attributes: TGeneric): string | null | undefined;
 }
 
-declare class Migration {
-    connection: any;
+declare const HasUniqueIds: <TBase extends MixinConstructor>(Model: TBase) => {
+    new (...args: any[]): {
+        [x: string]: any;
+        useUniqueIds: boolean;
+        uniqueIds(): any[];
+        getKeyType(): any;
+        getIncrementing(): any;
+    };
+} & TBase;
+
+interface IMigration {
+    withinTransaction?: boolean;
+    up(schema: SchemaBuilder, connection?: QueryBuilder): Promise<any>;
+    down(schema: SchemaBuilder, connection?: QueryBuilder): Promise<any>;
+    getConnection(): TBaseConfig['client'];
+}
+declare const Inference: {
+    new (): IMigration;
+};
+declare class Migration extends Inference {
+    protected connection: TBaseConfig['client'];
     withinTransaction: boolean;
-    getConnection(): any;
+    getConnection(): TBaseConfig['client'];
 }
 
-declare class Scope {
-    apply(builder: any, model: any): void;
+declare class MigrationRepository {
+    resolver: typeof arquebus;
+    table: string;
+    connection: TBaseConfig['client'] | null;
+    constructor(resolver: typeof arquebus, table: string);
+    getRan(): Promise<ICollection<any>>;
+    getMigrations(steps: number): Promise<any>;
+    getMigrationsByBatch(batch: number): Promise<any>;
+    getLast(): Promise<any>;
+    getMigrationBatches(): Promise<TGeneric>;
+    log(file: string, batch: number): Promise<void>;
+    delete(migration: TGeneric): Promise<void>;
+    getNextBatchNumber(): Promise<number>;
+    getLastBatchNumber(): Promise<number>;
+    createRepository(): Promise<void>;
+    repositoryExists(): Promise<boolean>;
+    deleteRepository(): Promise<void>;
+    getTable(): IQueryBuilder<Model$2, Model$2 | Model$2[]>;
+    getConnection(): QueryBuilder<Model$2, Model$2 | Model$2[]>;
+    setSource(name: TBaseConfig['client']): void;
+}
+
+interface MigrationOptions {
+    pretend?: boolean;
+    step?: number;
+    batch?: number;
+}
+declare class Migrator {
+    events: any;
+    repository: MigrationRepository;
+    files: any;
+    resolver: typeof arquebus;
+    connection: TBaseConfig['client'];
+    paths: string[];
+    output: boolean | null;
+    constructor(repository: MigrationRepository, resolver?: typeof arquebus | null, files?: any, dispatcher?: any);
+    run(paths?: string[], options?: MigrationOptions): Promise<string[]>;
+    pendingMigrations(files: Record<string, string>, ran: string[]): string[];
+    runPending(migrations: string[], options?: MigrationOptions): Promise<void>;
+    runUp(file: string, batch: number, _pretend: boolean): Promise<void>;
+    runDown(file: string, migration: {
+        migration: string;
+    }, _pretend: boolean): Promise<void>;
+    rollback(paths?: string[], options?: MigrationOptions): Promise<string[]>;
+    getMigrationsForRollback(options: MigrationOptions): Promise<{
+        migration: string;
+    }[]>;
+    rollbackMigrations(migrations: {
+        migration: string;
+    }[], paths: string[], options: MigrationOptions): Promise<string[]>;
+    reset(_paths?: string[], _pretend?: boolean): Promise<string[]> | string[];
+    resetMigrations(migrations: {
+        migration: string;
+    }[], paths: string[], pretend?: boolean): Promise<string[]>;
+    runMigration(migration: IMigration, method: 'up' | 'down'): Promise<void>;
+    runMethod(connection: QueryBuilder, migration: IMigration, method: 'up' | 'down'): Promise<void>;
+    resolvePath(filePath: string): Promise<IMigration>;
+    getMigrationClass(migrationName: string): string;
+    getMigrationFiles(paths: string[]): Promise<Record<string, string>>;
+    getMigrationName(filePath: string): string;
+    path(p: string): void;
+    getPaths(): string[];
+    getConnection(): TBaseConfig['client'];
+    resolveConnection(connection?: TBaseConfig['client']): any;
+    getRepository(): MigrationRepository;
+    repositoryExists(): Promise<boolean>;
+    hasRunAnyMigrations(): Promise<boolean>;
+    deleteRepository(): void;
+    setOutput(output: boolean): this;
+    write(...args: any[]): void;
+    writeTwoColumns(name: string, ...args: string[]): void;
+    writeTask(description: string, task: () => Promise<any> | any): Promise<void>;
 }
 
-declare function softDeletes(Model: any): {
-    new (): {
+interface MigrationStatus {
+    name: string;
+    ran: boolean;
+    batch: number | null;
+}
+interface MigrateOptions {
+    path?: string;
+    step?: number;
+    pretend?: boolean;
+    batch?: number;
+}
+interface TCallback {
+    (message: string, status?: 'success' | 'error' | 'info' | 'quiet'): void;
+}
+declare class Migrate {
+    private basePath?;
+    private customStubPath?;
+    private callback;
+    constructor(basePath?: string | undefined, customStubPath?: string | undefined, callback?: TCallback);
+    /**
+     * Runs all pending migrations
+     *
+     * @param config
+     * @param options
+     * @param destroyAll
+     */
+    run(config: TBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<void>;
+    /**
+     * Rollback the last migration
+     *
+     * @param config
+     * @param options
+     * @param destroyAll
+     */
+    rollback(config: TBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<void>;
+    /**
+     * Prepares the database for migration
+     *
+     * @param migrator
+     */
+    prepareDatabase(migrator: Migrator): Promise<void>;
+    /**
+     * Check the status of available migrations
+     *
+     * @param config
+     * @param options
+     * @param destroyAll
+     * @returns
+     */
+    status(config: TBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<MigrationStatus[]>;
+    /**
+     * Setup the database connection
+     *
+     * @param config
+     * @returns
+     */
+    setupConnection(config: TBaseConfig): Promise<{
+        arquebus: typeof arquebus;
+        migrator: Migrator;
+    }>;
+}
+
+declare const softDeletes: <TBase extends MixinConstructor>(Model: TBase) => {
+    new (...args: any[]): {
         [x: string]: any;
         forceDeleting: boolean;
-        initialize(): void;
+        initialize(this: typeof Model.prototype): void;
         initializeSoftDeletes(): void;
         forceDelete(): Promise<any>;
         forceDeleteQuietly(): any;
         performDeleteOnModel(options?: {}): Promise<any>;
-        exists: boolean | undefined;
         runSoftDelete(options?: {}): Promise<void>;
         restore(options?: {}): Promise<any>;
         restoreQuietly(): any;
         trashed(): boolean;
         isForceDeleting(): boolean;
-        getDeletedAtColumn(): any;
+        getDeletedAtColumn(this: typeof Model.prototype): any;
         getQualifiedDeletedAtColumn(): any;
     };
-    [x: string]: any;
-    bootSoftDeletes(): void;
-    softDeleted(callback: any): void;
-    restoring(callback: any): void;
-    restored(callback: any): void;
-    forceDeleting(callback: any): void;
-    forceDeleted(callback: any): void;
-};
+    bootSoftDeletes(this: typeof Model.prototype): void;
+    softDeleted(this: typeof Model.prototype, callback: TFunction): void;
+    restoring(this: typeof Model.prototype, callback: TFunction): void;
+    restored(this: typeof Model.prototype, callback: TFunction): void;
+    forceDeleting(this: typeof Model.prototype, callback: TFunction): void;
+    forceDeleted(this: typeof Model.prototype, callback: TFunction): void;
+} & TBase;
 
-declare function HasUniqueIds(Model: any): {
-    new (): {
-        [x: string]: any;
-        useUniqueIds: boolean;
-        uniqueIds(): any[];
-        getKeyType(): any;
-        getIncrementing(): any;
-    };
-    [x: string]: any;
+declare class BaseError extends Error {
+    constructor(message: string, _entity?: any);
+}
+declare class ModelNotFoundError extends BaseError {
+    model?: IModel;
+    ids: (string | number)[] | string | number;
+    constructor();
+    setModel(model: IModel, ids?: never[]): this;
+    getModel(): IModel | undefined;
+    getIds(): string | number | (string | number)[];
+}
+declare class RelationNotFoundError extends BaseError {
+}
+declare class InvalidArgumentError extends BaseError {
+}
+
+/**
+ * Helper type to extract instance type from constructor or mixin function
+ */
+type Constructor<T = TGeneric> = MixinConstructor<T>;
+type Mixin<TBase extends Constructor> = (Base: TBase) => Constructor;
+/**
+ * Helper type to convert union to intersection
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Helper type to get static side of a constructor
+ */
+type Static<T> = {
+    [K in keyof T]: T[K];
 };
+/**
+ * Compose function that merges multiple classes and mixins
+ *
+ * @example
+ * const SomePlugin = <TBase extends new (...args: any[]) => TGeneric> (Base: TBase) => {
+ *     return class extends Base {
+ *         pluginAttribtue = 'plugin'
+ *         pluginMethod () {
+ *             return this.pluginAttribtue
+ *         }
+ *     }
+ * }
+ *
+ * // Base class
+ * class Model {
+ *     make () {
+ *         console.log('make')
+ *     }
+ *     pluginMethod (id: string) {
+ *     }
+ * }
+ *
+ * class User extends compose(
+ *     Model,
+ *     SomePlugin,
+ * ) {
+ *     relationPosts () {
+ *         return 'hasMany Posts'
+ *     }
+ * }
+ *
+ * const user = new User()
+ * user.make() // from Model
+ * user.pluginMethod() // from SomePlugin
+ * user.relationPosts() // from User
+ *
+ * console.log(user.pluginMethod('w')) // "plugin"
+ * console.log(user.pluginMethod()) // "plugin"
+ * console.log(user.relationPosts()) // "hasMany Posts"
+ *
+ * @param Base
+ * @param mixins
+ * @returns
+ */
+declare function compose$1<TBase extends Constructor, TMixins extends Array<Mixin<any> | Constructor>>(Base: TBase, ...mixins: TMixins): Constructor<InstanceType<TBase> & UnionToIntersection<{
+    [K in keyof TMixins]: TMixins[K] extends Mixin<any> ? InstanceType<ReturnType<TMixins[K]>> : TMixins[K] extends Constructor ? InstanceType<TMixins[K]> : never;
+}[number]>> & UnionToIntersection<{
+    [K in keyof TMixins]: TMixins[K] extends Mixin<any> ? Static<ReturnType<TMixins[K]>> : TMixins[K] extends Constructor ? Static<TMixins[K]> : never;
+}[number]> & Static<TBase>;
 
-declare function migrateRun(config: any, options?: {}, destroyAll?: boolean): Promise<void>;
-declare function migrateRollback(config: any, options?: {}, destroyAll?: boolean): Promise<void>;
-declare function migrateStatus(config: any, options?: {}, destroyAll?: boolean): Promise<{
-    name: string;
-    ran: any;
-    batch: any;
-}[]>;
+declare const now: (format?: string) => string;
+declare const getRelationName: (relationMethod: string) => string;
+declare const getScopeName: (scopeMethod: string) => string;
+declare const getRelationMethod: (relation: string) => string;
+declare const getScopeMethod: (scope: string) => string;
+declare const getAttrMethod: (attr: string) => string;
+declare const getGetterMethod: (attr: string) => string;
+declare const getSetterMethod: (attr: string) => string;
+declare const getAttrName: (attrMethod: string) => string;
+/**
+ * Tap into a model a collection instance
+ *
+ * @param instance
+ * @param callback
+ * @returns
+ */
+declare const tap: <I>(instance: I, callback: (ins: I) => Promise<I> | I) => Promise<I> | I;
+declare const compose: typeof compose$1;
+declare const flattenDeep: (arr: any) => any;
+declare const kebabCase: (str: string) => string;
+declare const snakeCase: (str: string) => string;
+declare const defineConfig: (config: TConfig) => XGeneric<TConfig>;
 
-declare function make(model: any, data: any, options?: {}): any;
-declare function makeCollection(model: any, data: any): Collection;
-declare function makePaginator(model: any, data: any): Paginator;
+declare const make: (model: Model$2, data: TGeneric, options?: {
+    paginated: IPaginatorParams;
+}) => any;
+declare const makeCollection: (model: Model$2, data: TGeneric) => Collection$1<Model$2 | Model$1>;
+declare const makePaginator: (model: Model$2, data: TGeneric) => Paginator<Model$2, IPaginatorParams>;
 
-export { Attribute, Builder, CastsAttributes, Collection, HasUniqueIds, InvalidArgumentError, Migration, Model, ModelNotFoundError, Paginator, Pivot, QueryBuilder, RelationNotFoundError, Scope, softDeletes as SoftDeletes, arquebus, compose, flattenDeep, getAttrMethod, getAttrName, getGetterMethod, getRelationMethod, getRelationName, getScopeMethod, getScopeName, getSetterMethod, kebabCase, make, makeCollection, makePaginator, migrateRollback, migrateRun, migrateStatus, now, snakeCase, tap };
+export { Attribute, Builder, CastsAttributes, Collection$1 as Collection, HasUniqueIds, InvalidArgumentError, Migrate, Migration, Model$2 as Model, ModelNotFoundError, Paginator, Pivot$1 as Pivot, QueryBuilder, RelationNotFoundError, Scope, softDeletes as SoftDeletes, arquebus, compose, defineConfig, flattenDeep, getAttrMethod, getAttrName, getGetterMethod, getRelationMethod, getRelationName, getScopeMethod, getScopeName, getSetterMethod, kebabCase, make, makeCollection, makePaginator, now, snakeCase, tap };