@h3ravel/arquebus 0.6.7 → 0.6.8

package/dist/browser/index.d.mts

@@ -0,0 +1,4932 @@
+import { Collection as Collection$1 } from "collect.js";
+import * as dayjs0 from "dayjs";
+import Knex$1, { Knex } from "knex";
+
+//#region src/browser/collection.d.ts
+declare class Collection<I$1 extends Model$1> extends Collection$1<I$1> {
+  mapThen(callback: TFunction): Promise<any[]>;
+  modelKeys(): any[];
+  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$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$1 | {
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+  })[];
+  toJSON(): (I$1 | {
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+  })[];
+  toJson(...args: any[]): string;
+  [Symbol.iterator]: () => Iterator<I$1>;
+}
+//#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$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$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$1<M> {
+  getResults(): Promise<M | null>;
+  withDefault(callback?: TFunction | object): this;
+}
+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;
+  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;
+  connection?: TBaseConfig['client'] | null;
+  perPage: number;
+  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
+  trx: AnyQueryBuilder | null;
+  timestamps: boolean;
+  dateFormat: string;
+  visible: string[];
+  hidden: string[];
+  query<T$1 extends {
+    prototype: unknown;
+  }>(this: T$1, client?: AnyQueryBuilder | null): IBuilder<Model$2>;
+  on<T$1 extends {
+    prototype: unknown;
+  }>(this: T$1, connection: string | null): IBuilder<Model$2>;
+  boot(): void;
+  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;
+  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[];
+  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$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$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$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$1 extends Model$2 | Model$1> extends Collection$1<I$1> implements ICollection<I$1> {
+  private newConstructor;
+  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$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$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;
+  makeHidden(attributes: any): this;
+  append(attributes: any): this;
+  only(keys: any[]): any;
+  getDictionary(items?: ICollection<any> | any[]): TGeneric;
+  toQuery(): any;
+  toData(): ({
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+  } | I$1)[];
+  toJSON(): ({
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+  } | I$1)[];
+  toJson(...args: any[]): string;
+  [Symbol.iterator]: () => Iterator<I$1>;
+}
+//#endregion
+//#region src/paginator.d.ts
+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$1>;
+  _total: number;
+  _perPage: number;
+  _lastPage: number;
+  _currentPage: number;
+  hasMore: boolean;
+  options: TGeneric;
+  static setFormatter(formatter?: ((paginator: IPaginator<any> | null) => any) | null): 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$1 | null;
+  count(): number;
+  items(): Collection$2<T$1>;
+  map(callback: (value: T$1, index: number) => T$1): Collection$2<T$1>;
+  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$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$2 | Model$1 = Model$2, R$1 = IModel | ICollection<M>>(): IBuilder<M, R$1>;
+};
+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$1>, number>>;
+  eagerLoad: TGeneric<(...args: any[]) => any>;
+  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$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>;
+  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$1>;
+  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$2<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 | string[] | number[] | TFunction | Collection$2<M>): Promise<number>;
+  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$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
+//#region src/inspector/types/column.d.ts
+interface Column {
+  name: string;
+  table: string;
+  data_type: string;
+  default_value: string | null;
+  max_length: number | null;
+  numeric_precision: number | null;
+  numeric_scale: number | null;
+  is_nullable: boolean;
+  is_unique: boolean;
+  is_primary_key: boolean;
+  is_generated: boolean;
+  generation_expression?: string | null;
+  has_auto_increment: boolean;
+  foreign_key_table: string | null;
+  foreign_key_column: string | null;
+  comment?: string | null;
+  schema?: string;
+  foreign_key_schema?: string | null;
+  collation?: string | null;
+}
+//#endregion
+//#region src/inspector/types/foreign-key.d.ts
+type ForeignKey = {
+  table: string;
+  column: string;
+  foreign_key_table: string;
+  foreign_key_column: string;
+  foreign_key_schema?: string;
+  constraint_name: null | string;
+  on_update: null | 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+  on_delete: null | 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+};
+//#endregion
+//#region src/inspector/types/table.d.ts
+interface Table {
+  name: string;
+  comment?: string | null;
+  schema?: string;
+  collation?: string;
+  engine?: string;
+  owner?: string;
+  sql?: string;
+  catalog?: string;
+}
+//#endregion
+//#region types/query-builder.d.ts
+interface SchemaBuilder extends Knex.SchemaBuilder {
+  [k: string]: any;
+  /**
+   * Retrieve all tables in the current database.
+   */
+  tables(): Promise<string[]>;
+  /**
+   * Retrieve the table info for the given table, or all tables if no table is specified.
+   *
+   * @param table
+   */
+  tableInfo(table?: string): Promise<Table | Table[]>;
+  /**
+   * Retrieve all columns in a given table, or all columns if no table is specified.
+   *
+   * @param table
+   */
+  columns(table?: string): Promise<{
+    table: string;
+    column: string;
+  }[]>;
+  /**
+   * Retrieve all columns from a given table. Returns all columns if table parameter is undefined.
+   *
+   * @param table
+   * @param column
+   */
+  columnInfo(table?: string, column?: string): Promise<Column[] | Column>;
+  /**
+   * Retrieve the primary key column for a given table.
+   *
+   * @param table
+   */
+  primary(table: string): Promise<string>;
+  /**
+   * Retrieve all configured foreign key constraints
+   */
+  foreignKeys(): Promise<ForeignKey>;
+}
+interface AsMethod<QB extends AnyQueryBuilder> {
+  (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$1 = M[] | M> {
+  query: IBuilder<M, R$1>;
+  schema: SchemaBuilder;
+  _statements: IStatement[];
+  table(name: string): IQueryBuilder<M, R$1>;
+  select: SelectMethod<this>;
+  addSelect: AddSelectMethod<this>;
+  columns: SelectMethod<this>;
+  column: SelectMethod<this>;
+  distinct: SelectMethod<this>;
+  returning: ReturningMethod<this>;
+  distinctOn: SelectMethod<this>;
+  as: AsMethod<this>;
+  asProxy(): IQueryBuilder<M, R$1>;
+  where: WhereMethod<this>;
+  firstOrFail: FirstOrFailMethod<this>;
+  forceDelete: ForceDeleteMethod;
+  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>;
+  restore: RestoreMethod;
+  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$1>;
+  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<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>>;
+}
+//#endregion
+//#region src/query-builder.d.ts
+declare const Inference: {
+  new <M extends Model$2 = Model$2, R$1 = M[] | M>(): IQueryBuilder<M, R$1>;
+};
+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$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$1>;
+  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 | undefined, perPage: number | undefined, _pageName: string, _page: number): Promise<IPaginator<M, F>>;
+  forPage(this: any, page?: number, perPage?: number): any;
+  toSQL(...args: any[]): 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$1>;
+  delete(): Promise<number | boolean>;
+  insert(...args: Parameters<typeof this.connector.insert>): Promise<unknown>;
+  update(...args: Parameters<typeof this.connector.update>): Promise<number>;
+  destroy(...args: Parameters<typeof this.connector.destroy>): Promise<number>;
+  get _statements(): IStatement[] & any[];
+  get _single(): any;
+  get from(): Knex.Table<any, any> & Knex.Table<any, any[]>;
+}
+//#endregion
+//#region src/relations/relation.d.ts
+declare class Relation {
+  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: unknown[]): 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 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);
+}
+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;
+}
+//#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;
+}
+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;
+}
+//#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;
+  };
+} & TBase;
+//#endregion
+//#region src/arquebus.d.ts
+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$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$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[]>>;
+  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$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[]>>;
+  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;
+}
+//#endregion
+//#region src/errors.d.ts
+declare class BaseError extends Error {
+  constructor(message: string, _entity?: any);
+}
+declare class ModelNotFoundError extends BaseError {
+  model?: IModel;
+  ids: (string | number)[] | string | number;
+  constructor();
+  setModel(model: IModel, ids?: never[]): this;
+  getModel(): IModel | undefined;
+  getIds(): string | number | (string | number)[];
+}
+declare class RelationNotFoundError extends BaseError {}
+declare class InvalidArgumentError extends BaseError {}
+//#endregion
+//#region src/mixin.d.ts
+/**
+ * Helper type to extract instance type from constructor or mixin function
+ */
+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$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$1> = { [K in keyof T$1]: T$1[K] };
+/**
+ * Compose function that merges multiple classes and mixins
+ *
+ * @example
+ * const SomePlugin = <TBase extends new (...args: any[]) => TGeneric> (Base: TBase) => {
+ *     return class extends Base {
+ *         pluginAttribtue = 'plugin'
+ *         pluginMethod () {
+ *             return this.pluginAttribtue
+ *         }
+ *     }
+ * }
+ *
+ * // Base class
+ * class Model {
+ *     make () {
+ *         console.log('make')
+ *     }
+ *     pluginMethod (id: string) {
+ *     }
+ * }
+ *
+ * class User extends compose(
+ *     Model,
+ *     SomePlugin,
+ * ) {
+ *     relationPosts () {
+ *         return 'hasMany Posts'
+ *     }
+ * }
+ *
+ * const user = new User()
+ * user.make() // from Model
+ * user.pluginMethod() // from SomePlugin
+ * user.relationPosts() // from User
+ *
+ * console.log(user.pluginMethod('w')) // "plugin"
+ * console.log(user.pluginMethod()) // "plugin"
+ * console.log(user.relationPosts()) // "hasMany Posts"
+ *
+ * @param Base
+ * @param mixins
+ * @returns
+ */
+declare function compose$1<TBase extends Constructor, TMixins extends Array<Mixin<any> | Constructor> = any>(Base: TBase, ...mixins: TMixins): Constructor<InstanceType<TBase> & 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;
+declare const getRelationMethod: (relation: string) => string;
+declare const getScopeMethod: (scope: string) => string;
+declare const getAttrMethod: (attr: string) => string;
+declare const getGetterMethod: (attr: string) => string;
+declare const getSetterMethod: (attr: string) => string;
+declare const getAttrName: (attrMethod: string) => string;
+/**
+ * Tap into a model a collection instance
+ *
+ * @param instance
+ * @param callback
+ * @returns
+ */
+declare const tap: <I$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;
+declare const kebabCase: (str: string) => string;
+declare const snakeCase: (str: string) => string;
+declare const defineConfig: (config: TConfig) => XGeneric<TConfig>;
+//#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;
+  };
+}
+type TConfig = TBaseConfig & ({
+  client: 'pg';
+  connection: Knex.PgConnectionConfig;
+} | {
+  client: 'oracle';
+  connection: Knex.OracleDbConnectionConfig;
+} | {
+  client: 'mysql2';
+  connection: Knex.MySql2ConnectionConfig;
+} | {
+  client: 'mysql';
+  connection: Knex.MySqlConnectionConfig;
+} | {
+  client: 'sqlite3';
+  connection: Knex.Sqlite3ConnectionConfig;
+  useNullAsDefault?: boolean;
+} | {
+  client: 'mariadb';
+  connection: Knex.MariaSqlConnectionConfig;
+  useNullAsDefault?: boolean;
+});
+interface ModelOptions<M extends Model$2 = Model$2> {
+  table?: string;
+  scopes?: TGeneric<(...args: any[]) => Builder<M>>;
+  plugins?: (<X extends MixinConstructor<M>>(Model: X) => MixinConstructor<M>)[];
+  relations?: TGeneric<(...args: any[]) => Relation>;
+  attributes?: TGeneric<Attribute$1>;
+  CREATED_AT?: string;
+  UPDATED_AT?: string;
+  DELETED_AT?: string;
+  connection?: TBaseConfig['client'];
+  timestamps?: boolean;
+  primaryKey?: string;
+  incrementing?: boolean;
+  keyType?: 'int' | 'string';
+  with?: Model$2['with'];
+  casts?: Model$2['casts'];
+}
+interface TField {
+  type: 'VAR_STRING' | 'BLOB' | 'DATETIME' | 'TIMESTAMP' | 'LONG' | 'JSON';
+  length: number;
+  db: string;
+  table: string;
+  name: string;
+  string: TFunction;
+  buffer: TFunction;
+  geometry: TFunction;
+}
+//#endregion
+//#region src/browser/model.d.ts
+declare const BaseModel$1: (new (...args: any[]) => any) & {
+  [x: string]: any;
+};
+declare class Model$1 extends BaseModel$1 {
+  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;
+}
+//#endregion
+//#region types/utils.d.ts
+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$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$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$1, any>;
+  toData(): any;
+  toJSON(): any;
+  toJson(): string;
+  toString(): string;
+  [key: string]: any;
+  [Symbol.iterator]: () => Iterator<T$1>;
+}
+interface IPaginatorParams {
+  current_page: number;
+  data: any[];
+  per_page: number;
+  total: number;
+  last_page: number;
+  count: number;
+  paginated?: boolean;
+}
+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$1[] | Collection$2<T$1>): void;
+  hasMorePages(): boolean;
+  get(index: number): T$1 | null;
+  count(): number;
+  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$1 = K$1>(): U$1;
+  toJSON<U$1 = K$1>(): U$1;
+  toJson(): string;
+  [Symbol.iterator]?(): {
+    next: () => {
+      value: T$1;
+      done: boolean;
+    };
+  };
+}
+//#endregion
+//#region types/builder.d.ts
+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$2): void;
+}
+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$1>;
+  chunk(count: number, callback: (rows: ICollection<M>) => any): Promise<boolean>;
+  enforceOrderBy(): void;
+  idOf(id: string | number): this;
+  clone(): IBuilder<M, R$1>;
+  forPage(page: number, perPage?: number): this;
+  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;
+  orWhere(...args: any[]): 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;
+  take(count: number): this;
+  skip(count: number): this;
+  limit(count: number): this;
+  offset(count: number): 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>>;
+  destroy(ids?: string | number | string[] | number[] | TFunction | ICollection<any>): Promise<number>;
+  get(columns?: string[]): Promise<ICollection<M>>;
+  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;
+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$1> {
+  (this: T$1, arg: T$1): void;
+}
+type Raw = Knex.Raw;
+type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
+interface OrderByDescriptor {
+  column: ColumnRef;
+  order?: OrderByDirection;
+}
+type AnyQueryBuilder<M extends Model$2 = any, R$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$1> {
+  (sql: string, ...bindings: any[]): R$1;
+}
+interface BaseSetOperations<QB extends AnyQueryBuilder> {
+  (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB;
+  (callbacksOrBuilders: QBOrCallback<QB>[], wrap?: boolean): QB;
+}
+type JoinRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {};
+type OrderByRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {};
+type WhereRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {};
+interface GroupByMethod<QB extends AnyQueryBuilder> {
+  (...columns: ColumnRef[]): QB;
+  (columns: ColumnRef[]): QB;
+}
+type WithRelationType = {
+  [key: string]: <T$1 extends IBuilder<any>>(builder: T$1) => T$1 | void;
+} | string | string[];
+interface SetOperationsMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
+  (...callbacksOrBuilders: QBOrCallback<QB>[]): QB;
+}
+interface SelectMethod<QB extends AnyQueryBuilder> {
+  <QBP extends QB>(...columns: Selection<QBP>[]): QB;
+  <QBP extends QB>(columns: Selection<QBP>[]): QB;
+}
+interface WhereMethod<QB extends AnyQueryBuilder> {
+  (col: ColumnRef, op: Operator, expr: Expression<PrimitiveValue>): QB;
+  (col: ColumnRef, expr: Expression<PrimitiveValue>): QB;
+  (condition: boolean): QB;
+  (cb: CallbackVoid<QB>): QB;
+  (raw: Raw): QB;
+  <QBA extends AnyQueryBuilder>(qb: QBA): QB;
+  (obj: object): QB;
+}
+interface WhereWrappedMethod<QB extends AnyQueryBuilder> {
+  (cb: CallbackVoid<QB>): QB;
+}
+interface WhereFieldExpressionMethod<QB extends AnyQueryBuilder> {
+  (fieldExpression: FieldExpression): QB;
+}
+interface WhereExistsMethod<QB extends AnyQueryBuilder> {
+  (cb: CallbackVoid<QB>): QB;
+  (raw: Raw): QB;
+  <QBA extends AnyQueryBuilder>(qb: QBA): QB;
+}
+interface WhereInMethod<QB extends AnyQueryBuilder> {
+  (col: ColumnRef | ColumnRef[], expr: Expression<PrimitiveValue>[]): QB;
+  (col: ColumnRef | ColumnRef[], cb: CallbackVoid<QB>): QB;
+  (col: ColumnRef | ColumnRef[], qb: AnyQueryBuilder): QB;
+}
+interface WhereBetweenMethod<QB extends AnyQueryBuilder> {
+  (column: ColumnRef, range: [Expression<PrimitiveValue>, Expression<PrimitiveValue>]): QB;
+}
+interface WhereNullMethod<QB extends AnyQueryBuilder> {
+  (column: ColumnRef): QB;
+}
+interface OrderByMethod<QB extends AnyQueryBuilder> {
+  (column: ColumnRef, order?: OrderByDirection): QB;
+  (columns: ColumnRefOrOrderByDescriptor[]): QB;
+}
+interface WhereJsonExpressionMethod<QB extends AnyQueryBuilder> {
+  (fieldExpression: FieldExpression, keys: string | string[]): QB;
+}
+interface ReturningMethod<QB extends AnyQueryBuilder> {
+  (key: FieldExpression | FieldExpression[], options?: {
+    [key: string]: any;
+  }): QB;
+}
+interface FirstOrFailMethod<QB extends AnyQueryBuilder> {
+  (): Promise<QB>;
+}
+interface AddSelectMethod<QB extends AnyQueryBuilder> {
+  (params: string[]): QB;
+}
+interface ForceDeleteMethod {
+  (): Promise<boolean | number>;
+}
+interface RestoreMethod {
+  (): Promise<number>;
+}
+interface WhereColumnMethod<QB extends AnyQueryBuilder> {
+  (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;
+}
+interface UnionMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
+  (arg1: QBOrCallback<QB>, wrap?: boolean): QB;
+  (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, wrap?: boolean): QB;
+  (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, wrap?: boolean): QB;
+  (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, wrap?: boolean): QB;
+  (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, arg5: QBOrCallback<QB>, wrap?: boolean): QB;
+  (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, arg5: QBOrCallback<QB>, arg6: QBOrCallback<QB>, wrap?: boolean): QB;
+  (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, arg4: QBOrCallback<QB>, arg5: QBOrCallback<QB>, arg6: QBOrCallback<QB>, arg7: QBOrCallback<QB>, wrap?: boolean): QB;
+}
+interface JoinMethod<QB extends AnyQueryBuilder> {
+  (table: TableRef<QB>, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
+  (table: TableRef<QB>, leftCol: ColumnRef, rightCol: ColumnRef): QB;
+  (table: TableRef<QB>, cb: CallbackVoid<Knex.JoinClause>): QB;
+  (table: TableRef<QB>, raw: Raw): QB;
+  (raw: Raw): QB;
+}
+//#endregion
+//#region src/model.d.ts
+declare const BaseModel: (new (...args: any[]) => any) & {
+  [x: string]: any;
+} & {
+  [x: string]: any;
+  attributes: any;
+  relations: any;
+  exists: boolean;
+  connection?: (TBaseConfig["client"] | null) | undefined;
+  perPage: number;
+  with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model$2>>;
+  trx: AnyQueryBuilder | null;
+  timestamps: boolean;
+  dateFormat: string;
+  visible: string[] & any[];
+  hidden: string[] & any[];
+  query: <T$1 extends {
+    prototype: unknown;
+  }>(this: T$1, client?: AnyQueryBuilder | null) => IBuilder<Model$2>;
+  on: <T$1 extends {
+    prototype: unknown;
+  }>(this: T$1, connection: string | null) => IBuilder<Model$2>;
+  boot: () => void;
+  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;
+  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;
+    (): boolean;
+  };
+  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) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  usesUniqueIds: (() => boolean) & (() => boolean);
+  uniqueIds: (() => string[]) & (() => never[]);
+  setUniqueIds: (() => void) & (() => void);
+  getKeyType: () => string;
+  getIncrementing: () => boolean;
+  setIncrementing: (value: boolean) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  getTable: () => string;
+  setTable: (table: string) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  getDates: (() => string[]) & (() => any[]);
+  getDateFormat: (() => string) & (() => any);
+  getAttributes: (() => object) & (() => {
+    [x: string]: any;
+  });
+  getAttribute: ((key: string) => any) & ((key: string) => any);
+  setAttribute: ((key: string, value: any) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((key: string, value: string) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  fill: (attributes: any) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  setAppends: ((appends: string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((appends: any[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  append: ((key: string | string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((...keys: any[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  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;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  unsetRelation: (relation: string) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  relationLoaded: (relation: string) => boolean;
+  makeVisible: ((attributes: string | string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((...keys: string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  makeHidden: ((attributes: string | string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((key: string[], ...keys: string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  newCollection: (models?: any[]) => ICollection<Model$2>;
+  load: {
+    (relations: WithRelationType): Promise<(new () => IModel) & IModel & {
+      [x: string]: any;
+      timestamps: boolean;
+      dateFormat: string;
+      usesTimestamps(): boolean;
+      updateTimestamps(): /*elided*/any;
+      getCreatedAtColumn(): any;
+      getUpdatedAtColumn(): any;
+      setCreatedAt(value: any): /*elided*/any;
+      setUpdatedAt(value: any): /*elided*/any;
+      freshTimestamp(): Date;
+      freshTimestampString(): any;
+    } & TGeneric<any, string> & {
+      [x: string]: any;
+      attributes: TGeneric;
+      original: TGeneric;
+      casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+      changes: TGeneric;
+      appends: any[];
+      setAppends(appends: any[]): /*elided*/any;
+      append(...keys: any[]): /*elided*/any;
+      normalizeCastClassResponse(key: string, value: string): TGeneric;
+      syncOriginal(): /*elided*/any;
+      syncChanges(): /*elided*/any;
+      syncOriginalAttribute(attribute: string): void;
+      syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+      isDirty(...attributes: string[]): boolean;
+      getDirty(): TGeneric;
+      originalIsEquivalent(key: string): boolean;
+      setAttributes(attributes: TGeneric): void;
+      setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+      getAttributes(): {
+        [x: string]: any;
+      };
+      setAttribute(key: string, value: string): /*elided*/any;
+      getAttribute(key: string): any;
+      castAttribute(key: string, value: string): any;
+      attributesToData(): {
+        [x: string]: any;
+      };
+      mutateAttribute(key: string, value: string | null): any;
+      mutateAttributeForArray(_key: string, _value: string): void;
+      isDateAttribute(key: string): boolean;
+      serializeDate(date?: Date | string | null): string | null;
+      getDates(): any[];
+      getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+      getCastType(key: string): any;
+      hasCast(key: string, types?: readonly string[]): boolean;
+      withDayjs(date: string): dayjs0.Dayjs;
+      isCustomCast(cast: any): boolean;
+      isCustomDateTimeCast(cast: any): boolean;
+      isDecimalCast(cast: any): boolean;
+      isDateCastable(key: string): boolean;
+      fromDateTime(value: string): string;
+      getDateFormat(): any;
+      asDecimal(value: string, decimals: number): string;
+      asDateTime(value: any): Date | null;
+      asDate(value: string): Date;
+    } & {
+      [x: string]: any;
+      hidden: any[];
+      visible: any[];
+      makeVisible(...keys: string[]): /*elided*/any;
+      makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+      getHidden(): any[];
+      getVisible(): any[];
+      setHidden(hidden: any[]): /*elided*/any;
+      setVisible(visible: any[]): /*elided*/any;
+    } & {
+      [x: string]: any;
+      execHooks(hook: any, options: TGeneric): Promise<any>;
+    } & {
+      [x: string]: any;
+      getGlobalScopes(): {};
+    } & {
+      [x: string]: any;
+      useUniqueIds: boolean;
+      usesUniqueIds(): boolean;
+      uniqueIds(): never[];
+      setUniqueIds(): void;
+    }>;
+    (...relations: WithRelationType[]): Promise<(new () => IModel) & IModel & {
+      [x: string]: any;
+      timestamps: boolean;
+      dateFormat: string;
+      usesTimestamps(): boolean;
+      updateTimestamps(): /*elided*/any;
+      getCreatedAtColumn(): any;
+      getUpdatedAtColumn(): any;
+      setCreatedAt(value: any): /*elided*/any;
+      setUpdatedAt(value: any): /*elided*/any;
+      freshTimestamp(): Date;
+      freshTimestampString(): any;
+    } & TGeneric<any, string> & {
+      [x: string]: any;
+      attributes: TGeneric;
+      original: TGeneric;
+      casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+      changes: TGeneric;
+      appends: any[];
+      setAppends(appends: any[]): /*elided*/any;
+      append(...keys: any[]): /*elided*/any;
+      normalizeCastClassResponse(key: string, value: string): TGeneric;
+      syncOriginal(): /*elided*/any;
+      syncChanges(): /*elided*/any;
+      syncOriginalAttribute(attribute: string): void;
+      syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+      isDirty(...attributes: string[]): boolean;
+      getDirty(): TGeneric;
+      originalIsEquivalent(key: string): boolean;
+      setAttributes(attributes: TGeneric): void;
+      setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+      getAttributes(): {
+        [x: string]: any;
+      };
+      setAttribute(key: string, value: string): /*elided*/any;
+      getAttribute(key: string): any;
+      castAttribute(key: string, value: string): any;
+      attributesToData(): {
+        [x: string]: any;
+      };
+      mutateAttribute(key: string, value: string | null): any;
+      mutateAttributeForArray(_key: string, _value: string): void;
+      isDateAttribute(key: string): boolean;
+      serializeDate(date?: Date | string | null): string | null;
+      getDates(): any[];
+      getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+      getCastType(key: string): any;
+      hasCast(key: string, types?: readonly string[]): boolean;
+      withDayjs(date: string): dayjs0.Dayjs;
+      isCustomCast(cast: any): boolean;
+      isCustomDateTimeCast(cast: any): boolean;
+      isDecimalCast(cast: any): boolean;
+      isDateCastable(key: string): boolean;
+      fromDateTime(value: string): string;
+      getDateFormat(): any;
+      asDecimal(value: string, decimals: number): string;
+      asDateTime(value: any): Date | null;
+      asDate(value: string): Date;
+    } & {
+      [x: string]: any;
+      hidden: any[];
+      visible: any[];
+      makeVisible(...keys: string[]): /*elided*/any;
+      makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+      getHidden(): any[];
+      getVisible(): any[];
+      setHidden(hidden: any[]): /*elided*/any;
+      setVisible(visible: any[]): /*elided*/any;
+    } & {
+      [x: string]: any;
+      execHooks(hook: any, options: TGeneric): Promise<any>;
+    } & {
+      [x: string]: any;
+      getGlobalScopes(): {};
+    } & {
+      [x: string]: any;
+      useUniqueIds: boolean;
+      usesUniqueIds(): boolean;
+      uniqueIds(): never[];
+      setUniqueIds(): void;
+    }>;
+  };
+  loadAggregate: (relations: WithRelationType, column: any, callback?: any) => Promise<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }>;
+  loadCount: (...relations: WithRelationType[]) => Promise<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }>;
+  loadMax: (relations: WithRelationType, column: string) => Promise<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }>;
+  loadMin: (relations: WithRelationType, column: string) => Promise<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }>;
+  loadSum: (relations: WithRelationType, column: string) => Promise<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }>;
+  usesTimestamps: (() => boolean) & (() => boolean);
+  updateTimestamps: (() => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & (() => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  getCreatedAtColumn: (() => string) & (() => any);
+  getUpdatedAtColumn: (() => string) & (() => any);
+  getDeletedAtColumn: () => string;
+  setCreatedAt: ((value: string) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((value: any) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  setUpdatedAt: ((value: string) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) & ((value: any) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  });
+  freshTimestamp: (() => Date) & (() => Date);
+  freshTimestampString: (() => string) & (() => any);
+  fromDateTime: ((value: Date | number | null) => string) & ((value: string) => string);
+  useSoftDeletes: () => boolean;
+  toData: () => any;
+  attributesToData: (() => any) & (() => {
+    [x: string]: any;
+  });
+  relationsToData: () => any;
+  toJSON: () => any;
+  toJson: () => string;
+  toString: () => string;
+  isDirty: ((attributes?: string | string[]) => boolean) & ((...attributes: string[]) => boolean);
+  getDirty: (() => string[]) & (() => TGeneric);
+  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) & ((date?: Date | string | null) => string | null);
+  delete: (options?: any) => Promise<boolean>;
+  softDelete: (options?: any) => Promise<boolean>;
+  forceDelete: (options?: any) => Promise<boolean>;
+  restore: (options?: any) => Promise<boolean>;
+  fresh: () => Promise<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }>;
+  refresh: () => Promise<((new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) | undefined>;
+  push: () => Promise<boolean>;
+  is: (model: (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) => boolean;
+  isNot: (model: (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }) => boolean;
+  related: <T$1 extends never>(relation: T$1) => ReturnTypeOfMethod<(new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }, `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;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  }, `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;
+  appends: any[];
+  normalizeCastClassResponse: (key: string, value: string) => TGeneric;
+  syncOriginal: () => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  syncChanges: () => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  syncOriginalAttribute: (attribute: string) => void;
+  syncOriginalAttributes: (...attributes: string[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  originalIsEquivalent: (key: string) => boolean;
+  setAttributes: (attributes: TGeneric) => void;
+  setRawAttributes: (attributes: TGeneric, sync?: boolean) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  castAttribute: (key: string, value: string) => any;
+  mutateAttribute: (key: string, value: string | null) => any;
+  mutateAttributeForArray: (_key: string, _value: string) => void;
+  isDateAttribute: (key: string) => boolean;
+  getCasts: () => TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+  getCastType: (key: string) => any;
+  hasCast: (key: string, types?: readonly string[]) => boolean;
+  withDayjs: (date: string) => dayjs0.Dayjs;
+  isCustomCast: (cast: any) => boolean;
+  isCustomDateTimeCast: (cast: any) => boolean;
+  isDecimalCast: (cast: any) => boolean;
+  isDateCastable: (key: string) => boolean;
+  asDecimal: (value: string, decimals: number) => string;
+  asDateTime: (value: any) => Date | null;
+  asDate: (value: string) => Date;
+  getHidden: () => any[];
+  getVisible: () => any[];
+  setHidden: (hidden: any[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  setVisible: (visible: any[]) => (new () => IModel) & IModel & {
+    [x: string]: any;
+    timestamps: boolean;
+    dateFormat: string;
+    usesTimestamps(): boolean;
+    updateTimestamps(): /*elided*/any;
+    getCreatedAtColumn(): any;
+    getUpdatedAtColumn(): any;
+    setCreatedAt(value: any): /*elided*/any;
+    setUpdatedAt(value: any): /*elided*/any;
+    freshTimestamp(): Date;
+    freshTimestampString(): any;
+  } & TGeneric<any, string> & {
+    [x: string]: any;
+    attributes: TGeneric;
+    original: TGeneric;
+    casts: TGeneric<typeof CastsAttributes | "int" | "json" | "string" | "date" | "boolean" | "datetime" | "collection">;
+    changes: TGeneric;
+    appends: any[];
+    setAppends(appends: any[]): /*elided*/any;
+    append(...keys: any[]): /*elided*/any;
+    normalizeCastClassResponse(key: string, value: string): TGeneric;
+    syncOriginal(): /*elided*/any;
+    syncChanges(): /*elided*/any;
+    syncOriginalAttribute(attribute: string): void;
+    syncOriginalAttributes(...attributes: string[]): /*elided*/any;
+    isDirty(...attributes: string[]): boolean;
+    getDirty(): TGeneric;
+    originalIsEquivalent(key: string): boolean;
+    setAttributes(attributes: TGeneric): void;
+    setRawAttributes(attributes: TGeneric, sync?: boolean): /*elided*/any;
+    getAttributes(): {
+      [x: string]: any;
+    };
+    setAttribute(key: string, value: string): /*elided*/any;
+    getAttribute(key: string): any;
+    castAttribute(key: string, value: string): any;
+    attributesToData(): {
+      [x: string]: any;
+    };
+    mutateAttribute(key: string, value: string | null): any;
+    mutateAttributeForArray(_key: string, _value: string): void;
+    isDateAttribute(key: string): boolean;
+    serializeDate(date?: Date | string | null): string | null;
+    getDates(): any[];
+    getCasts(): TGeneric<"string" | "boolean" | typeof CastsAttributes | "int" | "json" | "date" | "datetime" | "collection">;
+    getCastType(key: string): any;
+    hasCast(key: string, types?: readonly string[]): boolean;
+    withDayjs(date: string): dayjs0.Dayjs;
+    isCustomCast(cast: any): boolean;
+    isCustomDateTimeCast(cast: any): boolean;
+    isDecimalCast(cast: any): boolean;
+    isDateCastable(key: string): boolean;
+    fromDateTime(value: string): string;
+    getDateFormat(): any;
+    asDecimal(value: string, decimals: number): string;
+    asDateTime(value: any): Date | null;
+    asDate(value: string): Date;
+  } & {
+    [x: string]: any;
+    hidden: any[];
+    visible: any[];
+    makeVisible(...keys: string[]): /*elided*/any;
+    makeHidden(key: string[], ...keys: string[]): /*elided*/any;
+    getHidden(): any[];
+    getVisible(): any[];
+    setHidden(hidden: any[]): /*elided*/any;
+    setVisible(visible: any[]): /*elided*/any;
+  } & {
+    [x: string]: any;
+    execHooks(hook: any, options: TGeneric): Promise<any>;
+  } & {
+    [x: string]: any;
+    getGlobalScopes(): {};
+  } & {
+    [x: string]: any;
+    useUniqueIds: boolean;
+    usesUniqueIds(): boolean;
+    uniqueIds(): never[];
+    setUniqueIds(): void;
+  };
+  execHooks: (hook: any, options: TGeneric) => Promise<any>;
+  getGlobalScopes: () => {};
+  useUniqueIds: boolean;
+};
+declare class Model$2 extends BaseModel {
+  [key: string]: any;
+  protected builder: IBuilder<any, any> | null;
+  protected table: string | null;
+  protected keyType: string;
+  protected incrementing: boolean;
+  protected withCount: never[];
+  protected primaryKey: string;
+  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>>;
+  name: any;
+  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$1 extends typeof Model$2>(this: InstanceType<T$1>): T$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;
+  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$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>;
+  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;
+}
+//#endregion
+//#region types/generics.d.ts
+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$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$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$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$1>;
+  _total: number;
+  _perPage: number;
+  _lastPage: number;
+  _currentPage: number;
+  hasMore: boolean;
+  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$1[]): void;
+  firstItem(): number | null;
+  lastItem(): number | null;
+  hasMorePages(): boolean;
+  get(index: number): T$1 | null;
+  count(): number;
+  items(): any;
+  map(callback: (value: T$1, index: number) => T$1): any;
+  currentPage(): number;
+  onFirstPage(): boolean;
+  perPage(): number;
+  lastPage(): number;
+  total(): number;
+  toData(): any;
+  toJSON(): any;
+  toJson(...args: any[]): string;
+}
+//#endregion
+//#region src/browser/index.d.ts
+declare const make: (model: Model$1, data: TGeneric, options?: {
+  paginated: IPaginatorParams;
+}) => any;
+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$1;
+  Pivot: typeof Pivot;
+  Attribute: typeof Attribute;
+  CastsAttributes: typeof CastsAttributes;
+  HasUniqueIds: <TBase extends MixinConstructor>(Model: TBase) => {
+    new (...args: any[]): {
+      [x: string]: any;
+      useUniqueIds: boolean;
+      uniqueIds(): any[];
+      getKeyType(): any;
+      getIncrementing(): any;
+    };
+  } & TBase;
+  make: (model: Model$1, data: TGeneric, options?: {
+    paginated: IPaginatorParams;
+  }) => any;
+  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$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 };