@h3ravel/arquebus 0.6.6 → 0.6.8

package/dist/browser/index.d.cts

@@ -3,32 +3,32 @@ import Knex$1, { Knex } from "knex";
 import * as dayjs0 from "dayjs";
 
 //#region src/browser/collection.d.ts
-declare class Collection<I extends Model> extends Collection$1<I> {
+declare class Collection<I$1 extends Model$1> extends Collection$1<I$1> {
   mapThen(callback: TFunction): Promise<any[]>;
   modelKeys(): any[];
-  contains<K, V>(key: keyof I | K | TFunction, value?: V): boolean;
+  contains<K$1, V>(key: keyof I$1 | K$1 | 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;
+  intersect(items: I$1[]): any;
+  unique(key?: TFunction | keyof I$1, _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 | {
+  toData(): (I$1 | {
     [x: string]: any;
     [x: number]: any;
     [x: symbol]: any;
   })[];
-  toJSON(): (I | {
+  toJSON(): (I$1 | {
     [x: string]: any;
     [x: number]: any;
     [x: symbol]: any;
   })[];
   toJson(...args: any[]): string;
-  [Symbol.iterator]: () => Iterator<I>;
+  [Symbol.iterator]: () => Iterator<I$1>;
 }
 //#endregion
 //#region types/modeling.d.ts
@@ -42,25 +42,25 @@ interface Attribute$1 {
   withCaching?: boolean;
   withObjectCaching?: boolean;
 }
-type Relation$1<M extends Model$1> = IBuilder<M, any> & {};
-interface HasOneOrMany<M extends Model$1> extends Relation$1<M> {
+type Relation$1<M extends Model$2> = IBuilder<M, any> & {};
+interface HasOneOrMany<M extends Model$2> extends Relation$1<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> {
+interface HasOne<M extends Model$2> extends HasOneOrMany<M> {
   getResults(): Promise<M | null>;
   withDefault(callback?: TFunction | object): this;
 }
-interface HasMany<M extends Model$1> extends HasOneOrMany<M> {
+interface HasMany<M extends Model$2> extends HasOneOrMany<M> {
   getResults(): Promise<ICollection<M>>;
 }
-interface BelongsTo<M extends Model$1> extends Relation$1<M> {
+interface BelongsTo<M extends Model$2> extends Relation$1<M> {
   getResults(): Promise<M | null>;
   withDefault(callback?: TFunction | object): this;
 }
-interface BelongsToMany<M extends Model$1> extends Relation$1<M> {
+interface BelongsToMany<M extends Model$2> extends Relation$1<M> {
   getResults(): Promise<ICollection<M>>;
   withTimestamps(): this;
   wherePivot(column: any, operator?: any, value?: any, boolean?: string, ...args: any[]): this;
@@ -86,20 +86,20 @@ interface IModel {
   exists: boolean;
   connection?: TBaseConfig['client'] | null;
   perPage: number;
-  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$1>>;
+  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
   trx: AnyQueryBuilder | null;
   timestamps: boolean;
   dateFormat: string;
   visible: string[];
   hidden: string[];
-  query<T extends {
+  query<T$1 extends {
     prototype: unknown;
-  }>(this: T, client?: AnyQueryBuilder | null): IBuilder<Model$1>;
-  on<T extends {
+  }>(this: T$1, client?: AnyQueryBuilder | null): IBuilder<Model$2>;
+  on<T$1 extends {
     prototype: unknown;
-  }>(this: T, connection: string | null): IBuilder<Model$1>;
+  }>(this: T$1, connection: string | null): IBuilder<Model$2>;
   boot(): void;
-  make<T extends IModel>(this: new () => T, attributes?: TGeneric): T;
+  make<T$1 extends IModel>(this: new () => T$1, attributes?: TGeneric): T$1;
   addHook(hook: Hook, callback: TFunction): void;
   creating(callback: TFunction): void;
   created(callback: TFunction): void;
@@ -139,13 +139,13 @@ interface IModel {
   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;
+  getRelation<T$1 extends Model$2>(relation: string): T$1 | ICollection<T$1> | null | undefined;
+  setRelation<T$1 extends Model$2>(relation: string, value: T$1 | ICollection<T$1> | 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>;
+  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>;
@@ -187,32 +187,32 @@ interface IModel {
   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>;
+  related<T$1 extends RelationNames<this>>(relation: T$1): ReturnTypeOfMethod<this, `relation${Capitalize<SnakeToCamelCase<T$1>>}`>;
+  getRelated<T$1 extends RelationNames<this>>(relation: T$1): ReturnTypeOfMethod<ReturnTypeOfMethod<this, `relation${Capitalize<SnakeToCamelCase<T$1>>}`>, any>;
+  hasOne<T$1 extends Model$2>(model: new () => T$1, foreignKey?: string, localKey?: string): HasOne<T$1>;
+  hasMany<T$1 extends Model$2>(model: new () => T$1, foreignKey?: string, localKey?: string): HasMany<T$1>;
+  belongsTo<T$1 extends Model$2>(model: new () => T$1, foreignKey?: string, ownerKey?: string, relation?: string): BelongsTo<T$1>;
+  belongsToMany<T$1 extends Model$2>(model: new () => T$1, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToMany<T$1>;
 }
 //#endregion
 //#region src/collection.d.ts
-declare class Collection$2<I extends Model$1 | Model> extends Collection$1<I> implements ICollection<I> {
+declare class Collection$2<I$1 extends Model$2 | Model$1> extends Collection$1<I$1> implements ICollection<I$1> {
   private newConstructor;
-  getConstructor<T extends typeof Collection$2<I>>(this: InstanceType<T>): T;
-  load(...relations: (string[] | I[] | string | I)[]): Promise<Collection$2<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>;
+  getConstructor<T$1 extends typeof Collection$2<I$1>>(this: InstanceType<T$1>): T$1;
+  load(...relations: (string[] | I$1[] | string | I$1)[]): Promise<Collection$2<I$1>>;
+  loadAggregate<I$1>(relations: I$1, column: string, action?: string | null | TFunction): Promise<this>;
+  loadCount(relations: I$1): Promise<this>;
+  loadMax(relation: I$1, column: string): Promise<this>;
+  loadMin(relation: I$1, column: string): Promise<this>;
+  loadSum(relation: I$1, column: string): Promise<this>;
+  loadAvg(relation: I$1, column: string): Promise<this>;
   mapThen(callback: () => void): Promise<void[]>;
   modelKeys(): any[];
-  contains<K, V>(key: keyof I | K | TFunction, value?: V): boolean;
+  contains<K$1, V>(key: keyof I$1 | K$1 | 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;
+  intersect(items: I$1[]): any;
+  unique(key?: TFunction | keyof I$1, _strict?: boolean): any;
   find(key: any, defaultValue?: null): any;
   fresh(...args: any[]): Promise<any>;
   makeVisible(attributes: any): this;
@@ -225,20 +225,20 @@ declare class Collection$2<I extends Model$1 | Model> extends Collection$1<I> im
     [x: string]: any;
     [x: number]: any;
     [x: symbol]: any;
-  } | I)[];
+  } | I$1)[];
   toJSON(): ({
     [x: string]: any;
     [x: number]: any;
     [x: symbol]: any;
-  } | I)[];
+  } | I$1)[];
   toJson(...args: any[]): string;
-  [Symbol.iterator]: () => Iterator<I>;
+  [Symbol.iterator]: () => Iterator<I$1>;
 }
 //#endregion
 //#region src/paginator.d.ts
-declare class Paginator$1<T extends Model$1, K extends IPaginatorParams = IPaginatorParams> implements IPaginator<T, K> {
+declare class Paginator$1<T$1 extends Model$2, K$1 extends IPaginatorParams = IPaginatorParams> implements IPaginator<T$1, K$1> {
   static formatter: (paginator: IPaginator<any>) => any | null;
-  _items: Collection$2<T>;
+  _items: Collection$2<T$1>;
   _total: number;
   _perPage: number;
   _lastPage: number;
@@ -246,15 +246,15 @@ declare class Paginator$1<T extends Model$1, K extends IPaginatorParams = IPagin
   hasMore: boolean;
   options: TGeneric;
   static setFormatter(formatter?: ((paginator: IPaginator<any> | null) => any) | null): void;
-  constructor(items: T[], total: number, perPage: number, currentPage?: number, options?: TGeneric);
-  setItems(items: T[]): void;
+  constructor(items: T$1[], total: number, perPage: number, currentPage?: number, options?: TGeneric);
+  setItems(items: T$1[]): void;
   firstItem(): number | null;
   lastItem(): number | null;
   hasMorePages(): boolean;
-  get(index: number): T | null;
+  get(index: number): T$1 | null;
   count(): number;
-  items(): Collection$2<T>;
-  map(callback: (value: T, index: number) => T): Collection$2<T>;
+  items(): Collection$2<T$1>;
+  map(callback: (value: T$1, index: number) => T$1): Collection$2<T$1>;
   currentPage(): number;
   onFirstPage(): boolean;
   perPage(): number;
@@ -266,33 +266,33 @@ declare class Paginator$1<T extends Model$1, K extends IPaginatorParams = IPagin
 }
 //#endregion
 //#region src/scope.d.ts
-declare class Scope<M extends Model$1 = Model$1> implements IScope {
+declare class Scope<M extends Model$2 = Model$2> implements IScope {
   constructor();
   apply(_builder: Builder<M>, _model: M): void;
 }
 //#endregion
 //#region src/builder.d.ts
 declare const Inference$1: {
-  new <M extends Model$1 | Model = Model$1, R = IModel | ICollection<M>>(): IBuilder<M, R>;
+  new <M extends Model$2 | Model$1 = Model$2, R$1 = IModel | ICollection<M>>(): IBuilder<M, R$1>;
 };
-declare class Builder<M extends Model$1 = Model$1, R = IModel | ICollection<M>> extends Inference$1 {
-  query: IBuilder<M, R>;
+declare class Builder<M extends Model$2 = Model$2, R$1 = IModel | ICollection<M>> extends Inference$1 {
+  query: IBuilder<M, R$1>;
   connection: any;
   model: M;
   actions: any[];
-  localMacros: TGeneric<(...args: any[]) => any, keyof Omit<IBuilder<M, R>, number>>;
+  localMacros: TGeneric<(...args: any[]) => any, keyof Omit<IBuilder<M, R$1>, 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>;
+  globalScopes: TGeneric<Scope<M> | ((arg: Builder<M, R$1>) => Builder<M, R$1>)>;
+  onDeleteCallback?: (builder: Builder<M, R$1>) => Promise<boolean | number>;
+  constructor(query: IBuilder<M, R$1>);
+  asProxy(): Builder<M, R$1>;
   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.query.insert>): Promise<any>;
-  update<T extends TGeneric>(values: T): Promise<any>;
+  update<T$1 extends TGeneric>(values: T$1): Promise<any>;
   increment(column: string, amount?: number, extra?: {}): Promise<any>;
   decrement(column: string, amount?: number, extra?: {}): Promise<any>;
   addUpdatedAtColumn(values: TGeneric<string>): TGeneric<string>;
@@ -301,9 +301,9 @@ declare class Builder<M extends Model$1 = Model$1, R = IModel | ICollection<M>>
   forceDelete(): Promise<number | boolean>;
   create(attributes?: {}): Promise<any>;
   newModelInstance(attributes?: {}): any;
-  getQuery(): IBuilder<M, R>;
+  getQuery(): IBuilder<M, R$1>;
   getModel(): M;
-  setModel<MO extends Model$1>(model: MO): this;
+  setModel<MO extends Model$2>(model: MO): this;
   qualifyColumn(column: string): string;
   setTable(table: string): this;
   applyScopes(): this;
@@ -366,15 +366,15 @@ declare class Builder<M extends Model$1 = Model$1, R = IModel | ICollection<M>>
   findMany(this: any, ids: string[] | number[] | ICollection<any>, columns?: string[]): Promise<any>;
   pluck(column: string): Promise<any>;
   destroy(this: any, ids?: string | number | string[] | number[] | TFunction | Collection$2<M>): Promise<number>;
-  get<M extends Model$1>(columns?: string | string[]): Promise<Collection$2<M>>;
+  get<M extends Model$2>(columns?: string | string[]): Promise<Collection$2<M>>;
   all(columns?: string[]): Promise<any>;
   paginate(this: any, page?: number, perPage?: number): Promise<Paginator$1<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[]>;
+  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[] | ICollection<any>): Collection$2<any>;
 }
 //#endregion
@@ -477,11 +477,11 @@ interface IStatement {
   nulls: boolean;
   bool: 'and' | 'or' | 'not';
 }
-interface IQueryBuilder<M extends Model$1 | Model = Model$1, R = M[] | M> {
-  query: IBuilder<M, R>;
+interface IQueryBuilder<M extends Model$2 | Model$1 = Model$2, R$1 = M[] | M> {
+  query: IBuilder<M, R$1>;
   schema: SchemaBuilder;
   _statements: IStatement[];
-  table(name: string): IQueryBuilder<M, R>;
+  table(name: string): IQueryBuilder<M, R$1>;
   select: SelectMethod<this>;
   addSelect: AddSelectMethod<this>;
   columns: SelectMethod<this>;
@@ -490,7 +490,7 @@ interface IQueryBuilder<M extends Model$1 | Model = Model$1, R = M[] | M> {
   returning: ReturningMethod<this>;
   distinctOn: SelectMethod<this>;
   as: AsMethod<this>;
-  asProxy(): IQueryBuilder<M, R>;
+  asProxy(): IQueryBuilder<M, R$1>;
   where: WhereMethod<this>;
   firstOrFail: FirstOrFailMethod<this>;
   forceDelete: ForceDeleteMethod;
@@ -582,7 +582,7 @@ interface IQueryBuilder<M extends Model$1 | Model = Model$1, R = M[] | M> {
   transaction(callback?: TFunction): Promise<Knex.Transaction> | undefined;
   destroy(callback: TFunction): Promise<number>;
   destroy(): Promise<number>;
-  clone(): IQueryBuilder<M, R>;
+  clone(): IQueryBuilder<M, R$1>;
   raw: Knex.RawQueryBuilder<TGeneric, M>;
   get(columns?: string[]): Promise<any>;
   first(columns?: string[]): Promise<M | null | undefined>;
@@ -600,7 +600,7 @@ interface IQueryBuilder<M extends Model$1 | Model = Model$1, R = M[] | M> {
   take(count: number): this;
   limit(count: number): this;
   offset(count: number): this;
-  pluck<X extends Model$1 = any>(column: string): Promise<Array<X>>;
+  pluck<X extends Model$2 = any>(column: string): Promise<Array<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>>;
@@ -608,19 +608,19 @@ interface IQueryBuilder<M extends Model$1 | Model = Model$1, R = M[] | M> {
 //#endregion
 //#region src/query-builder.d.ts
 declare const Inference: {
-  new <M extends Model$1 = Model$1, R = M[] | M>(): IQueryBuilder<M, R>;
+  new <M extends Model$2 = Model$2, R$1 = M[] | M>(): IQueryBuilder<M, R$1>;
 };
-declare class QueryBuilder<M extends Model$1 = Model$1, R = M[] | M> extends Inference<M, R> {
+declare class QueryBuilder<M extends Model$2 = Model$2, R$1 = M[] | M> extends Inference<M, R$1> {
   model: M;
   schema: SchemaBuilder;
-  connector: IQueryBuilder<M, R> & Knex.QueryBuilder & {
+  connector: IQueryBuilder<M, R$1> & Knex.QueryBuilder & {
     _statements: any[];
     _single: any;
   } & Knex;
   constructor(config: TConfig | null, connector: TFunction);
   asProxy(): any;
   beginTransaction(): Promise<Knex.Transaction<any, any[]>>;
-  table<X extends M>(table: string): IQueryBuilder<X, R>;
+  table<X extends M>(table: string): IQueryBuilder<X, R$1>;
   transaction(callback?: TFunction): Promise<Knex.Transaction> | undefined;
   find(id: string | number, columns?: string[]): Promise<any>;
   get(_columns?: string[]): Promise<any>;
@@ -636,7 +636,7 @@ declare class QueryBuilder<M extends Model$1 = Model$1, R = M[] | M> extends Inf
   max(column: string): Promise<number>;
   sum(column: string): Promise<number>;
   avg(column: string): Promise<number>;
-  clone(): IQueryBuilder<M, R>;
+  clone(): IQueryBuilder<M, R$1>;
   delete(): Promise<number | boolean>;
   insert(...args: Parameters<typeof this.connector.insert>): Promise<unknown>;
   update(...args: Parameters<typeof this.connector.update>): Promise<number>;
@@ -703,13 +703,13 @@ declare class Attribute {
 //#endregion
 //#region src/casts-attributes.d.ts
 interface ICastsAttributes {
-  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;
+  get?(model: Model$2, key: string, value: string, attributes: TGeneric): string | null | undefined;
+  set?(model: Model$2, key: string, value: string, attributes: TGeneric): string | null | undefined;
 }
 declare class CastsAttributes implements ICastsAttributes {
   constructor();
-  static get(_model: Model$1, _key: string, _value: string, _attributes: TGeneric): string | null | undefined;
-  static set(_model: Model$1, _key: string, _value: string, _attributes: TGeneric): string | null | undefined;
+  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;
 }
 //#endregion
 //#region src/concerns/has-unique-ids.d.ts
@@ -724,21 +724,21 @@ declare const HasUniqueIds: <TBase extends MixinConstructor>(Model: TBase) => {
 } & TBase;
 //#endregion
 //#region src/arquebus.d.ts
-declare class arquebus<M extends Model$1 = Model$1> {
+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$1>;
+  models: Record<string, typeof Model$2>;
   constructor();
-  getConstructor<T extends typeof arquebus>(this: InstanceType<T>): T;
-  static getInstance(): arquebus<Model$1>;
+  getConstructor<T$1 extends typeof arquebus>(this: InstanceType<T$1>): T$1;
+  static getInstance(): arquebus<Model$2>;
   /**
    * Initialize a new database connection
    *
    * @returns
    */
-  static fire<C extends TBaseConfig['client']>(connection?: C | null): QueryBuilder<Model$1>;
+  static fire<C extends TBaseConfig['client']>(connection?: C | null): QueryBuilder<Model$2>;
   /**
    * Initialize a new database connection
    *
@@ -749,16 +749,16 @@ declare class arquebus<M extends Model$1 = Model$1> {
    *
    * @returns
    */
-  static connection<C extends TBaseConfig['client']>(connection?: C | null): QueryBuilder<Model$1, Model$1 | Model$1[]>;
+  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[]>>;
-  static transaction<A, R>(callback: TFunction<A[], R>, connection?: null): Promise<Knex$1.Knex.Transaction<any, any[]>> | undefined;
-  static table(name: string, connection?: null): IQueryBuilder<Model$1, Model$1 | Model$1[]>;
+  static transaction<A, R$1>(callback: TFunction<A[], R$1>, 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$1;
+  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;
@@ -778,7 +778,7 @@ declare class arquebus<M extends Model$1 = Model$1> {
   table(name: string, connection?: null): IQueryBuilder<M, M | M[]>;
   schema(connection?: null): SchemaBuilder;
   destroyAll(): Promise<void>;
-  createModel(name: string, options?: ModelOptions): typeof Model$1;
+  createModel(name: string, options?: ModelOptions): typeof Model$2;
 }
 //#endregion
 //#region src/errors.d.ts
@@ -800,16 +800,16 @@ declare class InvalidArgumentError extends BaseError {}
 /**
  * Helper type to extract instance type from constructor or mixin function
  */
-type Constructor<T = TGeneric> = MixinConstructor<T>;
+type Constructor<T$1 = TGeneric> = MixinConstructor<T$1>;
 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$1> = (U$1 extends any ? (k: U$1) => 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$1> = { [K in keyof T$1]: T$1[K] };
 /**
  * Compose function that merges multiple classes and mixins
  *
@@ -873,7 +873,7 @@ declare const getAttrName: (attrMethod: string) => string;
  * @param callback
  * @returns
  */
-declare const tap: <I>(instance: I, callback: (ins: I) => Promise<I> | I) => Promise<I> | I;
+declare const tap: <I$1>(instance: I$1, callback: (ins: I$1) => Promise<I$1> | I$1) => Promise<I$1> | I$1;
 declare const compose: typeof compose$1;
 declare const flatten: <A = any>(arr: A[]) => (A extends readonly (infer InnerArr)[] ? InnerArr : A)[];
 declare const flattenDeep: (arr: any) => any;
@@ -927,7 +927,7 @@ type TConfig = TBaseConfig & ({
   connection: Knex.MariaSqlConnectionConfig;
   useNullAsDefault?: boolean;
 });
-interface ModelOptions<M extends Model$1 = Model$1> {
+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>)[];
@@ -941,8 +941,8 @@ interface ModelOptions<M extends Model$1 = Model$1> {
   primaryKey?: string;
   incrementing?: boolean;
   keyType?: 'int' | 'string';
-  with?: Model$1['with'];
-  casts?: Model$1['casts'];
+  with?: Model$2['with'];
+  casts?: Model$2['casts'];
 }
 interface TField {
   type: 'VAR_STRING' | 'BLOB' | 'DATETIME' | 'TIMESTAMP' | 'LONG' | 'JSON';
@@ -959,7 +959,7 @@ interface TField {
 declare const BaseModel$1: (new (...args: any[]) => any) & {
   [x: string]: any;
 };
-declare class Model extends BaseModel$1 {
+declare class Model$1 extends BaseModel$1 {
   protected primaryKey: string;
   protected perPage: number;
   static globalScopes: {};
@@ -969,9 +969,9 @@ declare class Model extends BaseModel$1 {
   static browser: boolean;
   connection: TBaseConfig['client'] | null;
   constructor(attributes?: {});
-  static init(attributes?: {}): Model;
+  static init(attributes?: {}): Model$1;
   static extend(plugin: TFunction, options: TGeneric): void;
-  static make(attributes?: TGeneric): Model;
+  static make(attributes?: TGeneric): Model$1;
   bootIfNotBooted(this: any): void;
   static booting(): void;
   static boot(): void;
@@ -1010,55 +1010,55 @@ declare class Model extends BaseModel$1 {
   fill(attributes: TGeneric): this;
   transacting(trx: any): this;
   trashed(): boolean;
-  newPivot<E extends Model>(parent: E, attributes: TGeneric, table: string, exists: boolean, using?: typeof Pivot | null): Pivot;
+  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 {
+declare class Pivot extends Model$1 {
   incrementing: boolean;
   guarded: never[];
-  pivotParent: Model | null;
+  pivotParent: Model$1 | null;
   foreignKey: string | null;
   relatedKey: string | null;
   setPivotKeys(foreignKey: string, relatedKey: string): this;
-  static fromRawAttributes<E extends Model>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot;
-  static fromAttributes<E extends Model>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot;
+  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/utils.d.ts
-interface ICollection<T extends Model$1 | Model> 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>;
+interface ICollection<T$1 extends Model$2 | Model$1> extends Collection$1<T$1> {
+  items?: T$1[];
+  load(...relations: T$1[]): Promise<ICollection<T$1>>;
+  loadAggregate(relations: T$1 | T$1[], column: string, action?: string | null): Promise<this>;
+  loadCount(relation: T$1, column: string): Promise<this>;
+  loadMax(relation: T$1, column: string): Promise<this>;
+  loadMin(relation: T$1, column: string): Promise<this>;
+  loadSum(relation: T$1, column: string): Promise<this>;
+  loadAvg(relation: T$1, 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>;
+  diff(items: ICollection<T$1> | any[]): ICollection<T$1>;
+  except(keys: any[]): ICollection<T$1>;
+  intersect(items: T$1[]): ICollection<T$1>;
+  unique(key?: any, strict?: boolean): ICollection<T$1>;
   find(key: any, defaultValue?: any): any;
-  fresh(withs?: any[]): Promise<ICollection<T>>;
+  fresh(withs?: any[]): Promise<ICollection<T$1>>;
   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>;
+  toQuery(): IBuilder<T$1, any>;
   toData(): any;
   toJSON(): any;
   toJson(): string;
   toString(): string;
   [key: string]: any;
-  [Symbol.iterator]: () => Iterator<T>;
+  [Symbol.iterator]: () => Iterator<T$1>;
 }
 interface IPaginatorParams {
   current_page: number;
@@ -1069,47 +1069,47 @@ interface IPaginatorParams {
   count: number;
   paginated?: boolean;
 }
-interface IPaginator<T extends Model$1 | Model, K extends IPaginatorParams = IPaginatorParams> {
+interface IPaginator<T$1 extends Model$2 | Model$1, K$1 extends IPaginatorParams = IPaginatorParams> {
   formatter?(paginator: IPaginator<any>): any | null;
   setFormatter?(formatter: (paginator: IPaginator<any>) => any | null): void;
-  setItems(items: T[] | Collection$2<T>): void;
+  setItems(items: T$1[] | Collection$2<T$1>): void;
   hasMorePages(): boolean;
-  get(index: number): T | null;
+  get(index: number): T$1 | null;
   count(): number;
-  items(): Collection$2<T>;
-  map(callback: (value: T, index: number) => T): Collection$2<T>;
+  items(): Collection$2<T$1>;
+  map(callback: (value: T$1, index: number) => T$1): Collection$2<T$1>;
   currentPage(): number;
   perPage(): number;
   lastPage(): number;
   firstItem(): number | null;
   lastItem(): number | null;
   total(): number;
-  toData<U = K>(): U;
-  toJSON<U = K>(): U;
+  toData<U$1 = K$1>(): U$1;
+  toJSON<U$1 = K$1>(): U$1;
   toJson(): string;
   [Symbol.iterator]?(): {
     next: () => {
-      value: T;
+      value: T$1;
       done: boolean;
     };
   };
 }
 //#endregion
 //#region types/builder.d.ts
-type BaseBuilder<M extends Model$1 | Model, R = ICollection<M> | IModel> = Omit<IQueryBuilder<M, R>, 'destroy' | 'clone' | 'get' | 'skip' | 'limit' | 'take' | 'offset' | 'chunk' | 'forPage' | 'orWhere' | 'pluck'>;
+type BaseBuilder<M extends Model$2 | Model$1, R$1 = ICollection<M> | IModel> = Omit<IQueryBuilder<M, R$1>, 'destroy' | 'clone' | 'get' | 'skip' | 'limit' | 'take' | 'offset' | 'chunk' | 'forPage' | 'orWhere' | 'pluck'>;
 interface IScope {
-  apply(builder: Builder<any>, model: Model$1): void;
+  apply(builder: Builder<any>, model: Model$2): void;
 }
-interface IBuilder<M extends Model$1 | Model, R = ICollection<M> | IModel> extends BaseBuilder<M, R> {
-  connector: IQueryBuilder<M, R> & Knex.QueryBuilder & {
+interface IBuilder<M extends Model$2 | Model$1, R$1 = ICollection<M> | IModel> extends BaseBuilder<M, R$1> {
+  connector: IQueryBuilder<M, R$1> & Knex.QueryBuilder & {
     _statements: any[];
     _single: any;
   } & Knex;
-  asProxy(): IQueryBuilder<M, R>;
+  asProxy(): IQueryBuilder<M, R$1>;
   chunk(count: number, callback: (rows: ICollection<M>) => any): Promise<boolean>;
   enforceOrderBy(): void;
   idOf(id: string | number): this;
-  clone(): IBuilder<M, R>;
+  clone(): IBuilder<M, R$1>;
   forPage(page: number, perPage?: number): this;
   insert(...attributes: any[]): Promise<any>;
   update(attributes: any): Promise<any>;
@@ -1174,7 +1174,7 @@ interface IBuilder<M extends Model$1 | Model, R = ICollection<M> | IModel> exten
   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>>;
+  pluck<X extends Model$2 = any | M>(column: string): Promise<ICollection<X>>;
   destroy(ids?: string | number | string[] | number[] | TFunction | ICollection<any>): Promise<number>;
   get(columns?: string[]): Promise<ICollection<M>>;
   all(columns?: string[]): Promise<ICollection<M>>;
@@ -1189,8 +1189,8 @@ type FieldExpression = string;
 type TableRef<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
 type Selection<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
 type QBOrCallback<QB extends AnyQueryBuilder> = AnyQueryBuilder | CallbackVoid<QB>;
-interface CallbackVoid<T> {
-  (this: T, arg: T): void;
+interface CallbackVoid<T$1> {
+  (this: T$1, arg: T$1): void;
 }
 type Raw = Knex.Raw;
 type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
@@ -1198,11 +1198,11 @@ interface OrderByDescriptor {
   column: ColumnRef;
   order?: OrderByDirection;
 }
-type AnyQueryBuilder<M extends Model$1 = any, R = any> = IQueryBuilder<M, R> | IBuilder<M, R>;
-type Expression<T> = T | Raw | AnyQueryBuilder;
+type AnyQueryBuilder<M extends Model$2 = any, R$1 = any> = IQueryBuilder<M, R$1> | IBuilder<M, R$1>;
+type Expression<T$1> = T$1 | Raw | AnyQueryBuilder;
 type ColumnRefOrOrderByDescriptor = ColumnRef | OrderByDescriptor;
-interface RawInterface<R> {
-  (sql: string, ...bindings: any[]): R;
+interface RawInterface<R$1> {
+  (sql: string, ...bindings: any[]): R$1;
 }
 interface BaseSetOperations<QB extends AnyQueryBuilder> {
   (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB;
@@ -1216,7 +1216,7 @@ interface GroupByMethod<QB extends AnyQueryBuilder> {
   (columns: ColumnRef[]): QB;
 }
 type WithRelationType = {
-  [key: string]: <T extends IBuilder<any>>(builder: T) => T | void;
+  [key: string]: <T$1 extends IBuilder<any>>(builder: T$1) => T$1 | void;
 } | string | string[];
 interface SetOperationsMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
   (...callbacksOrBuilders: QBOrCallback<QB>[]): QB;
@@ -1318,20 +1318,20 @@ declare const BaseModel: (new (...args: any[]) => any) & {
   exists: boolean;
   connection?: (TBaseConfig["client"] | null) | undefined;
   perPage: number;
-  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$1>>;
+  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
   trx: AnyQueryBuilder | null;
   timestamps: boolean;
   dateFormat: string;
   visible: string[] & any[];
   hidden: string[] & any[];
-  query: <T extends {
+  query: <T$1 extends {
     prototype: unknown;
-  }>(this: T, client?: AnyQueryBuilder | null) => IBuilder<Model$1>;
-  on: <T extends {
+  }>(this: T$1, client?: AnyQueryBuilder | null) => IBuilder<Model$2>;
+  on: <T$1 extends {
     prototype: unknown;
-  }>(this: T, connection: string | null) => IBuilder<Model$1>;
+  }>(this: T$1, connection: string | null) => IBuilder<Model$2>;
   boot: () => void;
-  make: <T extends IModel>(this: new () => T, attributes?: TGeneric) => T;
+  make: <T$1 extends IModel>(this: new () => T$1, attributes?: TGeneric) => T$1;
   addHook: (hook: Hook, callback: TFunction) => void;
   creating: (callback: TFunction) => void;
   created: (callback: TFunction) => void;
@@ -2176,8 +2176,8 @@ declare const BaseModel: (new (...args: any[]) => any) & {
     uniqueIds(): never[];
     setUniqueIds(): void;
   });
-  getRelation: <T extends Model$1>(relation: string) => T | ICollection<T> | null | undefined;
-  setRelation: <T extends Model$1>(relation: string, value: T | ICollection<T> | null) => (new () => IModel) & IModel & {
+  getRelation: <T$1 extends Model$2>(relation: string) => T$1 | ICollection<T$1> | null | undefined;
+  setRelation: <T$1 extends Model$2>(relation: string, value: T$1 | ICollection<T$1> | null) => (new () => IModel) & IModel & {
     [x: string]: any;
     timestamps: boolean;
     dateFormat: string;
@@ -2662,7 +2662,7 @@ declare const BaseModel: (new (...args: any[]) => any) & {
     uniqueIds(): never[];
     setUniqueIds(): void;
   });
-  newCollection: (models?: any[]) => ICollection<Model$1>;
+  newCollection: (models?: any[]) => ICollection<Model$2>;
   load: {
     (relations: WithRelationType): Promise<(new () => IModel) & IModel & {
       [x: string]: any;
@@ -4067,7 +4067,7 @@ declare const BaseModel: (new (...args: any[]) => any) & {
     uniqueIds(): never[];
     setUniqueIds(): void;
   }) => boolean;
-  related: <T extends never>(relation: T) => ReturnTypeOfMethod<(new () => IModel) & IModel & {
+  related: <T$1 extends never>(relation: T$1) => ReturnTypeOfMethod<(new () => IModel) & IModel & {
     [x: string]: any;
     timestamps: boolean;
     dateFormat: string;
@@ -4147,8 +4147,8 @@ declare const BaseModel: (new (...args: any[]) => any) & {
     usesUniqueIds(): boolean;
     uniqueIds(): never[];
     setUniqueIds(): void;
-  }, `relation${Capitalize<SnakeToCamelCase<T>>}`>;
-  getRelated: <T extends never>(relation: T) => ReturnTypeOfMethod<ReturnTypeOfMethod<(new () => IModel) & IModel & {
+  }, `relation${Capitalize<SnakeToCamelCase<T$1>>}`>;
+  getRelated: <T$1 extends never>(relation: T$1) => ReturnTypeOfMethod<ReturnTypeOfMethod<(new () => IModel) & IModel & {
     [x: string]: any;
     timestamps: boolean;
     dateFormat: string;
@@ -4228,11 +4228,11 @@ declare const BaseModel: (new (...args: any[]) => any) & {
     usesUniqueIds(): boolean;
     uniqueIds(): never[];
     setUniqueIds(): void;
-  }, `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>;
+  }, `relation${Capitalize<SnakeToCamelCase<T$1>>}`>, any>;
+  hasOne: <T$1 extends Model$2>(model: new () => T$1, foreignKey?: string, localKey?: string) => HasOne<T$1>;
+  hasMany: <T$1 extends Model$2>(model: new () => T$1, foreignKey?: string, localKey?: string) => HasMany<T$1>;
+  belongsTo: <T$1 extends Model$2>(model: new () => T$1, foreignKey?: string, ownerKey?: string, relation?: string) => BelongsTo<T$1>;
+  belongsToMany: <T$1 extends Model$2>(model: new () => T$1, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string) => BelongsToMany<T$1>;
   original: TGeneric;
   casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
   changes: TGeneric;
@@ -4748,7 +4748,7 @@ declare const BaseModel: (new (...args: any[]) => any) & {
   getGlobalScopes: () => {};
   useUniqueIds: boolean;
 };
-declare class Model$1 extends BaseModel {
+declare class Model$2 extends BaseModel {
   [key: string]: any;
   protected builder: IBuilder<any, any> | null;
   protected table: string | null;
@@ -4764,16 +4764,16 @@ declare class Model$1 extends BaseModel {
   connection: TBaseConfig['client'] | null;
   eagerLoad: {};
   exists: boolean;
-  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$1>>;
+  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
   name: any;
   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 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$1;
-  getConstructor<T extends typeof Model$1>(this: InstanceType<T>): T;
+  static make(attributes?: TGeneric): Model$2;
+  getConstructor<T$1 extends typeof Model$2>(this: InstanceType<T$1>): T$1;
   bootIfNotBooted(this: any): void;
   static booting(): void;
   static boot(): void;
@@ -4793,20 +4793,20 @@ declare class Model$1 extends BaseModel {
   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>>;
+  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$2<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>;
+  newCollection(this: any, models?: never[]): Collection$2<Model$2>;
+  load<R$1 extends WithRelationType>(this: any, ...relations: R$1[]): Promise<any>;
+  loadAggregate<R$1 extends WithRelationType>(relations: R$1[], column: string, callback?: TFunction | string | null): Promise<this>;
+  loadCount<R$1 extends WithRelationType>(...relations: R$1[]): Promise<this>;
+  loadMax<R$1 extends WithRelationType>(relations: R$1[], column: string): Promise<this>;
+  loadMin<R$1 extends WithRelationType>(relations: R$1[], column: string): Promise<this>;
+  loadSum<R$1 extends WithRelationType>(relations: R$1[], 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>;
@@ -4835,60 +4835,60 @@ declare class Model$1 extends BaseModel {
   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$1 | null): Pivot$1;
+  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$1 {
+declare class Pivot$1 extends Model$2 {
   incrementing: boolean;
   guarded: never[];
-  pivotParent: Model$1 | null;
+  pivotParent: Model$2 | 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$1;
-  static fromAttributes<E extends Model$1>(parent: E, attributes: TGeneric, table: string, exists?: boolean): Pivot$1;
+  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 types/generics.d.ts
-type TGeneric<V = any, K extends string = string> = Record<K, V>;
-type XGeneric<V = TGeneric, T = any> = {
-  [key: string]: T;
+type TGeneric<V = any, K$1 extends string = string> = Record<K$1, V>;
+type XGeneric<V = TGeneric, T$1 = any> = {
+  [key: string]: T$1;
 } & 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$1, K$1 extends keyof T$1> = T$1[K$1] extends ((...args: any[]) => infer R) ? R : never;
 type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
 type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Uncapitalize<T>}${CamelToSnakeCase<U>}` : `${Uncapitalize<T>}_${CamelToSnakeCase<U>}` : S;
-type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
-type RelationNames<T> = FunctionPropertyNames<T> extends infer R ? R extends `relation${infer P}` ? P extends 'sToData' | 'loaded' ? never : CamelToSnakeCase<P> : never : never;
-type MixinConstructor<T = TGeneric> = new (...args: any[]) => T;
+type FunctionPropertyNames<T$1> = { [K in keyof T$1]: T$1[K] extends ((...args: any[]) => any) ? K : never }[keyof T$1];
+type RelationNames<T$1> = FunctionPropertyNames<T$1> extends infer R ? R extends `relation${infer P}` ? P extends 'sToData' | 'loaded' ? never : CamelToSnakeCase<P> : never : never;
+type MixinConstructor<T$1 = TGeneric> = new (...args: any[]) => T$1;
 //#endregion
 //#region src/browser/paginator.d.ts
-declare class Paginator<T extends Model, K extends IPaginatorParams = IPaginatorParams> implements IPaginator<T, K> {
+declare class Paginator<T$1 extends Model$1, K$1 extends IPaginatorParams = IPaginatorParams> implements IPaginator<T$1, K$1> {
   static formatter: (paginator: IPaginator<any>) => any | null;
-  _items: Collection<T>;
+  _items: Collection<T$1>;
   _total: number;
   _perPage: number;
   _lastPage: number;
   _currentPage: number;
   hasMore: boolean;
   options: TGeneric;
-  constructor(items: T[], total: number, perPage: number, currentPage?: number, options?: TGeneric);
+  constructor(items: T$1[], total: number, perPage: number, currentPage?: number, options?: TGeneric);
   static setFormatter(formatter: (paginator: IPaginator<any>) => any | null): void;
-  setItems(items: T[]): void;
+  setItems(items: T$1[]): void;
   firstItem(): number | null;
   lastItem(): number | null;
   hasMorePages(): boolean;
-  get(index: number): T | null;
+  get(index: number): T$1 | null;
   count(): number;
   items(): any;
-  map(callback: (value: T, index: number) => T): any;
+  map(callback: (value: T$1, index: number) => T$1): any;
   currentPage(): number;
   onFirstPage(): boolean;
   perPage(): number;
@@ -4900,16 +4900,16 @@ declare class Paginator<T extends Model, K extends IPaginatorParams = IPaginator
 }
 //#endregion
 //#region src/browser/index.d.ts
-declare const make: (model: Model, data: TGeneric, options?: {
+declare const make: (model: Model$1, data: TGeneric, options?: {
   paginated: IPaginatorParams;
 }) => any;
-declare const makeCollection: (model: Model, data: TGeneric) => Collection<Model>;
+declare const makeCollection: (model: Model$1, data: TGeneric) => Collection<Model$1>;
 declare const isBrowser = true;
 declare const _default: {
   isBrowser: boolean;
   Paginator: typeof Paginator;
   Collection: typeof Collection;
-  Model: typeof Model;
+  Model: typeof Model$1;
   Pivot: typeof Pivot;
   Attribute: typeof Attribute;
   CastsAttributes: typeof CastsAttributes;
@@ -4922,11 +4922,11 @@ declare const _default: {
       getIncrementing(): any;
     };
   } & TBase;
-  make: (model: Model, data: TGeneric, options?: {
+  make: (model: Model$1, data: TGeneric, options?: {
     paginated: IPaginatorParams;
   }) => any;
-  makeCollection: (model: Model, data: TGeneric) => Collection<Model>;
-  makePaginator: (model: Model, data: TGeneric) => Paginator<Model, IPaginatorParams>;
+  makeCollection: (model: Model$1, data: TGeneric) => Collection<Model$1>;
+  makePaginator: (model: Model$1, data: TGeneric) => Paginator<Model$1, IPaginatorParams>;
 };
 //#endregion
-export { Attribute, CastsAttributes, Collection, HasUniqueIds, InvalidArgumentError, Model, ModelNotFoundError, Paginator, Pivot, RelationNotFoundError, compose, _default as default, defineConfig, flatten, flattenDeep, getAttrMethod, getAttrName, getGetterMethod, getRelationMethod, getRelationName, getScopeMethod, getScopeName, getSetterMethod, isBrowser, kebabCase, make, makeCollection, now, snakeCase, tap };
+export { Attribute, CastsAttributes, Collection, HasUniqueIds, InvalidArgumentError, Model$1 as Model, ModelNotFoundError, Paginator, Pivot, RelationNotFoundError, compose, _default as default, defineConfig, flatten, flattenDeep, getAttrMethod, getAttrName, getGetterMethod, getRelationMethod, getRelationName, getScopeMethod, getScopeName, getSetterMethod, isBrowser, kebabCase, make, makeCollection, now, snakeCase, tap };