@h3ravel/arquebus 0.3.1 → 0.3.3

package/dist/index.d.ts

@@ -1,183 +1,467 @@
-import { Collection as Collection$2 } from 'collect.js';
-import Knex$1, { Knex } from 'knex';
+import { Collection as Collection$1 } from "collect.js";
+import Knex$1, { Knex } from "knex";
 
-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>;
-}
+//#region src/collection.d.ts
 
+declare class Collection<I extends Model$1 | Model$2> extends Collection$1<I> implements ICollection<I> {
+  private newConstructor;
+  getConstructor<T extends typeof Collection<I>>(this: InstanceType<T>): T;
+  load(...relations: I[]): Promise<Collection<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>;
+}
+//#endregion
+//#region types/utils.d.ts
+interface ICollection<T extends Model$1 | Model$2> extends Collection$1<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$1 | Model$2, K extends IPaginatorParams = IPaginatorParams> {
+  formatter?(paginator: IPaginator<any>): any | null;
+  setFormatter?(formatter: (paginator: IPaginator<any>) => any | null): void;
+  setItems(items: T[] | Collection<T>): void;
+  hasMorePages(): boolean;
+  get(index: number): T | null;
+  count(): number;
+  items(): Collection<T>;
+  map(callback: (value: T, index: number) => T): Collection<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;
+    };
+  };
+}
+//#endregion
+//#region src/paginator.d.ts
+declare class Paginator<T extends Model$1, K extends IPaginatorParams = IPaginatorParams> implements IPaginator<T, K> {
+  static formatter: (paginator: IPaginator<any>) => any | null;
+  _items: Collection<T>;
+  _total: number;
+  _perPage: number;
+  _lastPage: number;
+  _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: number): T | null;
+  count(): number;
+  items(): Collection<T>;
+  map(callback: (value: T, index: number) => T): Collection<T>;
+  currentPage(): number;
+  onFirstPage(): boolean;
+  perPage(): number;
+  lastPage(): number;
+  total(): number;
+  toData(): any;
+  toJSON(): any;
+  toJson(...args: any[]): string;
+}
+//#endregion
+//#region src/scope.d.ts
+declare class Scope<M extends Model$1 = Model$1> implements IScope {
+  constructor();
+  apply(_builder: Builder<M>, _model: M): void;
+}
+//#endregion
+//#region src/builder.d.ts
+declare const Inference$2: {
+  new <M extends Model$1 = Model$1, R = IModel | ICollection<M>>(): IBuilder<M, R>;
+};
+declare class Builder<M extends Model$1 = Model$1, R = IModel | ICollection<M>> extends Inference$2 {
+  query: IBuilder<M, R>;
+  connection: 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<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 (void 0).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(): IBuilder<M, R>;
+  getModel(): M;
+  setModel<MO extends Model$1>(model: MO): this;
+  qualifyColumn(column: string): string;
+  setTable(table: string): this;
+  applyScopes(): this;
+  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?: TFunction | null): any;
+  orHas(relation: any, operator?: string, count?: number): any;
+  doesntHave(relation: any, boolean?: string, callback?: TFunction | null): any;
+  orDoesntHave(relation: any): 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?: 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): this;
+  selectSub(query: Builder<M>, as: string): any;
+  createSub(query: any): any[];
+  parseSub(query: any): any[];
+  prependDatabaseNameIfCrossDatabaseQuery(query: any): any;
+  getRelationWithoutConstraints(relation: string): any;
+  withCount(...args: 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: 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<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<M>): Promise<number>;
+  get<M extends Model$1>(columns?: string | string[]): Promise<Collection<M>>;
+  all(columns?: string[]): Promise<any>;
+  paginate(this: any, page?: number, perPage?: number): Promise<Paginator<any, IPaginatorParams>>;
+  getModels(...columns: any[]): Promise<any[]>;
+  getRelation(name: string): any;
+  relationsNestedUnder(relation: string): TGeneric;
+  isNestedUnder(relation: string, name: string): boolean;
+  eagerLoadRelation<M extends Model$1>(models: M[], name: string, constraints: any): Promise<any>;
+  eagerLoadRelations<M extends Model$1>(models: M[]): Promise<M[]>;
+  hydrate(items: any[]): Collection<any>;
+}
+//#endregion
+//#region types/query-builder.d.ts
 interface SchemaBuilder extends Knex.SchemaBuilder {
-    [k: string]: any;
+  [k: string]: any;
 }
 interface AsMethod<QB extends AnyQueryBuilder> {
-    (alias: string): QB;
+  (alias: string): QB;
 }
 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>>;
-}
-
+  grouping: string;
+  direction: string;
+  type: string;
+  value: () => any;
+  not: boolean;
+  nulls: boolean;
+  bool: 'and' | 'or' | 'not';
+}
+interface IQueryBuilder<M extends Model$1 | Model$2 = Model$1, 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$1 = 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>>;
+}
+//#endregion
+//#region types/builder.d.ts
+interface IScope {
+  apply(builder: Builder<any>, model: Model$1): void;
+}
+interface IBuilder<M extends Model$1 | Model$2, 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$1 = 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;
+}
+//#endregion
+//#region types/query-methods.d.ts
 type Operator = string;
 type ColumnRef = string | Raw;
 type FieldExpression = string;
@@ -185,1206 +469,951 @@ type TableRef<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | Callba
 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;
+  (this: T, arg: T): void;
 }
 type Raw = Knex.Raw;
 type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
 interface OrderByDescriptor {
-    column: ColumnRef;
-    order?: OrderByDirection;
+  column: ColumnRef;
+  order?: OrderByDirection;
 }
-type AnyQueryBuilder<M extends Model$2 = any, R = any> = IQueryBuilder<M, R> | IBuilder<M, R>;
+type AnyQueryBuilder<M extends Model$1 = 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;
+  (sql: string, ...bindings: any[]): R;
 }
 interface BaseSetOperations<QB extends AnyQueryBuilder> {
-    (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB;
-    (callbacksOrBuilders: QBOrCallback<QB>[], wrap?: boolean): QB;
+  (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;
+  (...columns: ColumnRef[]): QB;
+  (columns: ColumnRef[]): QB;
 }
 type WithRelationType = {
-    [key: string]: <T extends IBuilder<any>>(builder: T) => T | void;
+  [key: string]: <T extends IBuilder<any>>(builder: T) => T | void;
 } | string | string[];
 interface SetOperationsMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
-    (...callbacksOrBuilders: QBOrCallback<QB>[]): QB;
+  (...callbacksOrBuilders: QBOrCallback<QB>[]): QB;
 }
 interface SelectMethod<QB extends AnyQueryBuilder> {
-    <QBP extends QB>(...columns: Selection<QBP>[]): QB;
-    <QBP extends QB>(columns: Selection<QBP>[]): QB;
+  <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;
+  (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;
+  (cb: CallbackVoid<QB>): QB;
 }
 interface WhereFieldExpressionMethod<QB extends AnyQueryBuilder> {
-    (fieldExpression: FieldExpression): QB;
+  (fieldExpression: FieldExpression): QB;
 }
 interface WhereExistsMethod<QB extends AnyQueryBuilder> {
-    (cb: CallbackVoid<QB>): QB;
-    (raw: Raw): QB;
-    <QBA extends AnyQueryBuilder>(qb: QBA): QB;
+  (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;
+  (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;
+  (column: ColumnRef, range: [Expression<PrimitiveValue>, Expression<PrimitiveValue>]): QB;
 }
 interface WhereNullMethod<QB extends AnyQueryBuilder> {
-    (column: ColumnRef): QB;
+  (column: ColumnRef): QB;
 }
 interface OrderByMethod<QB extends AnyQueryBuilder> {
-    (column: ColumnRef, order?: OrderByDirection): QB;
-    (columns: ColumnRefOrOrderByDescriptor[]): QB;
+  (column: ColumnRef, order?: OrderByDirection): QB;
+  (columns: ColumnRefOrOrderByDescriptor[]): QB;
 }
 interface WhereJsonExpressionMethod<QB extends AnyQueryBuilder> {
-    (fieldExpression: FieldExpression, keys: string | string[]): QB;
+  (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;
+  (col1: ColumnRef, op: Operator, col2: ColumnRef): QB;
+  (col1: ColumnRef, col2: ColumnRef): 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;
+  (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;
+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;
 }
-
-declare const Inference$2: {
-    new <M extends Model$2 = Model$2, R = M[] | M>(): IQueryBuilder<M, R>;
+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;
+}
+//#endregion
+//#region src/query-builder.d.ts
+declare const Inference$1: {
+  new <M extends Model$1 = Model$1, 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 QueryBuilder<M extends Model$1 = Model$1, R = M[] | M> extends Inference$1<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 (void 0).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 (void 0).connector.insert>): Promise<unknown>;
+  update(...args: Parameters<typeof (void 0).connector.update>): Promise<number>;
+  destroy(...args: Parameters<typeof (void 0).connector.destroy>): Promise<number>;
+  get _statements(): IStatement[] & any[];
+  get _single(): any;
+  get from(): Knex.Table<any, any>;
+}
+//#endregion
+//#region src/relations/relation.d.ts
 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;
-}
-
+  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;
+}
+//#endregion
+//#region types/container.d.ts
 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;
-    };
+  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: 'pg';
+  connection: Knex.PgConnectionConfig;
 } | {
-    client: 'oracle';
-    connection: Knex.OracleDbConnectionConfig;
+  client: 'oracle';
+  connection: Knex.OracleDbConnectionConfig;
 } | {
-    client: 'mysql2';
-    connection: Knex.MySql2ConnectionConfig;
+  client: 'mysql2';
+  connection: Knex.MySql2ConnectionConfig;
 } | {
-    client: 'mysql';
-    connection: Knex.MySqlConnectionConfig;
+  client: 'mysql';
+  connection: Knex.MySqlConnectionConfig;
 } | {
-    client: 'sqlite3';
-    connection: Knex.Sqlite3ConnectionConfig;
-    useNullAsDefault?: boolean;
+  client: 'sqlite3';
+  connection: Knex.Sqlite3ConnectionConfig;
+  useNullAsDefault?: boolean;
 } | {
-    client: 'mariadb';
-    connection: Knex.MariaSqlConnectionConfig;
-    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 ModelOptions<M extends Model$1 = Model$1> {
+  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$1['with'];
+  casts?: Model$1['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;
-}
-
+  type: 'VAR_STRING' | 'BLOB' | 'DATETIME' | 'TIMESTAMP' | 'LONG' | 'JSON';
+  length: number;
+  db: string;
+  table: string;
+  name: string;
+  string: TFunction;
+  buffer: TFunction;
+  geometry: TFunction;
+}
+//#endregion
+//#region types/modeling.d.ts
 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;
+  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$1> = IBuilder<M, any> & {};
+interface HasOneOrMany<M extends Model$1> 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$1> extends HasOneOrMany<M> {
+  getResults(): Promise<M | null>;
+  withDefault(callback?: TFunction | object): this;
+}
+interface HasMany<M extends Model$1> extends HasOneOrMany<M> {
+  getResults(): Promise<ICollection<M>>;
+}
+interface BelongsTo<M extends Model$1> extends Relation<M> {
+  getResults(): Promise<M | null>;
+  withDefault(callback?: TFunction | object): this;
+}
+interface BelongsToMany<M extends Model$1> 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<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: 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: 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(): number;
-    toData(): any;
-    toJSON(): any;
-    toJson(...args: any[]): string;
-}
-
-declare class Scope<M extends Model$2 = Model$2> implements IScope {
-    constructor();
-    apply(_builder: Builder<M>, _model: M): void;
-}
-
-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: 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<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(): 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: 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?: TFunction | null): any;
-    orHas(relation: any, operator?: string, count?: number): any;
-    doesntHave(relation: any, boolean?: string, callback?: TFunction | null): any;
-    orDoesntHave(relation: any): 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?: 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): this;
-    selectSub(query: Builder<M>, as: string): any;
-    createSub(query: any): any[];
-    parseSub(query: any): any[];
-    prependDatabaseNameIfCrossDatabaseQuery(query: any): any;
-    getRelationWithoutConstraints(relation: string): any;
-    withCount(...args: 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: 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: 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>;
-    /**
-     * Initialize a new database connection
-     *
-     * @returns
-     */
-    static fire<C extends TBaseConfig['client']>(connection?: C | null): QueryBuilder<Model$2>;
-    /**
-     * Initialize a new database connection
-     *
-     * This is an alias of `arquebus.fire()` and will be removed in the future
-     *
-     * @deprecated since version 0.3.0
-     * @alias fire
-     *
-     * @returns
-     */
-    static connection<C extends TBaseConfig['client']>(connection?: C | 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;
-    /**
-     * Autoload the config file
-     *
-     * @param addConnection
-     * @default true
-     * If set to `false` we will no attempt add the connection, we
-     * will just go ahead and return the config
-     *
-     * @returns
-     */
-    static autoLoad(addConnection?: boolean): Promise<TBaseConfig>;
-    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;
-}
-
+  [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$1>>;
+  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$1>;
+  on<T extends {
+    prototype: unknown;
+  }>(this: T, connection: string | null): IBuilder<Model$1>;
+  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$1>(relation: string): T | ICollection<T> | null | undefined;
+  setRelation<T extends Model$1>(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$1>;
+  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$1>(model: new () => T, foreignKey?: string, localKey?: string): HasOne<T>;
+  hasMany<T extends Model$1>(model: new () => T, foreignKey?: string, localKey?: string): HasMany<T>;
+  belongsTo<T extends Model$1>(model: new () => T, foreignKey?: string, ownerKey?: string, relation?: string): BelongsTo<T>;
+  belongsToMany<T extends Model$1>(model: new () => T, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToMany<T>;
+}
+//#endregion
+//#region src/arquebus.d.ts
+declare class arquebus<M extends Model$1 = Model$1> {
+  static connectorFactory: typeof Knex$1 | null;
+  static instance: arquebus | null;
+  manager: Record<string, QueryBuilder<M>>;
+  connections: Record<string, TConfig>;
+  models: Record<string, typeof Model$1>;
+  constructor();
+  getConstructor<T extends typeof arquebus>(this: InstanceType<T>): T;
+  static getInstance(): arquebus<Model$1>;
+  /**
+   * Initialize a new database connection
+   *
+   * @returns
+   */
+  static fire<C extends TBaseConfig['client']>(connection?: C | null): QueryBuilder<Model$1>;
+  /**
+   * Initialize a new database connection
+   *
+   * This is an alias of `arquebus.fire()` and will be removed in the future
+   *
+   * @deprecated since version 0.3.0
+   * @alias fire
+   *
+   * @returns
+   */
+  static connection<C extends TBaseConfig['client']>(connection?: C | null): QueryBuilder<Model$1, Model$1 | Model$1[]>;
+  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$1, Model$1 | Model$1[]>;
+  static schema(connection?: null): SchemaBuilder;
+  static destroyAll(): Promise<void>;
+  static createModel<X extends TGeneric>(name: string, options: X): typeof Model$1;
+  connection(connection?: string | null): QueryBuilder<M, M | M[]>;
+  getConnection(name?: string | null): QueryBuilder<M, M | M[]>;
+  addConnection(config: TConfig | TBaseConfig, name?: string): void;
+  /**
+   * Autoload the config file
+   *
+   * @param addConnection
+   * @default true
+   * If set to `false` we will no attempt add the connection, we
+   * will just go ahead and return the config
+   *
+   * @returns
+   */
+  static autoLoad(addConnection?: boolean): Promise<TBaseConfig>;
+  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$1;
+}
+//#endregion
+//#region src/model.d.ts
 declare const BaseModel$1: (new (...args: any[]) => any) & {
-    [x: string]: 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: 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: arquebus): void;
-    initialize(): void;
-    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(): "mysql" | "mysql2" | "sqlite3" | "oracle" | "mariadb" | "pg";
-    getTable(): string;
-    getConnection(this: any): any;
-    setConnection(connection: TBaseConfig['client'] | null): this;
-    getKeyType(): string;
-    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;
-        [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;
-    getIncrementing(): boolean;
-    setIncrementing(value: boolean): this;
-    save(options?: TGeneric): Promise<boolean>;
-    update(attributes?: TGeneric, options?: TGeneric): Promise<boolean>;
-    delete(options?: {}): Promise<boolean>;
-    performDeleteOnModel(options?: TGeneric): Promise<void>;
-    setKeysForSaveQuery(query: any): any;
-    forceDelete(options?: {}): Promise<boolean>;
-    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$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;
+declare class Model$1 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: arquebus;
+  connection: TBaseConfig['client'] | null;
+  eagerLoad: {};
+  exists: boolean;
+  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$1>>;
+  trx: null;
+  constructor(attributes?: {});
+  static query(trx?: null): Builder<Model$1, IModel | ICollection<Model$1>>;
+  static on(connection?: TBaseConfig['client'] | null): Builder<Model$1, IModel | ICollection<Model$1>>;
+  static init(attributes?: {}): Model$1;
+  static extend(plugin: TFunction, options: TGeneric): void;
+  static make(attributes?: TGeneric): Model$1;
+  getConstructor<T extends typeof Model$1>(this: InstanceType<T>): T;
+  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;
+  newFromBuilder(attributes?: TGeneric, connection?: null): any;
+  asProxy(): this;
+  getKey(): any;
+  getKeyName(): string;
+  getForeignKey(): string;
+  getConnectionName(): "mysql" | "mysql2" | "sqlite3" | "oracle" | "mariadb" | "pg";
+  getTable(): string;
+  getConnection(this: any): any;
+  setConnection(connection: TBaseConfig['client'] | null): this;
+  getKeyType(): string;
+  newQuery(trx?: null): Builder<Model$1, IModel | ICollection<Model$1>>;
+  newQueryWithoutScopes(trx?: null): Builder<Model$1, IModel | ICollection<Model$1>>;
+  newModelQuery(trx?: null): Builder<Model$1, IModel | ICollection<Model$1>>;
+  addGlobalScopes(this: any, builder: Builder<Model$1>): Builder<Model$1, IModel | ICollection<Model$1>>;
+  hasNamedScope(name: string): boolean;
+  callNamedScope(scope: string, parameters: any[]): any;
+  setTable(table: string): this;
+  newCollection(this: any, models?: never[]): Collection<Model$1>;
+  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;
+    [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;
+  getIncrementing(): boolean;
+  setIncrementing(value: boolean): this;
+  save(options?: TGeneric): Promise<boolean>;
+  update(attributes?: TGeneric, options?: TGeneric): Promise<boolean>;
+  delete(options?: {}): Promise<boolean>;
+  performDeleteOnModel(options?: TGeneric): Promise<void>;
+  setKeysForSaveQuery(query: any): any;
+  forceDelete(options?: {}): Promise<boolean>;
+  fresh(this: any): any;
+  refresh(this: any): Promise<any>;
+  newPivot<E extends Model$1>(parent: E, attributes: TGeneric, table: string, exists: boolean, using?: typeof Pivot | null): Pivot;
+  qualifyColumn(column: string): string;
+  getQualifiedKeyName(): string;
+  push(options?: {}): Promise<boolean>;
+  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;
+}
+//#endregion
+//#region types/generics.d.ts
 type TGeneric<V = any, K extends string = string> = Record<K, V>;
 type XGeneric<V = TGeneric, T = any> = {
-    [key: string]: T;
+  [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 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 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) & {
+//#endregion
+//#region src/browser/collection.d.ts
+declare class Collection$2<I extends Model$2> extends Collection$1<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>;
+}
+//#endregion
+//#region src/browser/model.d.ts
+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;
+declare class Model$2 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$2;
+  static extend(plugin: TFunction, options: TGeneric): void;
+  static make(attributes?: TGeneric): Model$2;
+  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$2<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$2>(parent: E, attributes: TGeneric, table: string, exists: boolean, using?: typeof Pivot$1 | null): Pivot$1;
+  qualifyColumn(column: string): string;
+  getQualifiedKeyName(): string;
+  is(model: any): any;
+  isNot(model: any): 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;
+}
+//#endregion
+//#region src/casts/attribute.d.ts
 interface IAttribute {
-    get?: null | (<A extends TGeneric>(value: string, attr: A) => string);
-    set?: null | (<A extends TGeneric>(value: string, attr: A) => string | TGeneric);
+  get?: null | (<A extends TGeneric>(value: string, attr: A) => string);
+  set?: null | (<A extends TGeneric>(value: string, attr: A) => string | TGeneric);
 }
 declare class Attribute {
-    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;
-}
-
+  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;
+}
+//#endregion
+//#region src/casts-attributes.d.ts
 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;
+  get?(model: Model$1, key: string, value: string, attributes: TGeneric): string | null | undefined;
+  set?(model: Model$1, 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;
+  constructor();
+  static get(_model: Model$1, _key: string, _value: string, _attributes: TGeneric): string | null | undefined;
+  static set(_model: Model$1, _key: string, _value: string, _attributes: TGeneric): string | null | undefined;
 }
-
+//#endregion
+//#region src/concerns/has-unique-ids.d.ts
 declare const HasUniqueIds: <TBase extends MixinConstructor>(Model: TBase) => {
-    new (...args: any[]): {
-        [x: string]: any;
-        useUniqueIds: boolean;
-        uniqueIds(): any[];
-        getKeyType(): any;
-        getIncrementing(): any;
-    };
+  new (...args: any[]): {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    uniqueIds(): any[];
+    getKeyType(): any;
+    getIncrementing(): any;
+  };
 } & TBase;
-
+//#endregion
+//#region src/migrations/migration.d.ts
 interface IMigration {
-    withinTransaction?: boolean;
-    up(schema: SchemaBuilder, connection?: QueryBuilder): Promise<any>;
-    down(schema: SchemaBuilder, connection?: QueryBuilder): Promise<any>;
-    getConnection(): TBaseConfig['client'];
+  withinTransaction?: boolean;
+  up(schema: SchemaBuilder, connection?: QueryBuilder): Promise<any>;
+  down(schema: SchemaBuilder, connection?: QueryBuilder): Promise<any>;
+  getConnection(): TBaseConfig['client'];
 }
 declare const Inference: {
-    new (): IMigration;
+  new (): IMigration;
 };
 declare class Migration extends Inference {
-    protected connection: TBaseConfig['client'];
-    withinTransaction: boolean;
-    getConnection(): TBaseConfig['client'];
+  protected connection: TBaseConfig['client'];
+  withinTransaction: boolean;
+  getConnection(): TBaseConfig['client'];
 }
-
+//#endregion
+//#region src/migrations/migration-repository.d.ts
 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;
-}
-
+  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$1, Model$1 | Model$1[]>;
+  getConnection(): QueryBuilder<Model$1, Model$1 | Model$1[]>;
+  setSource(name: TBaseConfig['client']): void;
+}
+//#endregion
+//#region src/migrations/migrator.d.ts
 interface MigrationOptions {
-    pretend?: boolean;
-    step?: number;
-    batch?: number;
+  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>;
-}
-
+  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;
+  writeTask(description: string, task: () => Promise<any> | any): Promise<void>;
+}
+//#endregion
+//#region src/migrate.d.ts
 interface MigrationStatus {
-    name: string;
-    ran: boolean;
-    batch: number | null;
+  name: string;
+  ran: boolean;
+  batch: number | null;
 }
 interface MigrateOptions {
-    path?: string;
-    step?: number;
-    pretend?: boolean;
-    batch?: number;
+  path?: string;
+  step?: number;
+  pretend?: boolean;
+  batch?: number;
 }
 type TXBaseConfig<S = boolean> = (S extends true ? Partial<TBaseConfig> : TBaseConfig) & {
-    /**
-     * Set this to true if you already have an active connection and dont want to create a new one
-     */
-    skipConnection?: S;
+  /**
+   * Set this to true if you already have an active connection and dont want to create a new one
+   */
+  skipConnection?: S;
 };
 interface TCallback {
-    (message: string, status?: 'success' | 'error' | 'info' | 'quiet'): void;
+  (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: TXBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<void>;
-    /**
-     * Rollback the last migration
-     *
-     * @param config
-     * @param options
-     * @param destroyAll
-     */
-    rollback(config: TXBaseConfig, 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: TXBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<MigrationStatus[]>;
-    /**
-     * Setup the database connection
-     *
-     * @param config
-     * @returns
-     */
-    setupConnection(config: TXBaseConfig): Promise<{
-        arquebus: typeof arquebus;
-        migrator: Migrator;
-    }>;
-}
-
+  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: TXBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<void>;
+  /**
+   * Rollback the last migration
+   *
+   * @param config
+   * @param options
+   * @param destroyAll
+   */
+  rollback(config: TXBaseConfig, 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: TXBaseConfig, options?: MigrateOptions, destroyAll?: boolean): Promise<MigrationStatus[]>;
+  /**
+   * Setup the database connection
+   *
+   * @param config
+   * @returns
+   */
+  setupConnection(config: TXBaseConfig): Promise<{
+    arquebus: typeof arquebus;
+    migrator: Migrator;
+  }>;
+}
+//#endregion
+//#region src/soft-deletes.d.ts
 declare const softDeletes: <TBase extends MixinConstructor>(Model: TBase) => {
-    new (...args: any[]): {
-        [x: string]: any;
-        forceDeleting: boolean;
-        initialize(this: typeof Model.prototype): void;
-        initializeSoftDeletes(): void;
-        forceDelete(): Promise<any>;
-        forceDeleteQuietly(): any;
-        performDeleteOnModel(options?: {}): Promise<any>;
-        runSoftDelete(options?: {}): Promise<void>;
-        restore(options?: {}): Promise<any>;
-        restoreQuietly(): any;
-        trashed(): boolean;
-        isForceDeleting(): boolean;
-        getDeletedAtColumn(this: typeof Model.prototype): any;
-        getQualifiedDeletedAtColumn(): any;
-    };
-    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;
+  new (...args: any[]): {
+    [x: string]: any;
+    forceDeleting: boolean;
+    initialize(this: typeof Model.prototype): void;
+    initializeSoftDeletes(): void;
+    forceDelete(): Promise<any>;
+    forceDeleteQuietly(): any;
+    performDeleteOnModel(options?: {}): Promise<any>;
+    runSoftDelete(options?: {}): Promise<void>;
+    restore(options?: {}): Promise<any>;
+    restoreQuietly(): any;
+    trashed(): boolean;
+    isForceDeleting(): boolean;
+    getDeletedAtColumn(this: typeof Model.prototype): any;
+    getQualifiedDeletedAtColumn(): any;
+  };
+  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;
-
+//#endregion
+//#region src/errors.d.ts
 declare class BaseError extends Error {
-    constructor(message: string, _entity?: any);
+  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 {
-}
-
+  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 {}
+//#endregion
+//#region src/mixin.d.ts
 /**
  * Helper type to extract instance type from constructor or mixin function
  */
@@ -1393,13 +1422,11 @@ 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;
+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];
-};
+type Static<T> = { [K in keyof T]: T[K] };
 /**
  * Compose function that merges multiple classes and mixins
  *
@@ -1444,12 +1471,9 @@ type Static<T> = {
  * @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 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>;
+//#endregion
+//#region src/utils.d.ts
 declare const now: (format?: string) => string;
 declare const getRelationName: (relationMethod: string) => string;
 declare const getScopeName: (scopeMethod: string) => string;
@@ -1472,11 +1496,12 @@ 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 const make: (model: Model$2, data: TGeneric, options?: {
-    paginated: IPaginatorParams;
+//#endregion
+//#region src/index.d.ts
+declare const make: (model: Model$1, 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$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 };
+declare const makeCollection: (model: Model$1, data: TGeneric) => Collection<Model$1 | Model$2>;
+declare const makePaginator: (model: Model$1, data: TGeneric) => Paginator<Model$1, IPaginatorParams>;
+//#endregion
+export { Attribute, Builder, CastsAttributes, Collection, HasUniqueIds, InvalidArgumentError, Migrate, Migration, Model$1 as Model, ModelNotFoundError, Paginator, 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 };