# @zerotal/orm — public API surface

<!-- AUTO-GENERATED by scripts/api-surface.ts. Do not edit by hand.
     Run `bun run api:surface` to regenerate after an intentional API change. -->

> Not a guide — this is a flat, alphabetical snapshot used to detect unintended
> API changes. For how to use these, read the [documentation](https://zerotal.dev/docs).

## .  `(./src/index.ts)`

class ArrayCast = {
  new <T = unknown>(mapper?: CastMapper<T> | undefined): ArrayCast<T>
  fields: () => CastField[]
  get: (dbValue: unknown) => T[]
  readonly shape: 'array'
  set: (value: T[]) => unknown
}

class BaseModel = {
  new (): BaseModel
  static _isFillable: (key: string) => boolean
  static _unscopedQuery: <T extends BaseModel>(this: ModelCtor<T>) => ModelQueryBuilder<T>
  static addGlobalScope: <T extends BaseModel>(this: ModelCtor<T>, name: string, callback: GlobalScopeCallback) => void
  static all: <T extends BaseModel>(this: ModelCtor<T>) => Promise<T[]>
  static appends: string[]
  static bulkInsert: <T extends BaseModel>(this: ModelCtor<T>, records: InsertPayload<T>[]) => Promise<number>
  static casts?: Record<string, 'boolean' | 'date' | 'datetime' | 'array' | 'integer' | 'json' | 'float' | 'enum' | 'immutable_datetime' | 'encrypted' | 'encrypted:json' | `decimal:${number}` | {    get?: (dbValue: unknown) => unknown;    set?: (jsValue: unknown) => unknown;} | CastContract<unknown> | undefined>
  static connection?: string
  static count: <T extends BaseModel>(this: ModelCtor<T>) => Promise<number>
  static create: <T extends BaseModel, F extends string = string>(this: ModelCtor<T> & {    fillable?: readonly F[] | undefined;}, data: FillablePayload<T, F>) => Promise<T>
  static createMany: <T extends BaseModel>(this: ModelCtor<T>, records: InsertPayload<T>[]) => Promise<T[]>
  static dispatchesEvents?: Record<string, new (model: unknown) => object>
  static encryptable?: string[]
  static fillable?: readonly string[]
  static find: <T extends BaseModel>(this: ModelCtor<T>, id: number | string) => Promise<T | null>
  static findBy: <T extends BaseModel>(this: ModelCtor<T>, column: string, value: unknown) => Promise<T | null>
  static findMany: <T extends BaseModel>(this: ModelCtor<T>, ids: (number | string)[]) => Promise<T[]>
  static findOrFail: <T extends BaseModel>(this: ModelCtor<T>, id: number | string) => Promise<T>
  static findOrNew: <T extends BaseModel>(this: ModelCtor<T>, id: number | string) => Promise<T>
  static first: <T extends BaseModel>(this: ModelCtor<T>) => Promise<T | null>
  static firstOrCreate: <T extends BaseModel>(this: ModelCtor<T>, search: UpdatePayload<T>, create?: UpdatePayload<T>) => Promise<T>
  static firstOrFail: <T extends BaseModel>(this: ModelCtor<T>) => Promise<T>
  static firstOrNew: <T extends BaseModel>(this: ModelCtor<T>, search: UpdatePayload<T>, values?: UpdatePayload<T>) => Promise<T>
  static forceCreate: <T extends BaseModel>(this: ModelCtor<T>, data: Record<string, unknown>) => Promise<T>
  static fromRow: (row: Record<string, unknown>) => BaseModel
  static guarded?: readonly string[]
  static hashable?: string[]
  static hidden: string[]
  static implicitBinding?: boolean
  static implicitBindingKey?: string
  static latest: <T extends BaseModel>(this: ModelCtor<T>, column?: string) => ModelQueryBuilder<T>
  static loadCount: <T extends BaseModel>(this: typeof BaseModel, models: T[], relations: string | string[]) => Promise<T[]>
  static massPrune: boolean
  static observe: <T extends BaseModel>(this: ModelCtor<T>, ObserverClass: new () => ModelObserver<T>) => void
  static oldest: <T extends BaseModel>(this: ModelCtor<T>, column?: string) => ModelQueryBuilder<T>
  static orderBy: <T extends BaseModel>(this: ModelCtor<T>, column: string, direction?: OrderDirection) => ModelQueryBuilder<T>
  static paginate: <T extends BaseModel>(this: ModelCtor<T>, perPage?: number, page?: number, pageName?: string) => Promise<PaginateResult<T>>
  static primaryKey: string
  static prunable?: <T extends BaseModel>(this: ModelCtor<T>) => ModelQueryBuilder<T>
  static prune: <T extends BaseModel>(this: ModelCtor<T>, chunkSize?: number) => Promise<number>
  static query: <T extends BaseModel>(this: ModelCtor<T>) => ModelQueryBuilder<T>
  static reactiveCasts: boolean
  static registerConnection: (name: string, conn: SQLInstance, dialect?: Dialect) => void
  static reguard: () => void
  static removeGlobalScope: <T extends BaseModel>(this: ModelCtor<T>, name: string) => void
  static saveMany: <T extends BaseModel>(this: ModelCtor<T>, models: T[]) => Promise<T[]>
  static scope: <Args extends unknown[]>(fn: (query: QueryBuilder, ...args: Args) => void) => (...args: Args) => ScopeApplicator
  static softDeletes: boolean
  static table: string
  static timestamps: boolean
  static unguard: () => void
  static unguarded: boolean
  static updateOrCreate: <T extends BaseModel>(this: ModelCtor<T>, search: UpdatePayload<T>, values?: UpdatePayload<T>) => Promise<T>
  static upsert: <T extends BaseModel>(this: ModelCtor<T>, data: InsertPayload<T>, conflictKeys: (keyof T & string)[], updateCols?: (keyof T & string)[]) => Promise<void>
  static using: Compose
  static visible: string[]
  static where: {    <T extends BaseModel>(this: ModelCtor<T>, column: string, value: unknown): ModelQueryBuilder<T>;    <T extends BaseModel>(this: ModelCtor<T>, column: string, operator: WhereOperator, value: unknown): ModelQueryBuilder<T>;}
  static whereIn: <T extends BaseModel>(this: ModelCtor<T>, column: string, values: unknown[]) => ModelQueryBuilder<T>
  static withoutGuard: <T>(callback: () => T | Promise<T>) => Promise<T>
  static withoutTimestamps: <R>(callback: () => Promise<R> | R) => Promise<R>
  $dirty: () => Record<string, unknown>
  append: (...keys: string[]) => BaseModel
  associate: (relation: string, model: BaseModel) => BaseModel
  createdAt?: Carbon
  decrement: (column: 'id' | 'createdAt' | 'updatedAt' | '__isZerotalModel' | 'fill' | 'forceFill' | 'save' | 'delete' | 'load' | 'loadMissing' | 'fresh' | 'refresh' | 'replicate' | 'touch' | 'is' | 'isNot' | 'increment' | 'decrement' | 'loadCount' | 'loadSum' | 'loadAvg' | 'loadMin' | 'loadMax' | 'makeHidden' | 'makeVisible' | 'append' | 'associate' | 'dissociate' | 'isDirty' | '$dirty' | 'markDirty' | 'toJSON', amount?: number) => Promise<BaseModel>
  delete: () => Promise<void>
  dissociate: (relation: string) => BaseModel
  fill: (data: Partial<InsertPayload<BaseModel>>) => BaseModel
  forceFill: (data: Record<string, unknown>) => BaseModel
  fresh: () => Promise<BaseModel>
  id: number
  increment: (column: 'id' | 'createdAt' | 'updatedAt' | '__isZerotalModel' | 'fill' | 'forceFill' | 'save' | 'delete' | 'load' | 'loadMissing' | 'fresh' | 'refresh' | 'replicate' | 'touch' | 'is' | 'isNot' | 'increment' | 'decrement' | 'loadCount' | 'loadSum' | 'loadAvg' | 'loadMin' | 'loadMax' | 'makeHidden' | 'makeVisible' | 'append' | 'associate' | 'dissociate' | 'isDirty' | '$dirty' | 'markDirty' | 'toJSON', amount?: number) => Promise<BaseModel>
  is: (other: BaseModel | null | undefined) => boolean
  isDirty: (column?: string) => boolean
  isNot: (other: BaseModel | null | undefined) => boolean
  load: (relations: string[]) => Promise<BaseModel>
  loadAvg: (relation: string, column: string) => Promise<BaseModel>
  loadCount: (relations: string | string[]) => Promise<BaseModel>
  loadMax: (relation: string, column: string) => Promise<BaseModel>
  loadMin: (relation: string, column: string) => Promise<BaseModel>
  loadMissing: (relations: string[]) => Promise<BaseModel>
  loadSum: (relation: string, column: string) => Promise<BaseModel>
  makeHidden: (...keys: string[]) => BaseModel
  makeVisible: (...keys: string[]) => BaseModel
  markDirty: (property: keyof BaseModel) => BaseModel
  readonly __isZerotalModel: true
  refresh: () => Promise<BaseModel>
  replicate: (except?: string[]) => BaseModel
  save: () => Promise<BaseModel>
  toJSON: () => Record<string, unknown>
  touch: () => Promise<BaseModel>
  updatedAt?: Carbon
}

class Blueprint = {
  new (): Blueprint
  _pendingDrops: readonly string[]
  bigIncrements: (name?: string) => ColumnBuilder
  bigInteger: (name: string) => ColumnBuilder
  binary: (name: string) => ColumnBuilder
  boolean: (name: string) => ColumnBuilder
  char: (name: string, length?: number) => ColumnBuilder
  date: (name: string) => ColumnBuilder
  dateTime: (name: string) => ColumnBuilder
  datetime: (name: string) => ColumnBuilder
  decimal: (name: string, _precision?: number, _scale?: number) => ColumnBuilder
  double: (name: string, _precision?: number, _scale?: number) => ColumnBuilder
  dropColumn: (...names: string[]) => Blueprint
  dropForeign: (nameOrColumns: string | string[]) => Blueprint
  dropIndex: (nameOrColumns: string | string[]) => Blueprint
  dropPrimary: () => Blueprint
  dropUnique: (nameOrColumns: string | string[]) => Blueprint
  enum: (name: string, values: string[]) => ColumnBuilder<'check'>
  float: (name: string) => ColumnBuilder
  foreign: (column: string) => ForeignKeyBuilder
  foreignId: (name: string) => ForeignIdColumnBuilder
  foreignUuid: (name: string) => ForeignIdColumnBuilder
  fulltext: (columns: string | string[], name?: string) => Blueprint
  id: (name?: string) => ColumnBuilder
  increments: (name?: string) => ColumnBuilder
  index: (columns: string | string[], name?: string) => Blueprint
  integer: (name: string) => ColumnBuilder
  ipAddress: (name: string) => ColumnBuilder
  json: (name: string) => ColumnBuilder
  longText: (name: string) => ColumnBuilder
  macAddress: (name: string) => ColumnBuilder
  mediumInteger: (name: string) => ColumnBuilder
  mediumText: (name: string) => ColumnBuilder
  morphs: (name: string, indexName?: string) => void
  nullableMorphs: (name: string, indexName?: string) => void
  nullableTimestamps: () => void
  primary: (columns: string | string[], _name?: string) => Blueprint
  rememberToken: () => ColumnBuilder<'nullability'>
  renameColumn: (from: string, to: string) => Blueprint
  set: (name: string, _values: string[]) => ColumnBuilder
  smallInteger: (name: string) => ColumnBuilder
  softDeletes: (column?: string) => void
  spatialIndex: (columns: string | string[], name?: string) => Blueprint
  string: (name: string, length?: number) => ColumnBuilder
  text: (name: string) => ColumnBuilder
  time: (name: string) => ColumnBuilder
  timestamp: (name: string) => ColumnBuilder
  timestamps: () => void
  tinyInteger: (name: string) => ColumnBuilder
  tinyText: (name: string) => ColumnBuilder
  toAlterSQL: (table: string, dialect?: 'sqlite' | 'mysql' | 'postgres') => string[]
  toCreateSQL: (table: string, dialect?: 'sqlite' | 'mysql' | 'postgres') => string[]
  ulid: (name: string) => ColumnBuilder
  unique: (columns: string | string[], name?: string) => Blueprint
  unsignedBigInteger: (name: string) => ColumnBuilder<'unsigned'>
  unsignedDecimal: (name: string, _precision?: number, _scale?: number) => ColumnBuilder<'unsigned'>
  unsignedInteger: (name: string) => ColumnBuilder<'unsigned'>
  unsignedMediumInteger: (name: string) => ColumnBuilder<'unsigned'>
  unsignedSmallInteger: (name: string) => ColumnBuilder<'unsigned'>
  unsignedTinyInteger: (name: string) => ColumnBuilder<'unsigned'>
  uuid: (name: string) => ColumnBuilder
  uuidMorphs: (name: string, indexName?: string) => void
  year: (name: string) => ColumnBuilder
}

class Cast = {
  new <T = unknown>(): Cast<T>
  get: (dbValue: unknown) => T
  set: (value: T) => unknown
}

class ColumnBuilder = {
  new <Locked extends string = never>(name: string, _sqlType: string, isPrimary?: boolean, isAutoIncrement?: boolean, _isBoolean?: boolean, _stringLength?: number | undefined): ColumnBuilder<Locked>
  after: (_column: string) => ColumnBuilder<Locked>
  alter: () => ColumnBuilder<Locked>
  before: (_column: string) => ColumnBuilder<Locked>
  change: () => ColumnBuilder<Locked>
  check: (expression: string) => 'check' extends Locked ? never : ColumnBuilder<Locked | 'check'>
  comment: (_text: string) => ColumnBuilder<Locked>
  default: (value: unknown) => 'default' extends Locked ? never : ColumnBuilder<Locked | 'default'>
  defaultTo: (value: unknown) => 'default' extends Locked ? never : ColumnBuilder<Locked | 'default'>
  index: () => 'index' extends Locked ? never : ColumnBuilder<Locked | 'index'>
  isAlter: boolean
  isPrimary: boolean
  notNullable: () => 'nullability' extends Locked ? never : ColumnBuilder<Locked | 'nullability'>
  nullable: () => 'nullability' extends Locked ? never : ColumnBuilder<Locked | 'nullability'>
  primary: () => 'primary' extends Locked ? never : ColumnBuilder<Locked | 'primary'>
  readonly name: string
  storedAs: (expression: string) => 'generated' extends Locked ? never : ColumnBuilder<Locked | 'generated'>
  toColumnSQL: (dialect?: DialectName) => string
  unique: () => 'unique' extends Locked ? never : ColumnBuilder<Locked | 'unique'>
  unsigned: () => 'unsigned' extends Locked ? never : ColumnBuilder<Locked | 'unsigned'>
  useCurrent: () => 'default' extends Locked ? never : ColumnBuilder<Locked | 'default'>
  useCurrentOnUpdate: () => ColumnBuilder<Locked>
  virtualAs: (expression: string) => 'generated' extends Locked ? never : ColumnBuilder<Locked | 'generated'>
  wantsIndex: boolean
}

class ColumnTypeError = {
  new (column: string, declared: string): ColumnTypeError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class DatabaseProvider = {
  new (app: Application): DatabaseProvider
  static dependsOn?: (new (app: Application) => ServiceProvider)[]
  static environments: AppEnvironment[]
  static priority?: number
  static provides: readonly ['db']
  devProcesses: () => DevProcessDefinition[]
  doctorChecks: () => DoctorCheck[]
  onBooted: () => Promise<void>
  onBooting: () => Promise<void>
  onRegister: () => void
  onRequestProcessed: (_ctx: HttpContext) => Promise<void>
  onRequestReceived: (_ctx: HttpContext) => Promise<void>
  onResponseSent: (_ctx: HttpContext) => Promise<void>
  onStarted: () => Promise<void>
  onStarting: () => Promise<void>
  onStopped: () => Promise<void>
  onStopping: () => Promise<void>
  replContext: () => Record<string, unknown>
}

class EncryptedColumnError = {
  new (message: string, code: string, context?: Record<string, unknown>): EncryptedColumnError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class ForeignIdColumnBuilder = {
  new <Locked extends string = never>(name: string, sqlType: string, _addFk: (col: string) => ForeignKeyBuilder): ForeignIdColumnBuilder<Locked>
  after: (_column: string) => ForeignIdColumnBuilder<Locked>
  alter: () => ForeignIdColumnBuilder<Locked>
  before: (_column: string) => ForeignIdColumnBuilder<Locked>
  change: () => ForeignIdColumnBuilder<Locked>
  check: (expression: string) => 'check' extends Locked ? never : ColumnBuilder<'check' | Locked>
  comment: (_text: string) => ForeignIdColumnBuilder<Locked>
  constrained: (table?: string, column?: string) => ForeignKeyBuilder
  default: (value: unknown) => 'default' extends Locked ? never : ColumnBuilder<'default' | Locked>
  defaultTo: (value: unknown) => 'default' extends Locked ? never : ColumnBuilder<'default' | Locked>
  index: () => 'index' extends Locked ? never : ColumnBuilder<'index' | Locked>
  isAlter: boolean
  isPrimary: boolean
  notNullable: () => 'nullability' extends Locked ? never : ForeignIdColumnBuilder<Locked | 'nullability'>
  nullable: () => 'nullability' extends Locked ? never : ForeignIdColumnBuilder<Locked | 'nullability'>
  primary: () => 'primary' extends Locked ? never : ColumnBuilder<'primary' | Locked>
  readonly name: string
  storedAs: (expression: string) => 'generated' extends Locked ? never : ColumnBuilder<Locked | 'generated'>
  toColumnSQL: (dialect?: DialectName) => string
  unique: () => 'unique' extends Locked ? never : ColumnBuilder<'unique' | Locked>
  unsigned: () => 'unsigned' extends Locked ? never : ColumnBuilder<'unsigned' | Locked>
  useCurrent: () => 'default' extends Locked ? never : ColumnBuilder<'default' | Locked>
  useCurrentOnUpdate: () => ForeignIdColumnBuilder<Locked>
  virtualAs: (expression: string) => 'generated' extends Locked ? never : ColumnBuilder<Locked | 'generated'>
  wantsIndex: boolean
}

class ForeignKeyBuilder = {
  new (_column: string): ForeignKeyBuilder
  cascadeOnDelete: () => ForeignKeyBuilder
  cascadeOnUpdate: () => ForeignKeyBuilder
  nullOnDelete: () => ForeignKeyBuilder
  on: (table: string) => ForeignKeyBuilder
  onDelete: (action: FKAction) => ForeignKeyBuilder
  onUpdate: (action: FKAction) => ForeignKeyBuilder
  references: (columnOrTableDotColumn: string) => ForeignKeyBuilder
  restrictOnDelete: () => ForeignKeyBuilder
  toConstraintSQL: () => string
}

class JsonCast = {
  new <T = unknown>(mapper?: CastMapper<T> | undefined): JsonCast<T>
  fields: () => CastField[]
  get: (dbValue: unknown) => T | null
  readonly shape: 'object'
  set: (value: T | null) => unknown
}

class Migration = {
  new (): Migration
  static id?: string
  down: () => Promise<void>
  up: () => Promise<void>
}

class MigrationError = {
  new (migrationName: string, cause: Error): MigrationError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class MigrationRan = {
  new (name: string, direction: 'up' | 'down', durationMs: number, ok: boolean, error?: string | undefined): MigrationRan
  readonly direction: 'down' | 'up'
  readonly durationMs: number
  readonly error?: string | undefined
  readonly name: string
  readonly ok: boolean
}

class MigrationRunner = {
  new (options: { connection: SQLInstance; table?: string; }): MigrationRunner
  pending: (entries: MigrationEntry[]) => Promise<string[]>
  reset: (entries: MigrationEntry[]) => Promise<void>
  rollback: (entries: MigrationEntry[]) => Promise<string[]>
  rollbackFromDirectory: (dir: string) => Promise<string[]>
  run: (entries: MigrationEntry[]) => Promise<string[]>
  runFromDirectory: (dir: string) => Promise<string[]>
  status: (entries: MigrationEntry[]) => Promise<MigrationStatus[]>
  willRollBackOnFailure: boolean
}

class Model = {
  new (): BaseModel
  static _isFillable: (key: string) => boolean
  static _unscopedQuery: <T extends BaseModel>(this: ModelCtor<T>) => ModelQueryBuilder<T>
  static addGlobalScope: <T extends BaseModel>(this: ModelCtor<T>, name: string, callback: GlobalScopeCallback) => void
  static all: <T extends BaseModel>(this: ModelCtor<T>) => Promise<T[]>
  static appends: string[]
  static bulkInsert: <T extends BaseModel>(this: ModelCtor<T>, records: InsertPayload<T>[]) => Promise<number>
  static casts?: Record<string, 'boolean' | 'date' | 'datetime' | 'array' | 'integer' | 'json' | 'float' | 'enum' | 'immutable_datetime' | 'encrypted' | 'encrypted:json' | `decimal:${number}` | {    get?: (dbValue: unknown) => unknown;    set?: (jsValue: unknown) => unknown;} | CastContract<unknown> | undefined>
  static connection?: string
  static count: <T extends BaseModel>(this: ModelCtor<T>) => Promise<number>
  static create: <T extends BaseModel, F extends string = string>(this: ModelCtor<T> & {    fillable?: readonly F[] | undefined;}, data: FillablePayload<T, F>) => Promise<T>
  static createMany: <T extends BaseModel>(this: ModelCtor<T>, records: InsertPayload<T>[]) => Promise<T[]>
  static dispatchesEvents?: Record<string, new (model: unknown) => object>
  static encryptable?: string[]
  static fillable?: readonly string[]
  static find: <T extends BaseModel>(this: ModelCtor<T>, id: number | string) => Promise<T | null>
  static findBy: <T extends BaseModel>(this: ModelCtor<T>, column: string, value: unknown) => Promise<T | null>
  static findMany: <T extends BaseModel>(this: ModelCtor<T>, ids: (number | string)[]) => Promise<T[]>
  static findOrFail: <T extends BaseModel>(this: ModelCtor<T>, id: number | string) => Promise<T>
  static findOrNew: <T extends BaseModel>(this: ModelCtor<T>, id: number | string) => Promise<T>
  static first: <T extends BaseModel>(this: ModelCtor<T>) => Promise<T | null>
  static firstOrCreate: <T extends BaseModel>(this: ModelCtor<T>, search: UpdatePayload<T>, create?: UpdatePayload<T>) => Promise<T>
  static firstOrFail: <T extends BaseModel>(this: ModelCtor<T>) => Promise<T>
  static firstOrNew: <T extends BaseModel>(this: ModelCtor<T>, search: UpdatePayload<T>, values?: UpdatePayload<T>) => Promise<T>
  static forceCreate: <T extends BaseModel>(this: ModelCtor<T>, data: Record<string, unknown>) => Promise<T>
  static fromRow: (row: Record<string, unknown>) => BaseModel
  static guarded?: readonly string[]
  static hashable?: string[]
  static hidden: string[]
  static implicitBinding?: boolean
  static implicitBindingKey?: string
  static latest: <T extends BaseModel>(this: ModelCtor<T>, column?: string) => ModelQueryBuilder<T>
  static loadCount: <T extends BaseModel>(this: typeof BaseModel, models: T[], relations: string | string[]) => Promise<T[]>
  static massPrune: boolean
  static observe: <T extends BaseModel>(this: ModelCtor<T>, ObserverClass: new () => ModelObserver<T>) => void
  static oldest: <T extends BaseModel>(this: ModelCtor<T>, column?: string) => ModelQueryBuilder<T>
  static orderBy: <T extends BaseModel>(this: ModelCtor<T>, column: string, direction?: OrderDirection) => ModelQueryBuilder<T>
  static paginate: <T extends BaseModel>(this: ModelCtor<T>, perPage?: number, page?: number, pageName?: string) => Promise<PaginateResult<T>>
  static primaryKey: string
  static prunable?: <T extends BaseModel>(this: ModelCtor<T>) => ModelQueryBuilder<T>
  static prune: <T extends BaseModel>(this: ModelCtor<T>, chunkSize?: number) => Promise<number>
  static query: <T extends BaseModel>(this: ModelCtor<T>) => ModelQueryBuilder<T>
  static reactiveCasts: boolean
  static registerConnection: (name: string, conn: SQLInstance, dialect?: Dialect) => void
  static reguard: () => void
  static removeGlobalScope: <T extends BaseModel>(this: ModelCtor<T>, name: string) => void
  static saveMany: <T extends BaseModel>(this: ModelCtor<T>, models: T[]) => Promise<T[]>
  static scope: <Args extends unknown[]>(fn: (query: QueryBuilder, ...args: Args) => void) => (...args: Args) => ScopeApplicator
  static softDeletes: boolean
  static table: string
  static timestamps: boolean
  static unguard: () => void
  static unguarded: boolean
  static updateOrCreate: <T extends BaseModel>(this: ModelCtor<T>, search: UpdatePayload<T>, values?: UpdatePayload<T>) => Promise<T>
  static upsert: <T extends BaseModel>(this: ModelCtor<T>, data: InsertPayload<T>, conflictKeys: (keyof T & string)[], updateCols?: (keyof T & string)[]) => Promise<void>
  static using: Compose
  static visible: string[]
  static where: {    <T extends BaseModel>(this: ModelCtor<T>, column: string, value: unknown): ModelQueryBuilder<T>;    <T extends BaseModel>(this: ModelCtor<T>, column: string, operator: WhereOperator, value: unknown): ModelQueryBuilder<T>;}
  static whereIn: <T extends BaseModel>(this: ModelCtor<T>, column: string, values: unknown[]) => ModelQueryBuilder<T>
  static withoutGuard: <T>(callback: () => T | Promise<T>) => Promise<T>
  static withoutTimestamps: <R>(callback: () => Promise<R> | R) => Promise<R>
  $dirty: () => Record<string, unknown>
  append: (...keys: string[]) => BaseModel
  associate: (relation: string, model: BaseModel) => BaseModel
  createdAt?: Carbon
  decrement: (column: 'id' | 'createdAt' | 'updatedAt' | '__isZerotalModel' | 'fill' | 'forceFill' | 'save' | 'delete' | 'load' | 'loadMissing' | 'fresh' | 'refresh' | 'replicate' | 'touch' | 'is' | 'isNot' | 'increment' | 'decrement' | 'loadCount' | 'loadSum' | 'loadAvg' | 'loadMin' | 'loadMax' | 'makeHidden' | 'makeVisible' | 'append' | 'associate' | 'dissociate' | 'isDirty' | '$dirty' | 'markDirty' | 'toJSON', amount?: number) => Promise<BaseModel>
  delete: () => Promise<void>
  dissociate: (relation: string) => BaseModel
  fill: (data: Partial<InsertPayload<BaseModel>>) => BaseModel
  forceFill: (data: Record<string, unknown>) => BaseModel
  fresh: () => Promise<BaseModel>
  id: number
  increment: (column: 'id' | 'createdAt' | 'updatedAt' | '__isZerotalModel' | 'fill' | 'forceFill' | 'save' | 'delete' | 'load' | 'loadMissing' | 'fresh' | 'refresh' | 'replicate' | 'touch' | 'is' | 'isNot' | 'increment' | 'decrement' | 'loadCount' | 'loadSum' | 'loadAvg' | 'loadMin' | 'loadMax' | 'makeHidden' | 'makeVisible' | 'append' | 'associate' | 'dissociate' | 'isDirty' | '$dirty' | 'markDirty' | 'toJSON', amount?: number) => Promise<BaseModel>
  is: (other: BaseModel | null | undefined) => boolean
  isDirty: (column?: string) => boolean
  isNot: (other: BaseModel | null | undefined) => boolean
  load: (relations: string[]) => Promise<BaseModel>
  loadAvg: (relation: string, column: string) => Promise<BaseModel>
  loadCount: (relations: string | string[]) => Promise<BaseModel>
  loadMax: (relation: string, column: string) => Promise<BaseModel>
  loadMin: (relation: string, column: string) => Promise<BaseModel>
  loadMissing: (relations: string[]) => Promise<BaseModel>
  loadSum: (relation: string, column: string) => Promise<BaseModel>
  makeHidden: (...keys: string[]) => BaseModel
  makeVisible: (...keys: string[]) => BaseModel
  markDirty: (property: keyof BaseModel) => BaseModel
  readonly __isZerotalModel: true
  refresh: () => Promise<BaseModel>
  replicate: (except?: string[]) => BaseModel
  save: () => Promise<BaseModel>
  toJSON: () => Record<string, unknown>
  touch: () => Promise<BaseModel>
  updatedAt?: Carbon
}

class ModelChanged = {
  new (model: string, table: string, operation: 'created' | 'updated' | 'deleted'): ModelChanged
  readonly model: string
  readonly operation: 'created' | 'updated' | 'deleted'
  readonly table: string
}

class ModelNotFoundError = {
  new (model: string, id?: number | string): ModelNotFoundError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class ModelQueryBuilder = {
  new <M extends BaseModel>(table: string, sql: SQLInstance, ModelClass: typeof BaseModel): ModelQueryBuilder<M>
  _markUserWhereStart: () => void
  asc: (column?: string) => ModelQueryBuilder<M>
  avg: (column: string) => Promise<number>
  chunk: <T = Record<string, unknown>>(size: number, callback: (rows: T[], page: number) => unknown | Promise<unknown>) => Promise<void>
  chunkById: <T = Record<string, unknown>>(size: number, callback: (rows: T[]) => unknown | Promise<unknown>, column?: string) => Promise<void>
  clone: () => ModelQueryBuilder<M>
  count: () => Promise<number>
  crossJoin: (table: string) => ModelQueryBuilder<M>
  cursor: <T = Record<string, unknown>>(size?: number) => AsyncGenerator<T>
  cursorPaginate: <T = M>(options?: {    cursor?: number;    limit?: number;} | undefined) => Promise<CursorPaginateResult<T>>
  dd: () => ModelQueryBuilder<M>
  decrement: (column: string, amount?: number) => Promise<void>
  delete: () => Promise<void>
  desc: (column?: string) => ModelQueryBuilder<M>
  distinct: () => ModelQueryBuilder<M>
  doesntExist: () => Promise<boolean>
  doesntHave: (relation: string, callback?: RelationConstraint) => ModelQueryBuilder<M>
  dump: () => ModelQueryBuilder<M>
  each: <T = Record<string, unknown>>(callback: (row: T, index: number) => unknown | Promise<unknown>, size?: number) => Promise<void>
  exists: () => Promise<boolean>
  explain: <T = Record<string, unknown>>() => Promise<T[]>
  findOrFail: (id: number) => Promise<M>
  first: <T = M>() => Promise<T | null>
  firstOrFail: () => Promise<M>
  from: (table: string) => ModelQueryBuilder<M>
  get: <T = M>() => Promise<T[]>
  groupBy: (...columns: string[]) => ModelQueryBuilder<M>
  has: (relation: string, operator?: string, count?: number) => ModelQueryBuilder<M>
  having: (column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  inRandomOrder: () => ModelQueryBuilder<M>
  increment: (column: string, amount?: number) => Promise<void>
  insert: (data: Record<string, unknown>) => Promise<void>
  join: (table: string, first: string, operator: string, second: string) => ModelQueryBuilder<M>
  joinSub: (sub: QueryBuilder | ((q: QueryBuilder) => void), alias: string, first: string, operator: string, second: string, type?: JoinType) => ModelQueryBuilder<M>
  keysetPaginate: <T = M>(options?: KeysetOptions) => Promise<KeysetPaginateResult<T>>
  latest: (column?: string) => ModelQueryBuilder<M>
  lazy: <T = Record<string, unknown>>(size?: number) => AsyncGenerator<T>
  lazyById: <T = Record<string, unknown>>(size?: number, column?: string) => AsyncGenerator<T>
  leftJoin: (table: string, first: string, operator: string, second: string) => ModelQueryBuilder<M>
  limit: (n: number) => ModelQueryBuilder<M>
  lockForUpdate: () => ModelQueryBuilder<M>
  max: (column: string) => Promise<number>
  min: (column: string) => Promise<number>
  offset: (n: number) => ModelQueryBuilder<M>
  oldest: (column?: string) => ModelQueryBuilder<M>
  orDoesntHave: (relation: string, callback?: RelationConstraint) => ModelQueryBuilder<M>
  orHas: (relation: string, operator?: string, count?: number) => ModelQueryBuilder<M>
  orWhere: {    (column: string, value: unknown): ModelQueryBuilder<M>;    (column: string, operator: WhereOperator, value: unknown): ModelQueryBuilder<M>;    (group: (query: ModelQueryBuilder<M>) => void): ModelQueryBuilder<M>;}
  orWhereBetween: (column: string, range: [unknown, unknown]) => ModelQueryBuilder<M>
  orWhereColumn: (first: string, operatorOrSecond: string, second?: string) => ModelQueryBuilder<M>
  orWhereDoesntHave: (relation: string, callback?: RelationConstraint) => ModelQueryBuilder<M>
  orWhereExists: (callback: (q: QueryBuilder) => void) => ModelQueryBuilder<M>
  orWhereHas: (relation: string, callback?: RelationConstraint) => ModelQueryBuilder<M>
  orWhereIn: (column: string, values: unknown[]) => ModelQueryBuilder<M>
  orWhereLike: (column: string, value: string) => ModelQueryBuilder<M>
  orWhereNotBetween: (column: string, range: [unknown, unknown]) => ModelQueryBuilder<M>
  orWhereNotExists: (callback: (q: QueryBuilder) => void) => ModelQueryBuilder<M>
  orWhereNotIn: (column: string, values: unknown[]) => ModelQueryBuilder<M>
  orWhereNotLike: (column: string, value: string) => ModelQueryBuilder<M>
  orWhereNotNull: (column: string) => ModelQueryBuilder<M>
  orWhereNull: (column: string) => ModelQueryBuilder<M>
  orWhereRaw: (sql: string, bindings?: unknown[]) => ModelQueryBuilder<M>
  orWhereRelation: (relation: string, column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  orderBy: (column: string, direction?: OrderDirection) => ModelQueryBuilder<M>
  orderByDesc: (column: string) => ModelQueryBuilder<M>
  orderByRaw: (expression: string) => ModelQueryBuilder<M>
  paginate: <T = M>(perPage?: number, page?: number, pageName?: string) => Promise<PaginateResult<T>>
  pluck: <V = unknown>(column: string, key?: string) => Promise<V[] | Record<string, V>>
  reorder: (column?: string, direction?: OrderDirection) => ModelQueryBuilder<M>
  rightJoin: (table: string, first: string, operator: string, second: string) => ModelQueryBuilder<M>
  select: (...columns: string[]) => ModelQueryBuilder<M>
  selectRaw: (expression: string) => ModelQueryBuilder<M>
  sharedLock: () => ModelQueryBuilder<M>
  simplePaginate: <T = M>(perPage?: number, page?: number) => Promise<SimplePaginateResult<T>>
  sole: <T = Record<string, unknown>>() => Promise<T>
  sum: (column: string) => Promise<number>
  toRawSql: () => string
  toSql: () => string
  toSqlWithBindings: () => {    sql: string;    bindings: unknown[];}
  union: (other: QueryBuilder, all?: boolean) => ModelQueryBuilder<M>
  unionAll: (other: QueryBuilder) => ModelQueryBuilder<M>
  update: (data: Record<string, unknown>) => Promise<void>
  updateOrInsert: (attributes: Record<string, unknown>, values?: Record<string, unknown>) => Promise<boolean>
  value: <V = unknown>(column: string) => Promise<V | null>
  when: (condition: unknown, callback: (q: QueryBuilder, value: unknown) => void) => ModelQueryBuilder<M>
  where: {    (column: string, value: unknown): ModelQueryBuilder<M>;    (column: string, operator: WhereOperator, value: unknown): ModelQueryBuilder<M>;    (group: (query: ModelQueryBuilder<M>) => void): ModelQueryBuilder<M>;}
  whereAll: (columns: string[], operator: string, value: unknown) => ModelQueryBuilder<M>
  whereAny: (columns: string[], operator: string, value: unknown) => ModelQueryBuilder<M>
  whereBetween: (column: string, range: [unknown, unknown]) => ModelQueryBuilder<M>
  whereColumn: (first: string, operatorOrSecond: string, second?: string) => ModelQueryBuilder<M>
  whereDate: (column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  whereDay: (column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  whereDoesntHave: (relation: string, callback?: RelationConstraint) => ModelQueryBuilder<M>
  whereExists: (callback: (q: QueryBuilder) => void) => ModelQueryBuilder<M>
  whereHas: (relation: string, callback?: RelationConstraint, operator?: string, count?: number) => ModelQueryBuilder<M>
  whereIn: (column: string, values: unknown[]) => ModelQueryBuilder<M>
  whereJson: (column: string, value: unknown) => ModelQueryBuilder<M>
  whereLike: (column: string, value: string) => ModelQueryBuilder<M>
  whereMonth: (column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  whereNotBetween: (column: string, range: [unknown, unknown]) => ModelQueryBuilder<M>
  whereNotExists: (callback: (q: QueryBuilder) => void) => ModelQueryBuilder<M>
  whereNotIn: (column: string, values: unknown[]) => ModelQueryBuilder<M>
  whereNotLike: (column: string, value: string) => ModelQueryBuilder<M>
  whereNotNull: (column: string) => ModelQueryBuilder<M>
  whereNull: (column: string) => ModelQueryBuilder<M>
  whereRaw: (sql: string, bindings?: unknown[]) => ModelQueryBuilder<M>
  whereRelation: (relation: string, column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  whereTime: (column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  whereYear: (column: string, operatorOrValue: unknown, value?: unknown) => ModelQueryBuilder<M>
  with: {    <K extends keyof M & string>(relation: K): ModelQueryBuilder<Omit<M, K> & { [K in K]: M[K] extends ManyToMany<infer T> ? ManyToMany<T> : M[K] extends HasMany<infer T> ? T[] : M[K] extends BelongsTo<infer T> ? T | null : M[K] extends HasOne<infer T> ? T | null : M[K] extends MorphTo<infer T> ? T | null : M[K] extends MorphMany<infer T> ? T[] : M[K] extends MorphOne<infer T> ? T | null : M[K]; } & BaseModel>;    (relation: string, constraint: RelationConstraint): ModelQueryBuilder<M>;    (relations: Array<string | Record<string, RelationConstraint>>): ModelQueryBuilder<M>;    (map: Record<string, RelationConstraint | true>): ModelQueryBuilder<M>;}
  withAvg: (relation: string, column: string, constraint?: RelationConstraint) => ModelQueryBuilder<M>
  withCount: (relation: string | string[] | Record<string, RelationConstraint>, constraint?: RelationConstraint) => ModelQueryBuilder<M>
  withExists: (relation: string, constraint?: RelationConstraint) => ModelQueryBuilder<M>
  withMax: (relation: string, column: string, constraint?: RelationConstraint) => ModelQueryBuilder<M>
  withMin: (relation: string, column: string, constraint?: RelationConstraint) => ModelQueryBuilder<M>
  withScopes: (callback: (scopes: any) => void) => ModelQueryBuilder<M>
  withSum: (relation: string, column: string, constraint?: RelationConstraint) => ModelQueryBuilder<M>
  withWhereHas: (relation: string, callback?: RelationConstraint) => ModelQueryBuilder<M>
  withoutGlobalScope: (...names: string[]) => ModelQueryBuilder<M>
  withoutGlobalScopes: () => ModelQueryBuilder<M>
  withoutTenancy: () => ModelQueryBuilder<M>
}

class NPlusOneDetected = {
  new (fingerprint: string, count: number, ctx: object | undefined): NPlusOneDetected
  readonly count: number
  readonly ctx: object | undefined
  readonly fingerprint: string
}

class NPlusOneError = {
  new (fingerprint: string, count: number, distinctArgs?: number): NPlusOneError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly count: number
  readonly distinctArgs: number
  readonly fingerprint: string
  readonly status: number
}

class QueryBuilder = {
  new (table: string, sql: SQLInstance): QueryBuilder
  _markUserWhereStart: () => void
  asc: (column?: string) => QueryBuilder
  avg: (column: string) => Promise<number>
  chunk: <T = Record<string, unknown>>(size: number, callback: (rows: T[], page: number) => unknown | Promise<unknown>) => Promise<void>
  chunkById: <T = Record<string, unknown>>(size: number, callback: (rows: T[]) => unknown | Promise<unknown>, column?: string) => Promise<void>
  clone: () => QueryBuilder
  count: () => Promise<number>
  crossJoin: (table: string) => QueryBuilder
  cursor: <T = Record<string, unknown>>(size?: number) => AsyncGenerator<T>
  cursorPaginate: <T = Record<string, unknown>>(options?: {    cursor?: number;    limit?: number;    column?: string;}) => Promise<CursorPaginateResult<T>>
  dd: () => QueryBuilder
  decrement: (column: string, amount?: number) => Promise<void>
  delete: () => Promise<void>
  desc: (column?: string) => QueryBuilder
  distinct: () => QueryBuilder
  doesntExist: () => Promise<boolean>
  dump: () => QueryBuilder
  each: <T = Record<string, unknown>>(callback: (row: T, index: number) => unknown | Promise<unknown>, size?: number) => Promise<void>
  exists: () => Promise<boolean>
  explain: <T = Record<string, unknown>>() => Promise<T[]>
  first: <T = Record<string, unknown>>() => Promise<T | null>
  from: (table: string) => QueryBuilder
  get: <T = Record<string, unknown>>() => Promise<T[]>
  groupBy: (...columns: string[]) => QueryBuilder
  having: (column: string, operatorOrValue: unknown, value?: unknown) => QueryBuilder
  inRandomOrder: () => QueryBuilder
  increment: (column: string, amount?: number) => Promise<void>
  insert: (data: Record<string, unknown>) => Promise<void>
  join: (table: string, first: string, operator: string, second: string) => QueryBuilder
  joinSub: (sub: QueryBuilder | ((q: QueryBuilder) => void), alias: string, first: string, operator: string, second: string, type?: JoinType) => QueryBuilder
  keysetPaginate: <T = Record<string, unknown>>(options?: KeysetOptions) => Promise<KeysetPaginateResult<T>>
  latest: (column?: string) => QueryBuilder
  lazy: <T = Record<string, unknown>>(size?: number) => AsyncGenerator<T>
  lazyById: <T = Record<string, unknown>>(size?: number, column?: string) => AsyncGenerator<T>
  leftJoin: (table: string, first: string, operator: string, second: string) => QueryBuilder
  limit: (n: number) => QueryBuilder
  lockForUpdate: () => QueryBuilder
  max: (column: string) => Promise<number>
  min: (column: string) => Promise<number>
  offset: (n: number) => QueryBuilder
  oldest: (column?: string) => QueryBuilder
  orWhere: {    (column: string, value: unknown): QueryBuilder;    (column: string, operator: WhereOperator, value: unknown): QueryBuilder;    (group: (query: QueryBuilder) => void): QueryBuilder;}
  orWhereBetween: (column: string, range: [unknown, unknown]) => QueryBuilder
  orWhereColumn: (first: string, operatorOrSecond: string, second?: string) => QueryBuilder
  orWhereExists: (callback: (q: QueryBuilder) => void) => QueryBuilder
  orWhereIn: (column: string, values: unknown[]) => QueryBuilder
  orWhereLike: (column: string, value: string) => QueryBuilder
  orWhereNotBetween: (column: string, range: [unknown, unknown]) => QueryBuilder
  orWhereNotExists: (callback: (q: QueryBuilder) => void) => QueryBuilder
  orWhereNotIn: (column: string, values: unknown[]) => QueryBuilder
  orWhereNotLike: (column: string, value: string) => QueryBuilder
  orWhereNotNull: (column: string) => QueryBuilder
  orWhereNull: (column: string) => QueryBuilder
  orWhereRaw: (sql: string, bindings?: unknown[]) => QueryBuilder
  orderBy: (column: string, direction?: OrderDirection) => QueryBuilder
  orderByDesc: (column: string) => QueryBuilder
  orderByRaw: (expression: string) => QueryBuilder
  paginate: <T = Record<string, unknown>>(perPage?: number, page?: number, pageName?: string) => Promise<PaginateResult<T>>
  pluck: <V = unknown>(column: string, key?: string) => Promise<V[] | Record<string, V>>
  reorder: (column?: string, direction?: OrderDirection) => QueryBuilder
  rightJoin: (table: string, first: string, operator: string, second: string) => QueryBuilder
  select: (...columns: string[]) => QueryBuilder
  selectRaw: (expression: string) => QueryBuilder
  sharedLock: () => QueryBuilder
  simplePaginate: <T = Record<string, unknown>>(perPage?: number, page?: number, pageName?: string) => Promise<SimplePaginateResult<T>>
  sole: <T = Record<string, unknown>>() => Promise<T>
  sum: (column: string) => Promise<number>
  toRawSql: () => string
  toSql: () => string
  toSqlWithBindings: () => {    sql: string;    bindings: unknown[];}
  union: (other: QueryBuilder, all?: boolean) => QueryBuilder
  unionAll: (other: QueryBuilder) => QueryBuilder
  update: (data: Record<string, unknown>) => Promise<void>
  updateOrInsert: (attributes: Record<string, unknown>, values?: Record<string, unknown>) => Promise<boolean>
  value: <V = unknown>(column: string) => Promise<V | null>
  when: (condition: unknown, callback: (q: QueryBuilder, value: unknown) => void) => QueryBuilder
  where: {    (column: string, value: unknown): QueryBuilder;    (column: string, operator: WhereOperator, value: unknown): QueryBuilder;    (group: (query: QueryBuilder) => void): QueryBuilder;}
  whereAll: (columns: string[], operator: string, value: unknown) => QueryBuilder
  whereAny: (columns: string[], operator: string, value: unknown) => QueryBuilder
  whereBetween: (column: string, range: [unknown, unknown]) => QueryBuilder
  whereColumn: (first: string, operatorOrSecond: string, second?: string) => QueryBuilder
  whereDate: (column: string, operatorOrValue: unknown, value?: unknown) => QueryBuilder
  whereDay: (column: string, operatorOrValue: unknown, value?: unknown) => QueryBuilder
  whereExists: (callback: (q: QueryBuilder) => void) => QueryBuilder
  whereIn: (column: string, values: unknown[]) => QueryBuilder
  whereJson: (column: string, value: unknown) => QueryBuilder
  whereLike: (column: string, value: string) => QueryBuilder
  whereMonth: (column: string, operatorOrValue: unknown, value?: unknown) => QueryBuilder
  whereNotBetween: (column: string, range: [unknown, unknown]) => QueryBuilder
  whereNotExists: (callback: (q: QueryBuilder) => void) => QueryBuilder
  whereNotIn: (column: string, values: unknown[]) => QueryBuilder
  whereNotLike: (column: string, value: string) => QueryBuilder
  whereNotNull: (column: string) => QueryBuilder
  whereNull: (column: string) => QueryBuilder
  whereRaw: (sql: string, bindings?: unknown[]) => QueryBuilder
  whereTime: (column: string, operatorOrValue: unknown, value?: unknown) => QueryBuilder
  whereYear: (column: string, operatorOrValue: unknown, value?: unknown) => QueryBuilder
}

class QueryExecuted = {
  new (sql: string, bindings: unknown[], startMs: number, durationMs: number, rowCount: number, ctx: object | undefined): QueryExecuted
  readonly bindings: unknown[]
  readonly ctx: object | undefined
  readonly durationMs: number
  readonly rowCount: number
  readonly sql: string
  readonly startMs: number
}

class RelationNotLoadedError = {
  new (relation: string, model: string): RelationNotLoadedError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class Seeder = {
  new (): Seeder
  call: (seeders: (new () => Seeder)[]) => Promise<void>
  run: () => Promise<void>
}

class StateError = {
  new (model: string, from: string, to: string, detail?: string): StateError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class TransactionCommitted = {
  new (txId: string, durationMs: number, ctx: object | undefined): TransactionCommitted
  readonly ctx: object | undefined
  readonly durationMs: number
  readonly txId: string
}

class TransactionError = {
  new (message: string): TransactionError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

class TransactionRolledBack = {
  new (txId: string, durationMs: number, reason: string | undefined, ctx: object | undefined): TransactionRolledBack
  readonly ctx: object | undefined
  readonly durationMs: number
  readonly reason: string | undefined
  readonly txId: string
}

class TransactionStarted = {
  new (txId: string, ctx: object | undefined): TransactionStarted
  readonly ctx: object | undefined
  readonly txId: string
}

class UnsupportedDialectError = {
  new (feature: string, dialect: string): UnsupportedDialectError
  readonly code: string
  readonly context?: Record<string, unknown> | undefined
  readonly status: number
}

const DB = {    table(tableName: string): QueryBuilder;    raw<T = Record<string, unknown>>(sql: TemplateStringsArray | string, ...rest: unknown[]): Promise<T[]>;    transaction<T>(callback: (tx?: SQLInstance) => Promise<T>, attempts?: number): Promise<T>;    beginTransaction(): Promise<ManualTransaction>;    onPrimary(): {        table(name: string): QueryBuilder;    };    currentTx(): unknown | undefined;    advisoryLock<T>(key: number, callback: () => Promise<T>): Promise<T>;    preventNPlusOne(options?: NPlusOneOptions): void;    allowNPlusOne(pattern: string, options?: {        once?: boolean;    }): void;}

const relationRegistry = Map<ClassRef, Map<string, RelationMetadata>>

const Schema = {    create(table: string, callback: (bp: Blueprint) => void): Promise<void>;    createIfNotExists(table: string, callback: (bp: Blueprint) => void): Promise<void>;    table(name: string, callback: (bp: Blueprint) => void): Promise<void>;    alter(name: string, callback: (bp: Blueprint) => void): Promise<void>;    drop(table: string): Promise<void>;    dropIfExists(table: string): Promise<void>;    rename(from: string, to: string): Promise<void>;    hasTable(table: string): Promise<boolean>;    hasColumn(table: string, column: string): Promise<boolean>;}

const TransactionContext = AsyncLocalStorage<SQLInstance>

function allowNPlusOne = (pattern: string, options?: {    once?: boolean;}, ctx?: object | null) => void

function arrayOf = <T = unknown>(mapper?: CastMapper<T>) => ArrayCast<T>

function belongsTo = (related: () => unknown, options: BelongsToOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function column = {    (): ColumnDecorator;    (type: ColumnShorthand): ColumnDecorator;    (options: ColumnOptions): ColumnDecorator;    (type: ColumnShorthand, options: Omit<ColumnOptions, 'type'>): ColumnDecorator;}

function DatabaseConfig = (options?: Partial<DatabaseConfigShape>) => DatabaseConfigShape

function hasMany = (related: () => unknown, options: HasManyOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function hasManyThrough = (related: () => unknown, through: () => unknown, options: HasManyThroughOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function hasOne = (related: () => unknown, options: HasOneOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function hasOneThrough = (related: () => unknown, through: () => unknown, options: HasManyThroughOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function isEncryptedCast = (cast: unknown) => cast is EncryptedCastName

function json = <T = unknown>(mapper?: CastMapper<T>) => JsonCast<T>

function manyToMany = (related: () => unknown, options: ManyToManyOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function morphedByMany = (related: () => unknown, options: MorphedByManyOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function morphMany = (related: () => unknown, options: MorphManyOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function morphOne = (related: () => unknown, options: MorphOneOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function morphTo = (options: MorphToOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function morphToMany = (related: () => unknown, options: MorphToManyOptions) => (_value: unknown, context: ClassFieldDecoratorContext) => void

function objectOf = <T = unknown>(mapper?: CastMapper<T>) => JsonCast<T>

function preventNPlusOne = (options?: NPlusOneOptions) => void

function SoftDeletes = <TBase extends Constructor>(Base: TBase) => {    new (...args: any[]): SoftDeletes;    prototype: SoftDeletes<any>.SoftDeletes;    softDeletes: boolean;    withTrashed<T extends BaseModel>(this: SoftDeleteModelClass<T>): ModelQueryBuilder<T>;    onlyTrashed<T extends BaseModel>(this: SoftDeleteModelClass<T>): ModelQueryBuilder<T>;} & TBase

function State = <TBase extends Constructor>(Base: TBase) => {    new (...args: any[]): State;    prototype: State<any>.State;    stateField: string;    states?: Record<string, StateDefinition<string, any>>;    onTransition<T>(this: {        new (...args: any[]): T;    }, toState: string, callback: TransitionCallback<T>): void;} & TBase

function table = (tableName: string, options?: TableOptions) => TableDecoratorBuilder

interface BelongsTo = {
  __@___relation__: 'belongsTo'
  __type__: T
}

interface CastContract = {
  get: (dbValue: unknown) => T
  set: (value: T) => unknown
}

interface CastField = {
  label: string
  name: string
  type: string
}

interface ColumnOptions = {
  cast?: 'boolean' | 'date' | 'datetime' | 'array' | 'integer' | 'json' | 'float' | 'enum' | 'immutable_datetime' | 'encrypted' | 'encrypted:json' | `decimal:${number}` | {    get?: (dbValue: unknown) => unknown;    set?: (jsValue: unknown) => unknown;} | CastContract<unknown> | undefined
  default?: unknown
  enumValues?: Record<string, string | number> | undefined
  index?: boolean | undefined
  nullable?: boolean | undefined
  primary?: boolean | undefined
  type?: 'string' | 'number' | 'boolean' | 'text' | 'datetime' | 'json' | undefined
  unique?: boolean | undefined
}

interface Compose = {
  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor, D extends Constructor, E extends Constructor, F extends Constructor, G extends Constructor, H extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B, c: (base: B) => C, d: (base: C) => D, e: (base: D) => E, f: (base: E) => F, g: (base: F) => G, h: (base: G) => H): H
  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor, D extends Constructor, E extends Constructor, F extends Constructor, G extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B, c: (base: B) => C, d: (base: C) => D, e: (base: D) => E, f: (base: E) => F, g: (base: F) => G): G
  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor, D extends Constructor, E extends Constructor, F extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B, c: (base: B) => C, d: (base: C) => D, e: (base: D) => E, f: (base: E) => F): F
  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor, D extends Constructor, E extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B, c: (base: B) => C, d: (base: C) => D, e: (base: D) => E): E
  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor, D extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B, c: (base: B) => C, d: (base: C) => D): D
  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B, c: (base: B) => C): C
  <TBase extends Constructor, A extends Constructor, B extends Constructor>(this: TBase, a: (base: TBase) => A, b: (base: A) => B): B
  <TBase extends Constructor, A extends Constructor>(this: TBase, a: (base: TBase) => A): A
}

interface CursorPaginateResult = {
  data: T[]
  hasMore: boolean
  nextCursor: number | null
  prevCursor: number | null
}

interface DatabaseConfigShape = {
  driver: 'sqlite' | 'postgres' | 'mysql'
  pool?: {    max?: number;    idleTimeout?: number;} | undefined
  replicas?: string[] | undefined
  sqlite: {    path: string;    foreignKeys?: boolean | undefined;}
  synchronize?: boolean | {    enabled: boolean;    disruptive?: boolean;} | undefined
  url: string
}

interface HasMany = {
  __@___relation__: 'hasMany'
  __type__: T
}

interface HasManyThroughOptions = {
  firstKey: string
  localKey?: string | undefined
  secondKey: string
  throughLocalKey?: string | undefined
}

interface HasOne = {
  __@___relation__: 'hasOne'
  __type__: T
}

interface KeysetOptions = {
  column?: string | undefined
  cursor?: string | null | undefined
  direction?: 'asc' | 'desc' | undefined
  limit?: number | undefined
}

interface KeysetPaginateResult = {
  data: T[]
  nextCursor: string | null
}

interface ManualTransaction = {
  commit: () => Promise<void>
  readonly sql: SQLInstance
  rollback: () => Promise<void>
  table: (name: string) => QueryBuilder
}

interface ManyToMany = {
  [index: number]: T
  attach: (id: number | number[], pivotData?: Record<string, unknown>) => Promise<void>
  detach: (id?: number | number[]) => Promise<void>
  sync: (ids: number[]) => Promise<void>
  syncWithoutDetaching: (ids: number[]) => Promise<void>
  toggle: (id: number | number[]) => Promise<void>
  updateExistingPivot: (id: number, pivotData: Record<string, unknown>) => Promise<void>
}

interface ManyToManyOptions = {
  localKey?: string | undefined
  pivotForeignKey: string
  pivotRelatedKey: string
  pivotTable: string
  relatedKey?: string | undefined
  withPivot?: string[] | undefined
  withTimestamps?: boolean | undefined
}

interface MigrationEntry = {
  migration: Migration
  name: string
}

interface MigrationRecord = {
  instance: Migration
  name: string
}

interface MigrationStatus = {
  batch?: number
  name: string
  ran: boolean
  ranAt?: Date
}

interface ModelObserver = {
  created?: (model: T) => Promise<void> | void
  creating?: (model: T) => Promise<void> | void
  deleted?: (model: T) => Promise<void> | void
  deleting?: (model: T) => Promise<void> | void
  retrieved?: (model: T) => Promise<void> | void
  saved?: (model: T) => Promise<void> | void
  saving?: (model: T) => Promise<void> | void
  updated?: (model: T) => Promise<void> | void
  updating?: (model: T) => Promise<void> | void
}

interface MorphedByManyOptions = {
  morphName: string
  parentPivotKey: string
  pivotTable?: string | undefined
  withPivot?: string[] | undefined
  withTimestamps?: boolean | undefined
}

interface MorphMany = {
  __@___relation__: 'morphMany'
  __type__: T
}

interface MorphManyOptions = {
  localKey?: string | undefined
  morphName: string
}

interface MorphOne = {
  __@___relation__: 'morphOne'
  __type__: T
}

interface MorphOneOptions = {
  localKey?: string | undefined
  morphName: string
}

interface MorphTo = {
  __@___relation__: 'morphTo'
  __type__: T
}

interface MorphToManyOptions = {
  morphName: string
  pivotTable?: string | undefined
  relatedPivotKey: string
  withPivot?: string[] | undefined
  withTimestamps?: boolean | undefined
}

interface MorphToOptions = {
  morphForeignKey?: string | undefined
  morphMap: Record<string, () => unknown>
  morphTypeColumn?: string | undefined
}

interface NPlusOneOptions = {
  mode?: 'warn' | 'throw' | undefined
  threshold?: number | undefined
}

interface PaginateMeta = {
  currentPage: number
  from: number | null
  lastPage: number
  path: string
  perPage: number
  to: number | null
  total: number
}

interface PaginateResult = {
  data: T[]
  elements: (each?: number) => (number | '...')[]
  from: number | null
  hasMorePages: boolean
  lastPage: number
  links: (baseUrl?: string, query?: Record<string, string>) => Array<{    page: number;    url: string;    active: boolean;}>
  meta: PaginateMeta
  nextPageUrl: (baseUrl?: string, query?: Record<string, string>) => string | null
  onFirstPage: boolean
  onLastPage: boolean
  page: number
  perPage: number
  previousPageUrl: (baseUrl?: string, query?: Record<string, string>) => string | null
  to: number | null
  total: number
  url: (page: number, baseUrl?: string, query?: Record<string, string>) => string
}

interface RelationMetadata = {
  firstKey?: string
  foreignKey: string
  localKey: string
  morphMap?: Record<string, () => unknown>
  morphTypeColumn?: string
  pivotColumns?: string[]
  pivotForeignKey?: string
  pivotMorphType?: string
  pivotMorphValue?: string
  pivotRelatedKey?: string
  pivotTable?: string
  pivotTimestamps?: boolean
  pivotWheres?: [string, unknown][]
  related: () => unknown
  secondKey?: string
  through?: () => unknown
  throughLocalKey?: string
  type: RelationType
  withDefault?: boolean | Record<string, unknown> | ((model: unknown) => void)
}

interface ScopeApplicator = {
  apply: (query: QueryBuilder) => void
}

interface SimplePaginateResult = {
  data: T[]
  from: number | null
  hasMorePages: boolean
  nextPageUrl: (baseUrl?: string, query?: Record<string, string>) => string | null
  onFirstPage: boolean
  page: number
  perPage: number
  previousPageUrl: (baseUrl?: string, query?: Record<string, string>) => string | null
  to: number | null
  url: (page: number, baseUrl?: string, query?: Record<string, string>) => string
}

interface SQLInstance = {
  <T = Record<string, unknown>>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T[]>
  begin: <T>(fn: (tx: SQLInstance) => Promise<T>) => Promise<T>
  end: () => Promise<void>
}

interface StateDefinition = {
  canTransitionTo: readonly States[]
  guard?: StateGuard<T>
}

interface TableDecoratorBuilder = {
  (target: ClassRef, context?: unknown): void
  primaryKey: (key: string) => TableDecoratorBuilder
  withTimestamps: () => TableDecoratorBuilder
  withoutTimestamps: () => TableDecoratorBuilder
}

interface TableOptions = {
  primaryKey?: string | undefined
  timestamps?: boolean | undefined
}

interface TransitionContext = {
  current: string
  intended: string
  reject: RejectTransition
}

type CastMapper = ((raw: unknown) => T) | (new (...args: never[]) => T)

type Columns = { [K in keyof T & string]: K extends `_${string}` ? never : T[K] extends (...args: any[]) => any ? never : K; }[keyof T & string]

type ColumnShorthand = 'string' | 'text' | 'integer' | 'number' | 'float' | 'boolean' | 'datetime' | 'date' | 'json' | 'array' | 'encrypted' | 'encrypted:json'

type Constructor = new (...args: any[]) => T

type DatePart = 'date' | 'time' | 'day' | 'month' | 'year'

type EncryptedCastName = 'encrypted' | 'encrypted:json'

type FKAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION'

type GlobalScopeCallback = (qb: ModelQueryBuilder<BaseModel>) => void

type HookName = 'beforeCreate' | 'afterCreate' | 'beforeSave' | 'afterSave' | 'beforeUpdate' | 'afterUpdate' | 'beforeDelete' | 'afterDelete' | 'afterFind'

type InsertPayload = { [P in Exclude<ColumnKeys<T>, AutoManagedKeys>]: Pick<T, ColumnKeys<T>>[P]; }

type Mixin = (Base: TIn) => TOut

type OrderDirection = 'asc' | 'desc'

type RejectTransition = (reason: string) => never

type RelationConstraint = (query: ModelQueryBuilder<BaseModel>) => void

type RelationDefinition = RelationMetadata

type RelationType = 'hasMany' | 'belongsTo' | 'hasOne' | 'manyToMany' | 'morphTo' | 'morphMany' | 'morphOne' | 'hasManyThrough' | 'hasOneThrough' | 'morphToMany' | 'morphedByMany'

type StateGuard = (model: T, ctx: TransitionContext) => boolean | void | Promise<boolean | void>

type StateMachine = { [K in States]: StateDefinition<States, T>; }

type TransitionCallback = (model: T, meta: {    from: string;    to: string;}) => Promise<void> | void

type TransitionResult = [ok: true] | [ok: false, error: StateError]

type UpdatePayload = { [P in keyof InsertPayload<T>]?: InsertPayload<T>[P]; }

type WhereOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'like' | 'not like' | 'in' | 'not in'

type WithLoaded = Omit<M, R> & { [K in R]: M[K] extends ManyToMany<infer T> ? ManyToMany<T> : M[K] extends HasMany<infer T> ? T[] : M[K] extends BelongsTo<infer T> ? T | null : M[K] extends HasOne<infer T> ? T | null : M[K] extends MorphTo<infer T> ? T | null : M[K] extends MorphMany<infer T> ? T[] : M[K] extends MorphOne<infer T> ? T | null : M[K]; }

## ./commands  `(./src/commands/index.ts)`

class DbSeedCommand = {
  new (): DbSeedCommand
  static args: ArgDef[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MakeFactoryCommand = {
  new (): MakeFactoryCommand
  static args: {    name: string;    required: boolean;    description: string;}[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MakeMigrationCommand = {
  new (): MakeMigrationCommand
  static args: {    name: string;    required: boolean;    description: string;}[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MakeModelCommand = {
  new (): MakeModelCommand
  static args: {    name: string;    required: boolean;    description: string;}[]
  static commandName: string
  static description: string
  static flags: {    name: string;    short: string;    type: 'boolean';    description: string;    default: boolean;}[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MakeSeederCommand = {
  new (): MakeSeederCommand
  static args: {    name: string;    required: boolean;    description: string;}[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MigrateCommand = {
  new (): MigrateCommand
  static aliases: string[]
  static args: ArgDef[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MigrateFreshCommand = {
  new (): MigrateFreshCommand
  static args: ArgDef[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MigrateGenerateCommand = {
  new (): MigrateGenerateCommand
  static args: {    name: string;    required: boolean;    description: string;}[]
  static commandName: string
  static description: string
  static flags: {    name: string;    type: 'string';    description: string;    default: string;}[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MigrateRefreshCommand = {
  new (): MigrateRefreshCommand
  static args: ArgDef[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MigrateRollbackCommand = {
  new (): MigrateRollbackCommand
  static args: ArgDef[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}

class MigrateStatusCommand = {
  new (): MigrateStatusCommand
  static args: ArgDef[]
  static commandName: string
  static description: string
  static flags: FlagDef[]
  static needsApp: boolean
  _readLine: () => Promise<string>
  _writer: OutputWriter
  app: unknown
  args: Record<string, string>
  ask: (question: string, defaultValue?: string) => Promise<string>
  choice: (question: string, options: string[]) => Promise<string>
  confirm: (question: string, defaultValue?: boolean) => Promise<boolean>
  dim: (msg: string) => void
  error: (msg: string) => void
  flags: Record<string, string | number | boolean>
  info: (msg: string) => void
  line: (msg: string) => void
  newLine: () => void
  run: () => Promise<void>
  secret: (question: string) => Promise<string>
  section: (title: string) => void
  table: (rows: [string, string][], indent?: number) => void
  warn: (msg: string) => void
  write: (msg: string) => void
}