@rvoh/dream 0.29.1

package/dist/types/src/Dream.d.ts

@@ -0,0 +1,2211 @@
+import { CompiledQuery, DeleteQueryBuilder, InsertQueryBuilder, SelectQueryBuilder, Updateable, UpdateQueryBuilder } from 'kysely';
+import { AssociationTableNames } from './db/reflections.js';
+import { DbConnectionType } from './db/types.js';
+import { AssociationStatementsMap, PassthroughOnClause, WhereStatement } from './decorators/associations/shared.js';
+import { HookStatement, HookStatementMap } from './decorators/hooks/shared.js';
+import { ScopeStatement } from './decorators/Scope.js';
+import { SortableFieldConfig } from './decorators/sortable/Sortable.js';
+import ValidationStatement, { ValidationType } from './decorators/validations/shared.js';
+import { VirtualAttributeStatement } from './decorators/Virtual.js';
+import DreamClassTransactionBuilder from './dream/DreamClassTransactionBuilder.js';
+import DreamInstanceTransactionBuilder from './dream/DreamInstanceTransactionBuilder.js';
+import DreamTransaction from './dream/DreamTransaction.js';
+import { DestroyOptions } from './dream/internal/destroyOptions.js';
+import LeftJoinLoadBuilder from './dream/LeftJoinLoadBuilder.js';
+import LoadBuilder from './dream/LoadBuilder.js';
+import Query, { BaseModelColumnTypes, DefaultQueryTypeOptions, FindEachOpts, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from './dream/Query.js';
+import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamSerializeOptions, IdType, JoinedAssociation, JoinedAssociationsTypeFromAssociations, JoinOnStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RequiredOnClauseKeys, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from './dream/types.js';
+export default class Dream {
+    DB: any;
+    /**
+     * @internal
+     *
+     * This getter will throw an error when developers use .toEqual instead of
+     * useToMatchDreamModels or useToMatchDreamModel in a jest spec. This
+     * must be the first getter in the class in order for this to work, so don't move it.
+     *
+     */
+    private get _useToMatchDreamModels();
+    /**
+     * @internal
+     *
+     * Modern Javascript sets all properties that do not have an explicit
+     * assignment within the constructor to undefined in an implicit constructor.
+     * Since the Dream constructor sets the value of properties of instances of
+     * classes that extend Dream (e.g. when passing attributes to #new or #create
+     * or when loading a model via one of the #find methods or #all), we need to
+     * prevent those properties from being set back to undefined. Since all
+     * properties corresponding to a database column get a setter, we achieve this
+     * protection by including a guard in the setters that returns if this
+     * property is set.
+     *
+     */
+    protected columnSetterGuardActivated: boolean;
+    /**
+     * @internal
+     *
+     * Certain features (e.g. passing a Dream instance to `create` so that it automatically destructures polymorphic type and primary key)
+     * need static access to things set up by decorators (e.g. associations). Stage 3 Decorators change the context that is available
+     * at decoration time such that the class of a property being decorated is only avilable during instance instantiation. In order
+     * to only apply static values once, on boot, `globallyInitializingDecorators` is set to true on Dream, and all Dream models are instantiated.
+     *
+     */
+    private static globallyInitializingDecorators;
+    get schema(): any;
+    get globalSchema(): any;
+    /**
+     * Shadows #primaryKey, a getter which can be overwritten to customize the id field
+     * for a given model.
+     *
+     * @returns string
+     */
+    static get primaryKey(): "id";
+    /**
+     * Shadows #table, a getter which can be overwritten to customize the table field
+     * for a given model.
+     *
+     * @returns string
+     */
+    static get table(): string;
+    /**
+     * A getter which can be overwritten to customize the automatic createdAt timestamp field
+     * for a given model.
+     *
+     * ```ts
+     *  class User extends ApplicationModel {
+     *    public get createdAtField() {
+     *       return 'createdAtTimestamp' as const
+     *    }
+     *  }
+     *
+     * const user = await User.first()
+     * user.createdAtTimestamp // returns the DateTime that this user was created
+     *
+     * @returns string
+     */
+    get createdAtField(): Readonly<string>;
+    /**
+     * A getter which can be overwritten to customize the automatic updatedAt timestamp field
+     * for a given model.
+     *
+     * ```ts
+     *  class User extends ApplicationModel {
+     *    public get updatedAtField() {
+     *       return 'updatedAtTimestamp' as const
+     *    }
+     *  }
+     *
+     * const user = await User.first()
+     * user.updatedAtTimestamp // returns the DateTime that this user was updated
+     * ```
+     *
+     * @returns string
+     */
+    get updatedAtField(): Readonly<string>;
+    get deletedAtField(): Readonly<string>;
+    /**
+     * @internal
+     *
+     * Model storage for association metadata, set when using the association decorators like:
+     *   @Deco.HasOne
+     *   @Deco.HasMany
+     *   @Deco.BelongsTo
+     */
+    protected static associationMetadataByType: AssociationStatementsMap;
+    /**
+     * @internal
+     *
+     * Model storage for scope metadata, set when using the Scope decorator
+     * (this default assignment simply ensures that it is
+     * always an array rather than undefined,
+     * freezing ensures that we never modify the static array on the inherited Dream class)
+     */
+    protected static scopes: {
+        default: readonly ScopeStatement[] | ScopeStatement[];
+        named: readonly ScopeStatement[] | ScopeStatement[];
+    };
+    /**
+     * @internal
+     *
+     * Model storage for virtual attribute metadata, set on the inheriting class when
+     * using the Virtual decorator (this default assignment simply ensures that it is
+     * always an array rather than undefined,
+     * freezing ensures that we never modify the static array on the inherited Dream class)
+     */
+    protected static virtualAttributes: readonly VirtualAttributeStatement[] | VirtualAttributeStatement[];
+    /**
+     * @internal
+     *
+     * Model storage for additional columns that may not be set via the new/create/update
+     * methods. Set on the inheriting class when using the Virtual decorator (this default
+     * assignment simply ensures that it is always an array rather than undefined)
+     */
+    protected static explicitUnsafeParamColumns: readonly string[] | string[];
+    /**
+     * @internal
+     *
+     * Model storage for sortable metadata, set when using the Sortable decorator
+     *  (this default assignment simply ensures that it is always an array rather than undefined,
+     * freezing ensures that we never modify the static array on the inherited Dream class)
+     *
+     */
+    protected static sortableFields: readonly SortableFieldConfig[] | SortableFieldConfig[];
+    /**
+     * @internal
+     *
+     * Model storage for STI metadata, set when using the STI decorator
+     */
+    protected static extendedBy: (typeof Dream)[] | null;
+    /**
+     * @internal
+     *
+     * Model storage for STI metadata, set when using the STI decorator
+     *  (this default assignment simply ensures that it is always a valid object rather than undefined,
+     * freezing ensures that we never modify the static array on the inherited Dream class)
+     */
+    protected static sti: {
+        active: boolean;
+        baseClass: typeof Dream | null;
+        value: string | null;
+    };
+    /**
+     * @internal
+     *
+     * Model storage for model hook metadata, set when using the following decorators:
+     *   BeforeCreate
+     *   BeforeUpdate
+     *   BeforeSave
+     *   BeforeDestroy
+     *   AfterCreate
+     *   AfterCreateCommit
+     *   AfterUpdate
+     *   AfterUpdateCommit
+     *   AfterSave
+     *   AfterSaveCommit
+     *   AfterDestroy
+     *   AfterDestroyCommit
+     */
+    protected static hooks: Readonly<HookStatementMap>;
+    /**
+     * @internal
+     *
+     * Model storage for validation metadata, set when using the Validates decorator
+     * (this default assignment simply ensures that it is always an array rather than undefined,
+     * freezing ensures that we never modify the static array on the inherited Dream class)
+     */
+    protected static validations: readonly ValidationStatement[] | ValidationStatement[];
+    /**
+     * @internal
+     *
+     * Model storage for custom validation metadata, set when using the Validate decorator
+     * (this default assignment simply ensures that it is always an array rather than undefined,
+     * freezing ensures that we never modify the static array on the inherited Dream class)
+     *
+     */
+    protected static customValidations: readonly string[] | string[];
+    /**
+     * @internal
+     *
+     * Model storage for replica-safe metadata, set when using the ReplicaSafe decorator
+     */
+    protected static replicaSafe: boolean;
+    /**
+     * @internal
+     *
+     * Model storage for soft-delete metadata, set when using the SoftDelete decorator
+     */
+    protected static softDelete: boolean;
+    /**
+     * @internal
+     *
+     * Provided to distinguish between Dream and other classes
+     *
+     * @returns true
+     */
+    static get isDream(): boolean;
+    /**
+     * @internal
+     *
+     * Returns true if this model class is the base class of other STI models
+     *
+     * @returns boolean
+     */
+    protected static get isSTIBase(): boolean;
+    /**
+     * @internal
+     *
+     * Returns true if this model class a child class of a base STI model
+     *
+     * @returns boolean
+     */
+    protected static get isSTIChild(): boolean;
+    /**
+     * @internal
+     *
+     * Returns either the base STI class, or else this class
+     *
+     * @returns A dream class
+     */
+    protected static get stiBaseClassOrOwnClass(): typeof Dream;
+    /**
+     * @internal
+     *
+     * Shadows .stiBaseClassOrOwnClass. Returns either the base STI class, or else this class
+     *
+     * @returns A dream class
+     */
+    protected get stiBaseClassOrOwnClass(): typeof Dream;
+    /**
+     * @internal
+     *
+     * Used by model hook decorators to apply a hook to a specific model.
+     *
+     * @param hookType - the type of hook you want to attach the provided statement to
+     * @param statement - the statement to couple to the provided hookType
+     * @returns void
+     */
+    protected static addHook(hookType: keyof typeof this.hooks, statement: HookStatement): void;
+    /**
+     * @internal
+     *
+     * Returns a unique global name for the given model.
+     *
+     * @returns A string representing a unique key for this model
+     */
+    static get globalName(): string;
+    private static _globalName;
+    /**
+     * @internal
+     *
+     * Used by DreamApplication during the load process
+     * for models, services, and controllers to assign
+     * unique global names to each model based on the file
+     * name of that model.
+     */
+    private static setGlobalName;
+    /**
+     * Returns the column names for the given model
+     *
+     * @returns The column names for the given model
+     */
+    static columns<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], TableName extends keyof DB = InstanceType<T>['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName], RetType = Set<keyof Table & string>>(this: T): RetType;
+    private static _columns;
+    /**
+     * Returns the list of column names that are safe for
+     * casting automatically using `.paramsFor` within a
+     * psychic controller. It will return a subset of the
+     * `.columns` getter, but which filters out the following:
+     *   * createdAt
+     *   * updatedAt
+     *   * deletedAt
+     *   * type fields for STI models
+     *   * foreign key fields for belongs to associations (these should usually be verified before being set)
+     *   * type fields corresponding to polymorphic associations
+     *
+     * @returns A subset of columns for the given dream class
+     */
+    static paramSafeColumnsOrFallback<T extends typeof Dream, I extends InstanceType<T>, ParamSafeColumnsOverride extends InstanceType<T>['paramSafeColumns' & keyof InstanceType<T>] extends never ? undefined : InstanceType<T>['paramSafeColumns' & keyof InstanceType<T>] & string[], ReturnVal extends ParamSafeColumnsOverride extends string[] ? Extract<DreamParamSafeColumnNames<I>, ParamSafeColumnsOverride[number] & DreamParamSafeColumnNames<I>>[] : DreamParamSafeColumnNames<I>[]>(this: T): ReturnVal;
+    protected static defaultParamSafeColumns<T extends typeof Dream, I extends InstanceType<T>>(this: T): DreamParamSafeColumnNames<I>[];
+    /**
+     * @internal
+     *
+     * Returns true if the column is virtual (set using the Virtual decorator)
+     *
+     * @param columnName - the name of the property you are checking for
+     * @returns boolean
+     */
+    static isVirtualColumn<T extends typeof Dream>(this: T, columnName: string): boolean;
+    /**
+     * @internal
+     *
+     * Locates an association's metadata by key
+     *
+     * ```ts
+     * Post.getAssociationMetadata('user')
+     * // {
+     * //    modelCB: [Function (anonymous)],
+     * //    type: 'BelongsTo',
+     * //    as: 'user',
+     * //    optional: false,
+     * //    polymorphic: false,
+     * //    primaryKeyOverride: null,
+     * //    primaryKey: [Function: primaryKey],
+     * //    primaryKeyValue: [Function: primaryKeyValue],
+     * //    foreignKey: [Function: foreignKey],
+     * //    foreignKeyTypeField: [Function: foreignKeyTypeField]
+     * //  }
+     * ```
+     *
+     * @param associationName - the name of the association you wish to retrieve metadata for
+     * @returns Association metadata for the requested association
+     */
+    private static getAssociationMetadata;
+    /**
+     * @internal
+     *
+     * Returns an array containing all of the associations for this dream class
+     *
+     * @returns An array containing all of the associations for this dream class
+     */
+    private static associationMetadataMap;
+    /**
+     * @internal
+     *
+     * Returns all of the association names for this dream class
+     *
+     * @returns All of the association names for this dream class
+     */
+    static get associationNames(): string[];
+    /**
+     * Returns a query for this model which disregards default scopes
+     *
+     * @returns A query for this model which disregards default scopes
+     */
+    static removeAllDefaultScopes<T extends typeof Dream>(this: T): Query<InstanceType<T>>;
+    /**
+     * Prevents a specific default scope from applying when
+     * the Query is executed
+     *
+     * @returns A new Query which will prevent a specific default scope from applying
+     */
+    static removeDefaultScope<T extends typeof Dream>(this: T, scopeName: AllDefaultScopeNames<InstanceType<T>>): Query<InstanceType<T>>;
+    /**
+     * Retrieves an array containing all records corresponding to
+     * this model. Be careful using this, since it will attempt to
+     * pull every record into memory at once. For a large number
+     * of records, consider using `.findEach`, which will pull
+     * the records in batches.
+     *
+     * ```ts
+     * await User.all()
+     * ```
+     *
+     * @returns an array of dreams
+     */
+    static all<T extends typeof Dream>(this: T, options?: {
+        columns?: DreamColumnNames<InstanceType<T>>[];
+    }): Promise<InstanceType<T>[]>;
+    /**
+     * Forces use of a database connection (e.g. 'primary') during the query.
+     *
+     * NOTE: all queries within a transaction always use the 'primary' replica, so
+     * explicitly setting connection within a transaction has no effect.
+     *
+     * @param connection - The connection you wish to access ('primary' or 'replica')
+     * @returns A Query with the requested connection
+     */
+    static connection<T extends typeof Dream>(this: T, connection: DbConnectionType): Query<InstanceType<T>>;
+    /**
+     * Retrieves the number of records corresponding
+     * to this model.
+     *
+     * @returns The number of records corresponding to this model
+     */
+    static count<T extends typeof Dream>(this: T): Promise<number>;
+    /**
+     * Retrieves the max value of the specified column
+     * for this model's records.
+     *
+     * ```ts
+     * await User.max('id')
+     * // 99
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the max value of the specified column for this model's records
+     */
+    static max<T extends typeof Dream, ColumnName extends DreamColumnNames<InstanceType<T>>>(this: T, columnName: ColumnName): Promise<InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]["coercedType" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]]>;
+    /**
+     * Retrieves the min value of the specified column
+     * for this model's records.
+     *
+     *
+     * ```ts
+     * await User.min('id')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the min value of the specified column for this model's records
+     */
+    static min<T extends typeof Dream, ColumnName extends DreamColumnNames<InstanceType<T>>>(this: T, columnName: ColumnName): Promise<InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]["coercedType" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]][ColumnName & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]["columns" & keyof InstanceType<T>["schema"][InstanceType<T>["table"] & keyof InstanceType<T>["schema"]]]]]>;
+    /**
+     * Persists a new record, setting the provided attributes
+     *
+     * ```ts
+     * const user = await User.create({ email: 'how@yadoin' })
+     * await Post.create({ body: 'howdy', user })
+     * ```
+     *
+     * @param attributes - attributes or belongs to associations you wish to set on this model before persisting
+     * @returns A newly persisted dream instance
+     */
+    static create<T extends typeof Dream>(this: T, attributes?: UpdateablePropertiesForClass<T>): Promise<InstanceType<T>>;
+    /**
+     * Attempt to create the model. If creation fails
+     * due to uniqueness constraint, then find the existing
+     * model.
+     *
+     * This is useful in situations where we want to avoid
+     * a race condition creating duplicate records.
+     *
+     * IMPORTANT: A unique index/uniqueness constraint must exist on
+     * at least one of the provided attributes
+     *
+     * ```ts
+     * const logEntry = await LogEntry.createOrFindBy({ externalId }, { createWith: params })
+     * ```
+     *
+     * @param attributes - The base attributes to persist, but also the attributes to use to find when create fails
+     * @param extraOpts.createWith - additional attributes to persist when creating, but not used for finding
+     * @returns A dream instance
+     */
+    static createOrFindBy<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, extraOpts?: CreateOrFindByExtraOps<T>): Promise<InstanceType<T>>;
+    /**
+     * Returns a new query instance with the distinct query applied.
+     * If no columnName is provided, then distinct will apply to the
+     * primary key by default.
+     *
+     * ```ts
+     * await User.distinct('name').pluck('name')
+     * ```
+     *
+     * @param columnName - The column name you wish to apply the distinct clause to
+     * @returns A Query scoped to this Dream model with the distinct clause applied
+     */
+    static distinct<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], TableName extends InstanceType<T>['table']>(this: T, columnName?: TableColumnNames<DB, TableName> | null | boolean): Query<InstanceType<T>, Readonly<{
+        joinedAssociations: Readonly<[]>;
+        rootTableName: InstanceType<T>["table"];
+        rootTableAlias: InstanceType<T> extends infer T_1 ? T_1 extends InstanceType<T> ? T_1 extends Dream ? T_1["table"] : T_1 : never : never;
+        allowPreload: true;
+        allowLeftJoinPreload: true;
+    }>>;
+    /**
+     * Finds a record for the corresponding model with the
+     * specified primary key. If not found, null
+     * is returned
+     *
+     * ```ts
+     * await User.query().find(123)
+     * // User{id: 123}
+     * ```
+     *
+     * @param primaryKey - The primaryKey of the record to look up
+     * @returns Either the found record, or else null
+     */
+    static find<T extends typeof Dream, I extends InstanceType<T>>(this: T, primaryKey: PrimaryKeyForFind<I>): Promise<InstanceType<T> | null>;
+    /**
+     * Finds a record for the corresponding model with the
+     * specified primary key. If not found, an exception is raised.
+     *
+     * ```ts
+     * await User.query().findOrFail(123)
+     * // User{id: 123}
+     * ```
+     *
+     * @param primaryKey - The primaryKey of the record to look up
+     * @returns Either the found record, or else null
+     */
+    static findOrFail<T extends typeof Dream, I extends InstanceType<T>>(this: T, primaryKey: PrimaryKeyForFind<I>): Promise<InstanceType<T>>;
+    /**
+     * Finds all records for the corresponding model in batches,
+     * and then calls the provided callback
+     * for each found record. Once all records
+     * have been passed for a given batch, the next set of
+     * records will be fetched and passed to your callback, until all
+     * records matching the corresponding model have been fetched.
+     *
+     * ```ts
+     * await User.findEach(user => {
+     *   console.log(user)
+     * })
+     * // User{email: 'hello@world'}
+     * // User{email: 'goodbye@world'}
+     * ```
+     *
+     * @param cb - The callback to call for each found record
+     * @param opts.batchSize - the batch size you wish to collect records in. If not provided, it will default to 1000
+     * @returns void
+     */
+    static findEach<T extends typeof Dream>(this: T, cb: (instance: InstanceType<T>) => void | Promise<void>, opts?: FindEachOpts): Promise<void>;
+    /**
+     * Returns a new instance of Query scoped to the given
+     * model class
+     *
+     * ```ts
+     * await User.query().all()
+     * // [User{id: 1}, User{id: 2}, ...]
+     * ```
+     *
+     * @returns A new Query instance scoped to this Dream class
+     *
+     */
+    static query<T extends typeof Dream, I extends InstanceType<T>>(this: T): Query<I>;
+    /**
+     * @internal
+     *
+     * Returns a new instance of Query scoped to the given
+     * Dream instance
+     *
+     * ```ts
+     * await user = User.first()
+     * await user.query()
+     * ```
+     *
+     * @returns A new Query instance scoped to this Dream instance
+     *
+     */
+    private query;
+    /**
+     * Finds the first record—ordered by primary key—matching
+     * the corresponding model and the specified where statement.
+     * If not found, null is returned.
+     *
+     * ```ts
+     * await User.findBy({ email: 'how@yadoin' })
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - The where statement used to locate the record
+     * @returns The first model found matching the whereStatement
+     */
+    static findBy<T extends typeof Dream, I extends InstanceType<T>>(this: T, whereStatement: WhereStatement<I['DB'], I['schema'], I['table']>): Promise<InstanceType<T> | null>;
+    /**
+     * Finds the first record—ordered by primary key—matching
+     * the corresponding model and the specified where statement.
+     * If not found, an exception is raised.
+     *
+     * ```ts
+     * await User.findOrFailBy({ email: 'how@yadoin' })
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - The where statement used to locate the record
+     * @returns The first model found matching the whereStatement
+     */
+    static findOrFailBy<T extends typeof Dream, I extends InstanceType<T>>(this: T, whereStatement: WhereStatement<I['DB'], I['schema'], I['table']>): Promise<InstanceType<T>>;
+    /**
+     * Attempt to find the model with the given attributes.
+     * If no record is found, then a new record is created.
+     *
+     * ```ts
+     * const user = await User.findOrCreateBy({ email }, { createWith: params })
+     * ```
+     *
+     * @param attributes - The base attributes for finding, but also the attributes to use when creating
+     * @param extraOpts.createWith - additional attributes to persist when creating, but not used for finding
+     * @returns A dream instance
+     */
+    static findOrCreateBy<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, extraOpts?: CreateOrFindByExtraOps<T>): Promise<InstanceType<T>>;
+    /**
+     * Returns true if a record exists for the given
+     * model class
+     *
+     * ```ts
+     * await User.exists()
+     * // false
+     *
+     * await User.create({ email: 'how@yadoin' })
+     *
+     * await User.exists()
+     * // true
+     * ```
+     *
+     * @returns boolean
+     */
+    static exists<T extends typeof Dream>(this: T): Promise<boolean>;
+    /**
+     * Load each specified association using a single SQL query.
+     * See {@link #preload} for preloading in separate queries.
+     *
+     * Note: since leftJoinPreload loads via single query, it has
+     * some downsides and that may be avoided using {@link #preload}:
+     * 1. `limit` and `offset` will be automatically removed
+     * 2. `through` associations will bring additional namespaces into the query that can conflict with through associations from other associations, creating an invalid query
+     * 3. each nested association will result in an additional record which duplicates data from the outer record. E.g., given `.leftJoinPreload('a', 'b', 'c')`, if each `a` has 10 `b` and each `b` has 10 `c`, then for one `a`, 100 records will be returned, each of which has all of the columns of `a`. `.preload('a', 'b', 'c')` would perform three separate SQL queries, but the data for a single `a` would only be returned once.
+     * 4. the individual query becomes more complex the more associations are included
+     * 5. associations loading associations loading associations could result in exponential amounts of data; in those cases, `.preload(...).findEach(...)` avoids instantiating massive amounts of data at once
+     *
+     * ```ts
+     * const user = await User.leftJoinPreload('posts', 'comments', { visibilty: 'public' }, 'replies').first()
+     * console.log(user.posts[0].comments[0].replies)
+     * // [Reply{id: 1}, Reply{id: 2}]
+     * ```
+     *
+     * @param args - A chain of association names and where clauses
+     * @returns A query for this model with the include statement applied
+     */
+    static leftJoinPreload<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], TableName extends InstanceType<T>['table'], Schema extends I['schema'], const Arr extends readonly unknown[], const LastArg extends VariadicLeftJoinLoadArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = QueryWithJoinedAssociationsTypeAndNoPreload<Query<I>, JoinedAssociations>>(this: T, ...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * Applies preload statement to a Query scoped to this model.
+     * Upon instantiating records of this model type,
+     * specified associations will be preloaded.
+     *
+     * Preloading/loading/including is necessary prior to accessing associations
+     * on a Dream instance.
+     *
+     * Preload is useful for avoiding the N+1 query problem
+     *
+     * ```ts
+     * const user = await User.preload('posts', 'comments', { visibilty: 'public' }, 'replies').first()
+     * console.log(user.posts[0].comments[0].replies)
+     * // [Reply{id: 1}, Reply{id: 2}]
+     * ```
+     *
+     * @param args - A chain of association names and where clauses
+     * @returns A query for this model with the preload statement applied
+     */
+    static preload<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], TableName extends InstanceType<T>['table'], Schema extends I['schema'], const Arr extends readonly unknown[]>(this: T, ...args: [...Arr, VariadicLoadArgs<DB, Schema, TableName, Arr>]): Query<InstanceType<T>, Readonly<{
+        joinedAssociations: readonly [];
+        rootTableName: InstanceType<T>["table"];
+        rootTableAlias: InstanceType<T> extends infer T_1 ? T_1 extends InstanceType<T> ? T_1 extends Dream ? T_1["table"] : T_1 : never : never;
+        allowPreload: true;
+        allowLeftJoinPreload: false;
+    }>>;
+    /**
+     * Returns a new Query instance with the provided
+     * inner join statement attached
+     *
+     * ```ts
+     * await User.innerJoin('posts').first()
+     * ```
+     *
+     * @param args - A chain of association names and where clauses
+     * @returns A Query for this model with the inner join clause applied
+     */
+    static innerJoin<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], Schema extends I['schema'], TableName extends I['table'] & keyof Schema, const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = QueryWithJoinedAssociationsType<Query<I>, JoinedAssociations>>(this: T, ...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * Returns a new Query instance with the provided
+     * inner join statement attached
+     *
+     * ```ts
+     * await user.innerJoin('posts').first()
+     * ```
+     *
+     * @param args - A chain of association names and where clauses
+     * @returns A Query for this model with the inner join clause applied
+     */
+    innerJoin<I extends Dream, DB extends I['DB'], Schema extends I['schema'], TableName extends I['table'] & keyof Schema, const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = QueryWithJoinedAssociationsType<Query<I>, JoinedAssociations>>(this: I, ...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * Returns a new Query instance with the provided
+     * left join statement attached
+     *
+     * ```ts
+     * await User.leftJoin('posts').first()
+     * ```
+     *
+     * @param args - A chain of association names and where clauses
+     * @returns A Query for this model with the left join clause applied
+     */
+    static leftJoin<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], Schema extends I['schema'], TableName extends I['table'] & keyof Schema, const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = QueryWithJoinedAssociationsType<Query<I>, JoinedAssociations>>(this: T, ...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * Returns a new Query instance with the provided
+     * left join statement attached
+     *
+     * ```ts
+     * await user.leftJoin('posts').first()
+     * ```
+     *
+     * @param args - A chain of association names and where clauses
+     * @returns A Query for this model with the left join clause applied
+     */
+    leftJoin<I extends Dream, DB extends I['DB'], Schema extends I['schema'], TableName extends I['table'] & keyof Schema, const Arr extends readonly unknown[], const LastArg extends VariadicJoinsArgs<DB, Schema, TableName, Arr>, const JoinedAssociationsCandidate = JoinedAssociationsTypeFromAssociations<DB, Schema, TableName, [
+        ...Arr,
+        LastArg
+    ]>, const JoinedAssociations extends readonly JoinedAssociation[] = JoinedAssociationsCandidate extends readonly JoinedAssociation[] ? JoinedAssociationsCandidate : never, RetQuery = QueryWithJoinedAssociationsType<Query<I>, JoinedAssociations>>(this: I, ...args: [...Arr, LastArg]): RetQuery;
+    /**
+     * Returns the first record corresponding to the
+     * model, ordered by primary key.
+     *
+     * ```ts
+     * await User.first()
+     * // User{id: 1}
+     * ```
+     *
+     * @returns First record, or null if no record exists
+     */
+    static first<T extends typeof Dream>(this: T): Promise<InstanceType<T> | null>;
+    /**
+     * Returns the first record corresponding to the
+     * model, ordered by primary key. If no record is
+     * found, an exception is raised.
+     *
+     * ```ts
+     * await User.firstOrFail()
+     * // User{id: 1}
+     * ```
+     *
+     * @returns First record
+     */
+    static firstOrFail<T extends typeof Dream>(this: T): Promise<InstanceType<T>>;
+    /**
+     * Returns the last record corresponding to the
+     * model, ordered by primary key.
+     *
+     * ```ts
+     * await User.last()
+     * // User{id: 99}
+     * ```
+     *
+     * @returns Last record, or null if no record exists
+     */
+    static last<T extends typeof Dream>(this: T): Promise<InstanceType<T> | null>;
+    /**
+     * Returns the last record corresponding to the
+     * model, ordered by primary key. If no record
+     * is found, an exception is raised.
+     *
+     * ```ts
+     * await User.lastOrFail()
+     * // User{id: 99}
+     * ```
+     *
+     * @returns Last record
+     */
+    static lastOrFail<T extends typeof Dream>(this: T): Promise<InstanceType<T>>;
+    /**
+     * Returns a new Query instance, specifying a limit
+     *
+     * ```ts
+     * await User.limit(2).all()
+     * // [User{}, User{}]
+     * ```
+     *
+     * @returns A Query for this model with the limit clause applied
+     */
+    static limit<T extends typeof Dream>(this: T, count: number | null): Query<InstanceType<T>, Readonly<{
+        joinedAssociations: Readonly<[]>;
+        rootTableName: InstanceType<T>["table"];
+        rootTableAlias: InstanceType<T> extends infer T_1 ? T_1 extends InstanceType<T> ? T_1 extends Dream ? T_1["table"] : T_1 : never : never;
+        allowPreload: true;
+        allowLeftJoinPreload: true;
+    }>>;
+    /**
+     * Returns a new Query instance, specifying an offset
+     *
+     * ```ts
+     * await User.offset(2).order('id').limit(2).all()
+     * // [User{id: 3}, User{id: 4}]
+     * ```
+     *
+     * @returns A Query for this model with the offset clause applied
+     */
+    static offset<T extends typeof Dream>(this: T, offset: number | null): Query<InstanceType<T>, Readonly<{
+        joinedAssociations: Readonly<[]>;
+        rootTableName: InstanceType<T>["table"];
+        rootTableAlias: InstanceType<T> extends infer T_1 ? T_1 extends InstanceType<T> ? T_1 extends Dream ? T_1["table"] : T_1 : never : never;
+        allowPreload: true;
+        allowLeftJoinPreload: true;
+    }>>;
+    /**
+     * Returns a new Query instance, attaching the provided
+     * order statement
+     *
+     * ```ts
+     * await User.order('id').all()
+     * // [User{id: 1}, User{id: 2}, ...]
+     * ```
+     *
+     * ```ts
+     * await User.order({ name: 'asc', id: 'desc' }).all()
+     * // [User{name: 'a', id: 99}, User{name: 'a', id: 97}, User{ name: 'b', id: 98 } ...]
+     * ```
+     *
+     * @param orderStatement - Either a string or an object specifying order. If a string, the order is implicitly ascending. If the orderStatement is an object, statements will be provided in the order of the keys set in the object
+     * @returns A query for this model with the order clause applied
+     */
+    static order<T extends typeof Dream, I extends InstanceType<T>>(this: T, orderStatement: DreamColumnNames<I> | Partial<Record<DreamColumnNames<I>, OrderDir>> | null): Query<InstanceType<T>>;
+    /**
+     * Plucks the provided fields from the corresponding model
+     *
+     * ```ts
+     * await User.pluck('id')
+     * // [1, 3, 2]
+     * ```
+     *
+     * If more than one column is requested, a multi-dimensional
+     * array is returned:
+     *
+     * ```ts
+     * await User.order('id').pluck('id', 'email')
+     * // [[1, 'a@a.com'], [2, 'b@b.com']]
+     * ```
+     *
+     * @param columnNames - The column or array of columns to pluck
+     * @returns An array of pluck results
+     */
+    static pluck<T extends typeof Dream, I extends InstanceType<T>, ColumnNames extends TableColumnNames<I['DB'], I['table']>[], ReturnValue extends ColumnNames['length'] extends 1 ? BaseModelColumnTypes<ColumnNames, I>[0][] : BaseModelColumnTypes<ColumnNames, I>[]>(this: T, ...columnNames: ColumnNames): Promise<ReturnValue>;
+    /**
+     * Plucks the specified fields from the given dream class table
+     * in batches, passing each found columns into the
+     * provided callback function
+     *
+     * ```ts
+     * await User.order('id').pluckEach('id', (id) => {
+     *   console.log(id)
+     * })
+     * // 1
+     * // 2
+     * // 3
+     * ```
+     *
+     * @param fields - a list of fields to pluck, followed by a callback function to call for each set of found fields
+     * @returns void
+     */
+    static pluckEach<T extends typeof Dream, I extends InstanceType<T>, ColumnNames extends TableColumnNames<I['DB'], I['table']>[], CbArgTypes extends BaseModelColumnTypes<ColumnNames, I>>(this: T, ...args: PluckEachArgs<ColumnNames, CbArgTypes>): Promise<void>;
+    /**
+     * Used in conjunction with the Sortable decorator, `resort`
+     * takes a list of sortable fields, and for each one, finds and
+     * sorts each record in the DB matching the field based on the
+     * scope provided for each Sortable decorator found.
+     *
+     * Calling this method shouldn't be necessary, but if
+     * the contents of the database have shifted without firing the
+     * correct callback mechanisms at the application layer, calling
+     * `resort` will ensure that all sortable fields are set from 1..n
+     * with no gaps, accounting for the scopes specified in the
+     * corresponding Sortable decorator.
+     *
+     * ```ts
+     * class Post extends ApplicationModel {
+     *   @Sortable({ scope: ['user']})
+     *   public position: DreamColumn<User, 'position'>
+     * }
+     *
+     * await Post.all()
+     * // [Post{position: 1}, Post{position: 3}, Post{position: 5}]
+     *
+     * await Post.resort('position')
+     * await Post.all()
+     * // [Post{position: 1}, Post{position: 2}, Post{position: 3}]
+     * ```
+     *
+     * @param fields - A list of sortable fields to resort
+     * @returns void
+     *
+     */
+    static resort<T extends typeof Dream>(this: T, ...fields: DreamColumnNames<InstanceType<T>>[]): Promise<void>;
+    /**
+     * Returns a Query scoped to this model with
+     * the specified scope applied.
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @Scope()
+     *   public visible(query: Query<User>) {
+     *     return query.where({ hidden: false })
+     *   }
+     * }
+     *
+     * await User.scope('visible').all()
+     * // [User{hidden: false}, User{hidden: false}]
+     * ```
+     *
+     * @param scopeName - The name of the scope
+     * @returns a Query scoped to this model with the specified scope applied
+     */
+    static scope<T extends typeof Dream>(this: T, scopeName: DefaultOrNamedScopeName<InstanceType<T>>): Query<InstanceType<T>>;
+    /**
+     * Returns the sql that would be executed by a Query
+     * scoped to this model.
+     *
+     * ```ts
+     * User.sql()
+     * // {
+     * //  query: {
+     * //    kind: 'SelectQueryNode',
+     * //    from: { kind: 'FromNode', froms: [Array] },
+     * //    selections: [ [Object] ],
+     * //    distinctOn: undefined,
+     * //    joins: undefined,
+     * //    groupBy: undefined,
+     * //    orderBy: undefined,
+     * //    where: { kind: 'WhereNode', where: [Object] },
+     * //    frontModifiers: undefined,
+     * //    endModifiers: undefined,
+     * //    limit: undefined,
+     * //    offset: undefined,
+     * //    with: undefined,
+     * //    having: undefined,
+     * //    explain: undefined,
+     * //    setOperations: undefined
+     * //  },
+     * //  sql: 'select "users".* from "users" where "users"."deleted_at" is null',
+     * //  parameters: []
+     * //}
+     * ```
+     *
+     * @returns An object representing the underlying sql statement
+     *
+     */
+    static sql<T extends typeof Dream>(this: T): CompiledQuery<object>;
+    /**
+     * Converts the given Dream class into a Kysely query, enabling
+     * you to build custom queries using the Kysely API
+     *
+     * ```ts
+     * await User.toKysely('select').where('email', '=', 'how@yadoin').execute()
+     * ```
+     *
+     * @param type - The type of Kysely query builder instance you would like to obtain
+     * @returns A Kysely query. Depending on the type passed, it will return either a SelectQueryBuilder, DeleteQueryBuilder, UpdateQueryBuilder, or an InsertQueryBuilder
+     */
+    static toKysely<T extends typeof Dream, QueryType extends 'select' | 'delete' | 'update' | 'insert', ToKyselyReturnType = QueryType extends 'select' ? SelectQueryBuilder<InstanceType<T>['DB'], InstanceType<T>['table'], unknown> : QueryType extends 'delete' ? DeleteQueryBuilder<InstanceType<T>['DB'], InstanceType<T>['table'], unknown> : QueryType extends 'update' ? UpdateQueryBuilder<InstanceType<T>['DB'], InstanceType<T>['table'], InstanceType<T>['table'], unknown> : QueryType extends 'insert' ? InsertQueryBuilder<InstanceType<T>['DB'], InstanceType<T>['table'], unknown> : never>(this: T, type: QueryType): ToKyselyReturnType;
+    /**
+     * Applies transaction to a new Query scoped
+     * to this model
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   await User.txn(txn).create({ email: 'how@yadoin' })
+     * })
+     * ```
+     *
+     * @param txn - A DreamTransaction instance (usually collected by calling `ApplicationModel.transaction`)
+     * @returns A Query scoped to this model with the transaction applied
+     */
+    static txn<T extends typeof Dream, I extends InstanceType<T>>(this: T, txn: DreamTransaction<I>): DreamClassTransactionBuilder<I>;
+    /**
+     * Builds a new DreamTransaction instance, provides
+     * the instance to the provided callback.
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   const user = await User.txn(txn).create({ email: 'how@yadoin' })
+     *   await Pet.txn(txn).create({ user })
+     * })
+     * ```
+     *
+     * @param callback - A callback function to call. The transaction provided to the callback can be passed to subsequent database calls within the transaction callback
+     * @returns void
+     */
+    static transaction<T extends typeof Dream, CB extends (txn: DreamTransaction<InstanceType<T>>) => unknown, RetType extends ReturnType<CB>>(this: T, callback: CB): Promise<RetType>;
+    /**
+     * Sends data through for use as passthrough data
+     * for the associations that require it.
+     *
+     * ```ts
+     * class Post {
+     *   @Deco.HasMany('LocalizedText')
+     *   public localizedTexts: LocalizedText[]
+     *
+     *   @Deco.HasOne('LocalizedText', {
+     *     where: { locale: DreamConst.passthrough },
+     *   })
+     *   public currentLocalizedText: LocalizedText
+     * }
+     *
+     * await User.passthrough({ locale: 'es-ES' })
+     *   .preload('posts', 'currentLocalizedText')
+     *   .first()
+     * ```
+     *
+     * @param passthroughWhereStatement - Where statement used for associations that require passthrough data
+     * @returns A Query for this model with the passthrough data
+     */
+    static passthrough<T extends typeof Dream, I extends InstanceType<T>, PassthroughColumns extends PassthroughColumnNames<I>>(this: T, passthroughWhereStatement: PassthroughOnClause<PassthroughColumns>): Query<InstanceType<T>>;
+    /**
+     * Applies a where statement to a new Query instance
+     * scoped to this model
+     *
+     * ```ts
+     * await User.where({ email: 'how@yadoin' }).first()
+     * // User{email: 'how@yadoin'}
+     * ```
+     *
+     * @param whereStatement - Where statement to apply to the Query
+     * @returns A Query for this model with the where clause applied
+     */
+    static where<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], Schema extends I['schema'], TableName extends AssociationTableNames<DB, Schema> & keyof DB = InstanceType<T>['table']>(this: T, whereStatement: WhereStatement<DB, Schema, TableName>): Query<InstanceType<T>>;
+    /**
+     * Applies "OR"'d where statements to a Query scoped
+     * to this model.
+     *
+     * ```ts
+     * await User.whereAny([{ email: 'how@yadoin' }, { name: 'fred' }]).first()
+     * // [User{email: 'how@yadoin'}, User{name: 'fred'}, User{name: 'fred'}]
+     * ```
+     *
+     * @param whereStatements - a list of where statements to `OR` together
+     * @returns A Query for this model with the whereAny clause applied
+     */
+    static whereAny<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], Schema extends I['schema'], TableName extends AssociationTableNames<DB, Schema> & keyof DB = InstanceType<T>['table']>(this: T, statements: WhereStatement<DB, Schema, TableName>[]): Query<InstanceType<T>>;
+    /**
+     * Applies a whereNot statement to a new Query instance
+     * scoped to this model.
+     *
+     * ```ts
+     * await User.whereNot({ email: 'how@yadoin' }).first()
+     * // User{email: 'hello@world'}
+     * ```
+     *
+     * @param whereStatement - A where statement to negate and apply to the Query
+     * @returns A Query for this model with the whereNot clause applied
+     */
+    static whereNot<T extends typeof Dream, I extends InstanceType<T>, DB extends I['DB'], Schema extends I['schema'], TableName extends AssociationTableNames<DB, Schema> & keyof DB = InstanceType<T>['table']>(this: T, attributes: WhereStatement<DB, Schema, TableName>): Query<InstanceType<T>>;
+    /**
+     * @internal
+     *
+     * Given a column, checks to see if it is a foreign key
+     * belonging to a BelongsTo association
+     *
+     * ```ts
+     * Post.isBelongsToAssociationForeignKey('id')
+     * // false
+     * Post.isBelongsToAssociationForeignKey('userId')
+     * // true
+     * ```
+     *
+     * @param column - A column on this Dream class
+     * @returns A boolean
+     */
+    private static isBelongsToAssociationForeignKey;
+    /**
+     * @internal
+     *
+     * Given a column, checks to see if it is a belongs to
+     * polymorphic type field
+     *
+     * ```ts
+     * LocalizedText.isBelongsToAssociationPolymorphicTypeField('localizableId')
+     * // false
+     * LocalizedText.isBelongsToAssociationPolymorphicTypeField('localizableType')
+     * // true
+     * ```
+     *
+     * @param column - a column on this dream class
+     * @returns A boolean
+     */
+    private static isBelongsToAssociationPolymorphicTypeField;
+    /**
+     * @internal
+     *
+     * Returns an array of column names that are belongs
+     * to foreign keys on this dream class
+     *
+     * ```ts
+     * Post.belongsToAssociationForeignKeys()
+     * // ['userId']
+     * ```
+     *
+     * @returns An array of column names that are belongs to foreign keys on this dream class
+     */
+    private static belongsToAssociationForeignKeys;
+    /**
+     * @internal
+     *
+     * Returns all polymorphic type columns
+     *
+     * ```ts
+     * LocalizedText.polymorphicTypeColumns()
+     * // ['localizableType']
+     * ```
+     *
+     * @returns An array of column names that are polymorphic type fields on the given dream class
+     */
+    private static polymorphicTypeColumns;
+    /**
+     * @internal
+     *
+     * Returns a list of association names which
+     * correspond to belongs to associations
+     * on this model class.
+     *
+     * ```ts
+     * Post.belongsToAssociationNames()
+     * // ['user']
+     * ```
+     *
+     * @returns An array of belongs to association names
+     */
+    private static belongsToAssociationNames;
+    /**
+     * @internal
+     *
+     * Returns a list of association names which
+     * have `dependent: destroy` set
+     *
+     * ```ts
+     * Post.dependentDestroyAssociationNames()
+     * // ['user']
+     * ```
+     *
+     * @returns An array of HasOne/HasMany association names with `dependent: 'destroy'` defined
+     */
+    private static dependentDestroyAssociationNames;
+    /**
+     * @internal
+     *
+     * Returns the metadata for the provided association
+     *
+     * ```ts
+     * new Post()['getAssociationMetadata']('user')
+     * // {
+     * //    modelCB: [Function (anonymous)],
+     * //    type: 'BelongsTo',
+     * //    as: 'user',
+     * //    optional: false,
+     * //    polymorphic: false,
+     * //    primaryKeyOverride: null,
+     * //    primaryKey: [Function: primaryKey],
+     * //    primaryKeyValue: [Function: primaryKeyValue],
+     * //    foreignKey: [Function: foreignKey],
+     * //    foreignKeyTypeField: [Function: foreignKeyTypeField]
+     * //  }
+     * ```
+     *
+     * @returns Association metadata
+     *
+     */
+    private getAssociationMetadata;
+    /**
+     * @internal
+     *
+     * Returns all association metadata for the given dream class
+     *
+     * ```ts
+     * new Post()['associationMetadataMap']()
+     * // {
+     * //     user: {
+     * //       modelCB: [Function (anonymous)],
+     * //       type: 'BelongsTo',
+     * //       as: 'user',
+     * //       optional: false,
+     * //       polymorphic: false,
+     * //       primaryKeyOverride: null,
+     * //       primaryKey: [Function: primaryKey],
+     * //       primaryKeyValue: [Function: primaryKeyValue],
+     * //       foreignKey: [Function: foreignKey],
+     * //       foreignKeyTypeField: [Function: foreignKeyTypeField]
+     * //     },
+     * //     ratings: {
+     * //       modelCB: [Function (anonymous)],
+     * //       type: 'HasMany',
+     * //       as: 'ratings',
+     * //       polymorphic: true,
+     * //       source: 'ratings',
+     * //       preloadThroughColumns: undefined,
+     * //       where: undefined,
+     * //       whereNot: undefined,
+     * //       selfWhere: undefined,
+     * //       selfWhereNot: undefined,
+     * //       primaryKeyOverride: null,
+     * //       primaryKey: [Function: primaryKey],
+     * //       primaryKeyValue: [Function: primaryKeyValue],
+     * //       through: undefined,
+     * //       distinct: undefined,
+     * //       order: undefined,
+     * //       foreignKey: [Function: foreignKey],
+     * //       foreignKeyTypeField: [Function: foreignKeyTypeField]
+     * //     },
+     * //     ...
+     * // }
+     * ```
+     *
+     * @returns association metadata
+     */
+    private associationMetadataMap;
+    /**
+     * @internal
+     *
+     * returns all association data for the given dream class,
+     * organized by the type of association
+     *
+     * ```ts
+     * new Post().associationMetadataByType
+     * // {
+     * //   belongsTo: [
+     * //     {
+     * //       modelCB: [Function (anonymous)],
+     * //       type: 'BelongsTo',
+     * //       as: 'user',
+     * //       optional: false,
+     * //       polymorphic: false,
+     * //       primaryKeyOverride: null,
+     * //       primaryKey: [Function: primaryKey],
+     * //       primaryKeyValue: [Function: primaryKeyValue],
+     * //       foreignKey: [Function: foreignKey],
+     * //       foreignKeyTypeField: [Function: foreignKeyTypeField]
+     * //     },
+     * //   ],
+     * //   hasMany: [
+     * //   ],
+     * //   hasOne: []
+     * //   }
+     * // }
+     * ```
+     *
+     * @returns association metadata by type
+     *
+     */
+    private get associationMetadataByType();
+    /**
+     * @internal
+     *
+     * Returns an array of association names for the
+     * given dream class
+     *
+     * ```ts
+     * new Post().associationNames
+     * // [ 'user', 'postVisibility', 'ratings', 'heartRatings' ]
+     * ```
+     *
+     * @returns association names array
+     */
+    get associationNames(): string[];
+    /**
+     * Returns true if any of the attributes on the instance
+     * have changed since it was last pulled from the database.
+     * It will also return true if the instance is not yet
+     * persisted.
+     *
+     * ```ts
+     * const post = Post.new({ body: 'howyadoin' })
+     * post.isDirty
+     * // true
+     *
+     * await post.save()
+     * post.isDirty
+     * // false
+     *
+     * post.body = 'groiyyyt'
+     * post.isDirty
+     * // true
+     * ```
+     *
+     * @returns A boolean
+     */
+    get isDirty(): boolean;
+    /**
+     * Returns true. This is useful for identifying
+     * dream instances from other objects
+     *
+     * @returns true
+     */
+    get isDreamInstance(): boolean;
+    /**
+     * Runs validation checks against all validations
+     * declared using the Validate and Validates decorators,
+     * and returns true if any of them fail.
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @Validates('presence')
+     *   public email: DreamColumn<User, 'email'>
+     * }
+     * const user = User.new()
+     * user.isInvalid
+     * // true
+     *
+     * user.email = 'how@yadoin'
+     * user.isInvalid
+     * // false
+     * ```
+     *
+     * @returns A boolean
+     */
+    get isInvalid(): boolean;
+    /**
+     * Returns true if the model has not been persisted
+     * to the database.
+     *
+     * ```ts
+     * const user = User.new({ email: 'howyadoin' })
+     * user.isNewRecord
+     * // true
+     *
+     * await user.save()
+     * user.isNewRecord
+     * // false
+     * ```
+     *
+     * @returns A boolean
+     */
+    get isNewRecord(): boolean;
+    /**
+     * Runs validation checks against all validations
+     * declared using the Validate and Validates decorators.
+     * Returns true if none of the validations fail.
+     *
+     * NOTE: Any validations that fail will leave the errors
+     * field populated on your model instance.
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @Validates('presence')
+     *   public email: DreamColumn<User, 'email'>
+     * }
+     *
+     * const user = User.new()
+     * user.isValid
+     * // false
+     *
+     * user.email = 'how@yadoin'
+     * user.isValid
+     * // true
+     * ```
+     *
+     * @returns A boolean
+     */
+    get isValid(): boolean;
+    /**
+     * The name of the primary key column on this model.
+     * NOTE: Must specify `as const` when defining a custom
+     * primary key.
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   public customIdField: DreamColumn<User, 'customIdField'>
+     *
+     *   public get primaryKey() {
+     *     return 'customIdField' as const
+     *   }
+     * }
+     * ```
+     *
+     * @returns The primary key column name
+     */
+    get primaryKey(): "id";
+    /**
+     * Returns the value of the primary key
+     *
+     * @returns The value of the primary key field for this Dream instance
+     */
+    get primaryKeyValue(): IdType;
+    /**
+     * This must be defined on every model, and it must point
+     * to a table in your database. In addition, you must
+     * return the value using the `as const` suffix, like so:
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   public get table() {
+     *     return 'users' as const
+     *   }
+     * }
+     * ```
+     *
+     * @returns The table name for this model
+     */
+    get table(): AssociationTableNames<any, any>;
+    /**
+     * @internal
+     *
+     * _errors is used to inform validation errors,
+     * and is built whenever validations are run on
+     * a dream instance.
+     */
+    private _errors;
+    /**
+     * @internal
+     *
+     * Used for the changes api
+     */
+    private frozenAttributes;
+    /**
+     * @internal
+     *
+     * Used for the changes api
+     */
+    private originalAttributes;
+    /**
+     * @internal
+     *
+     * Used for the changes api
+     */
+    private currentAttributes;
+    /**
+     * @internal
+     *
+     * Used for the changes api
+     */
+    private attributesFromBeforeLastSave;
+    /**
+     * @internal
+     *
+     * Stores whether the record has been persisted or not
+     */
+    private _isPersisted;
+    /**
+     * Returns true if the model has been persisted
+     * to the database.
+     *
+     * ```ts
+     * const user = User.new({ email: 'howyadoin' })
+     * user.isPersisted
+     * // false
+     *
+     * await user.save()
+     * user.isPersisted
+     * // true
+     * ```
+     *
+     * @returns A boolean
+     */
+    get isPersisted(): boolean;
+    protected set isPersisted(val: boolean);
+    /**
+     * Since typescript prevents constructor functions
+     * from absorbing type generics, we provide the `new`
+     * method to instantiate with type protection
+     *
+     * ```ts
+     * const user = User.new({ email: 'how@yadoin' })
+     * ```
+     *
+     * @returns A new (unpersisted) instance of the provided dream class
+     */
+    static new<T extends typeof Dream>(this: T, opts?: UpdateablePropertiesForClass<T>, additionalOpts?: {
+        bypassUserDefinedSetters?: boolean;
+    }): InstanceType<T>;
+    /**
+     * @internal
+     *
+     * NOTE: avoid using the constructor function directly.
+     * Use the static `.new` or `.create` methods instead, which
+     * will provide type guarding for your attributes.
+     *
+     * Since typescript prevents constructor functions
+     * from absorbing type generics, we provide the `new`
+     * method to instantiate with type protection.
+     *
+     * ```ts
+     * const user = User.new({ email: 'how@yadoin' })
+     * ```
+     *
+     * @returns A new (unpersisted) instance of the provided dream class
+     */
+    constructor(opts: any, additionalOpts: {
+        bypassUserDefinedSetters?: boolean;
+        isPersisted?: boolean;
+        _internalUseOnly: true;
+    });
+    /**
+     * @internal
+     *
+     * Used for determining which attributes to update
+     */
+    protected static extractAttributesFromUpdateableProperties<T extends typeof Dream>(this: T, attributes: UpdateablePropertiesForClass<T>, dreamInstance?: InstanceType<T>, { bypassUserDefinedSetters }?: {
+        bypassUserDefinedSetters?: boolean;
+    }): WhereStatement<InstanceType<T>['DB'], InstanceType<T>['schema'], InstanceType<T>['table']>;
+    /**
+     * @internal
+     *
+     * defines attribute setters and getters for every column
+     * set within your types/dream.ts file
+     */
+    private defineAttributeAccessors;
+    /**
+     * @internal
+     *
+     * Modern Javascript applies implicit accessors to instance properties that
+     * shadow prototype accessors applied by Dream. This method is called after
+     * every Dream model is initialized to delete the instance accessors so that
+     * the prototype accessors can be reached.
+     */
+    protected unshadowColumnPropertyPrototypeAccessors(): void;
+    protected finalizeConstruction(): void;
+    /**
+     * Returns true if the columnName passed is marked by a
+     * Virtual attribute decorator
+     *
+     * @param columnName - A property on this model to check
+     * @returns A boolean
+     */
+    isVirtualColumn<T extends Dream>(this: T, columnName: string): boolean;
+    /**
+     * Returns an object with column names for keys, and an
+     * array of strings representing validation errors for values.
+     *
+     * @returns An error object
+     */
+    get errors(): {
+        [key: string]: ValidationType[];
+    };
+    /**
+     * Adds an error to the model. Any errors added to the model
+     * will cause the model to be invalid, and will prevent the
+     * model from saving.
+     *
+     * ```ts
+     *  class User extends ApplicationModel {
+     *    ...
+     *    @Validate()
+     *    public async validateName() {
+     *      if (typeof this.name === 'number')
+     *        this.addError('name', 'name cannot be a number')
+     *    }
+     *  }
+     * ```
+     *
+     * @returns void
+     */
+    addError<I extends Dream, Key extends AttributeKeys<I>>(this: I, column: Key & string, error: string): void;
+    /**
+     * Changes the attribute value for a single attribute,
+     * leveraging any custom-defined setters. If you would like to
+     * bypass custom-defined setters, use #setAttribute instead
+     *
+     * ```ts
+     *  const user = new User()
+     *  user.assignAttribute('email', 'sally@gmail.com')
+     * ```
+     */
+    assignAttribute<I extends Dream, Key extends AttributeKeys<I>>(this: I, attr: Key & string, val: any): void;
+    /**
+     * Changes the attribute value for a single attribute internally,
+     * bypassing any custom-defined setters. If you would like to set attributes
+     * without bypassing custom-defined setters, use #assignAttribute instead
+     *
+     * ```ts
+     *  const user = new User()
+     *  user.setAttribute('email', 'sally@gmail.com')
+     * ```
+     */
+    setAttribute<I extends Dream, Key extends AttributeKeys<I>>(this: I, attr: Key & string, val: any): void;
+    /**
+     * Returns the value for a columnName provided,
+     * bypassing the getters.
+     *
+     * ```ts
+     *  const user = User.new({ email: 'how@yadoin' })
+     *  user.getAttribute('email') // 'how@yadoin'
+     * ```
+     */
+    getAttribute<I extends Dream, Key extends AttributeKeys<I>>(this: I, columnName: Key & string): DreamAttributes<I>[Key];
+    /**
+     * Returns an object containing all the columns
+     * on this dream class, as well as their values,
+     * bypassing getters.
+     *
+     * ```ts
+     *  const user = User.new({ email: 'how@yadoin' })
+     *  user.attributes()
+     *  // {
+     *  //   email: 'how@yadoin',
+     *  //   ...
+     *  // }
+     * ```
+     */
+    getAttributes<I extends Dream, DB extends I['DB']>(this: I): Updateable<DB[I['table']]>;
+    /**
+     * @internal
+     *
+     * Returns the db type stored within the database
+     */
+    protected static cachedTypeFor<T extends typeof Dream, DB extends InstanceType<T>['DB'], TableName extends keyof DB = InstanceType<T>['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName]>(this: T, attribute: keyof Table): string;
+    /**
+     * Returns the attributes that have changed since
+     * being persisted to the database, with the values
+     * that were last persisted to the database.
+     *
+     * ```ts
+     *  const user = User.new({ email: 'original@email', password: 'howyadoin' })
+     *  await user.save()
+     *
+     *  user.email = 'new@email'
+     *  user.changedAttributes()
+     *  // { email: 'original@email' }
+     *
+     *  user.email = 'original@email'
+     *  user.changedAttributes()
+     *  // {}
+     * ```
+     *
+     * @returns An object containing changed attributes and their original values
+     */
+    changedAttributes<I extends Dream, DB extends I['DB'], Schema extends I['schema'], TableName extends AssociationTableNames<DB, Schema> & keyof DB = I['table'] & AssociationTableNames<DB, Schema>, Table extends DB[keyof DB] = DB[TableName]>(this: I): Updateable<Table>;
+    /**
+     * Returns an object containing the attributes that have
+     * changed since last persisting, along with their current
+     * and previously persisted values.
+     *
+     * ```ts
+     * const pet = Pet.new({ species: 'dog' })
+     * pet.changes()
+     * // {
+     * //   species: {
+     * //     was: undefined,
+     * //     now: 'dog',
+     * //   }
+     * // }
+     *
+     * await pet.save()
+     * pet.changes()
+     * // {
+     * //   species: {
+     * //     was: undefined,
+     * //     now: 'dog',
+     * //   }
+     * // }
+     *
+     * pet.species = 'cat'
+     * pet.species = 'frog'
+     * pet.changes()
+     * // {
+     * //   species: {
+     * //     was: 'dog',
+     * //     now: 'frog',
+     * //   }
+     * // }
+     *
+     * await pet.save()
+     * pet.changes()
+     * // {
+     * //   species: {
+     * //     was: 'dog',
+     * //     now: 'frog',
+     * //   }
+     * // }
+     * ```
+     *
+     * @returns An object containing changed attributes
+     */
+    changes<I extends Dream, DB extends I['DB'], TableName extends I['table'], Table extends DB[TableName], RetType = Partial<Record<DreamColumnNames<I>, {
+        was: Updateable<Table>[DreamColumnNames<I>];
+        now: Updateable<Table>[DreamColumnNames<I>];
+    }>>>(this: I): RetType;
+    /**
+     * Returns the value most recently persisted
+     * to the database.
+     *
+     * ```ts
+     * const pet = Pet.new({ species: 'cat' })
+     * pet.previousValueForAttribute('species')
+     * // undefined
+     *
+     * await pet.save()
+     * pet.previousValueForAttribute('species')
+     * // undefined
+     *
+     * pet.species = 'dog'
+     * pet.previousValueForAttribute('species')
+     * // 'cat'
+     *
+     * await pet.save()
+     * pet.previousValueForAttribute('species')
+     * // 'cat'
+     *
+     * await pet.update({ species: 'cat' })
+     * pet.previousValueForAttribute('species')
+     * // 'dog'
+     * ```
+     *
+     * @param columName - The column name you want the previous value for
+     * @returns Returns the previous value for an attribute
+     */
+    previousValueForAttribute<I extends Dream, DB extends I['DB'], TableName extends I['table'], Table extends DB[TableName], ColumnName extends DreamColumnNames<I>>(this: I, columnName: ColumnName): Updateable<Table>[ColumnName];
+    /**
+     * Returns true if the columnName provided has
+     * changes that were persisted during the most
+     * recent save.
+     *
+     * @param columnName - the column name to check
+     * @returns A boolean
+     */
+    savedChangeToAttribute<I extends Dream>(this: I, columnName: DreamColumnNames<I>): boolean;
+    /**
+     * Returns true if the columnName provided has
+     * changes that have not yet been persisted.
+     *
+     * @param columnName - the column name to check
+     * @returns A boolean
+     */
+    willSaveChangeToAttribute<I extends Dream>(this: I, attribute: DreamColumnNames<I>): boolean;
+    /**
+     * Returns the column names for the given model
+     *
+     * @returns The column names for the given model
+     */
+    columns<I extends Dream, DB extends I['DB'], TableName extends keyof DB = I['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName]>(this: I): Set<keyof Table>;
+    /**
+     * Returns an object containing the column names
+     * of columns that have changed since last persist,
+     * and their current values.
+     *
+     * ```ts
+     *  const user = User.new({ email: 'hello@world' })
+     *  user.dirtyAttributes()
+     *  // { email: 'hello@world' }
+     *
+     *  await user.save()
+     *
+     *  user.email = 'hello@world'
+     *  user.dirtyAttributes()
+     *  // {}
+     *
+     *  user.email = 'goodbye@world'
+     *  user.dirtyAttributes()
+     *  // { email: 'goodbye@world' }
+     *
+     *  user.email = 'hello@world'
+     *  user.dirtyAttributes()
+     *  // {}
+     * ```
+     *
+     * @returns An object containing the changed attributes
+     */
+    dirtyAttributes<I extends Dream, DB extends I['DB'], Schema extends I['schema'], TableName extends AssociationTableNames<DB, Schema> & keyof DB = I['table'] & AssociationTableNames<DB, Schema>, Table extends DB[keyof DB] = DB[TableName]>(this: I): Updateable<Table>;
+    /**
+     * Returns true if an attribute has changes since last persist
+     *
+     * @returns A boolean
+     */
+    private attributeIsDirty;
+    /**
+     * @internal
+     */
+    private unknownValueToMillis;
+    /**
+     * @internal
+     */
+    private unknownValueToDateString;
+    /**
+     * Deletes the record represented by this instance
+     * from the database, calling any destroy
+     * hooks on this model.
+     *
+     * ```ts
+     * const user = await User.last()
+     * await user.destroy()
+     * ```
+     *
+     * @param options - Options for destroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
+     * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade destroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
+     * @returns The instance that was destroyed
+     */
+    destroy<I extends Dream>(this: I, options?: DestroyOptions<I>): Promise<I>;
+    /**
+     * Deletes the record represented by this instance
+     * from the database, calling any destroy
+     * hooks on this model.
+     *
+     * If the record being destroyed is using
+     * a SoftDelete decorator, the soft delete
+     * will be bypassed, causing the record
+     * to be permanently removed from the database.
+     *
+     * ```ts
+     * const user = await User.last()
+     * await user.reallyDestroy()
+     * ```
+     *
+     * @param options - Options for destroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
+     * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade destroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
+     * @returns The instance that was destroyed
+     */
+    reallyDestroy<I extends Dream>(this: I, options?: DestroyOptions<I>): Promise<I>;
+    /**
+     * Undestroys a SoftDelete model, unsetting
+     * the `deletedAt` field in the database.
+     *
+     * If the model is not a SoftDelete model,
+     * this will raise an exception.
+     *
+     * ```ts
+     * const user = await User.removeAllDefaultScopes().last()
+     * await user.undestroy()
+     * ```
+     *
+     * @param options - Options for undestroying the instance
+     * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
+     * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
+     * @param options.bypassAllDefaultScopes - If true, bypasses all default scopes when cascade undestroying. Defaults to false
+     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade undestroying (soft delete is always bypassed). Defaults to an empty array
+     * @returns The undestroyed record
+     */
+    undestroy<I extends Dream>(this: I, options?: DestroyOptions<I>): Promise<I>;
+    /**
+     * Returns true if the argument is the same Dream class
+     * with the same primary key value.
+     *
+     * NOTE: This does not compare attribute values other than
+     * the primary key.
+     *
+     * @returns A boolean
+     */
+    equals(other: any): boolean;
+    /**
+     * @internal
+     *
+     * Used for changes API
+     */
+    protected freezeAttributes(): void;
+    /**
+     * Deep clones the model and its non-association attributes.
+     * Unsets primaryKey, created and updated fields.
+     *
+     * @returns Non-persisted, cloned Dream instance
+     */
+    dup<I extends Dream>(this: I): I;
+    /**
+     * Deep clones the model and it's attributes, but maintains references to
+     * loaded associations
+     */
+    private clone;
+    /**
+     * Creates an association for an instance. Automatically
+     * handles setting foreign key and, in the case of polymorphism,
+     * foreign key type.
+     *
+     * ```ts
+     * await user.createAssociation('posts', { body: 'hello world' })
+     * ```
+     *
+     * @param associationName - the name of the association to create
+     * @param attributes - the attributes with which to create the associated model
+     * @returns The created association
+     */
+    createAssociation<I extends Dream, AssociationName extends DreamAssociationNames<I>, PossibleArrayAssociationType = I[AssociationName & keyof I], AssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType, RestrictedAssociationType extends AssociationType extends Dream ? AssociationType : never = AssociationType extends Dream ? AssociationType : never>(this: I, associationName: AssociationName, attributes?: UpdateableAssociationProperties<I, RestrictedAssociationType>): Promise<NonNullable<AssociationType>>;
+    destroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    destroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    reallyDestroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    reallyDestroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    undestroyAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    undestroyAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, options?: DestroyOptions<I> & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    associationQuery<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
+    associationQuery<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, joinOnStatements?: JoinOnStatements<DB, Schema, AssociationTableName, null>): Query<AssociationDream, DefaultQueryTypeOptions<AssociationDream, AssociationName & string>>;
+    updateAssociation<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], AssociationName extends DreamAssociationNames<I>, RequiredOnClauseKeysForThisAssociation extends RequiredOnClauseKeys<Schema, TableName, AssociationName>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<I, AssociationName>>>, updateAssociationOptions: {
+        bypassAllDefaultScopes?: boolean;
+        defaultScopesToBypass?: AllDefaultScopeNames<I>[];
+        skipHooks?: boolean;
+    } & JoinOnStatements<DB, Schema, AssociationTableName, RequiredOnClauseKeysForThisAssociation>): Promise<number>;
+    updateAssociation<I extends Dream, DB extends I['DB'], Schema extends I['schema'], AssociationName extends DreamAssociationNamesWithoutRequiredOnClauses<I>, AssociationDream extends AssociationNameToDream<I, AssociationName>, AssociationTableName extends AssociationDream['table']>(this: I, associationName: AssociationName, attributes: Partial<DreamAttributes<AssociationNameToDream<I, AssociationName>>>, updateAssociationOptions?: {
+        bypassAllDefaultScopes?: boolean;
+        defaultScopesToBypass?: AllDefaultScopeNames<I>[];
+        skipHooks?: boolean;
+    } & JoinOnStatements<DB, Schema, AssociationTableName, null>): Promise<number>;
+    /**
+     * Sends data through for use as passthrough data
+     * for the associations that require it.
+     *
+     * ```ts
+     * class Post {
+     *   @Deco.HasMany('LocalizedText')
+     *   public localizedTexts: LocalizedText[]
+     *
+     *   @Deco.HasOne('LocalizedText', {
+     *     where: { locale: DreamConst.passthrough },
+     *   })
+     *   public currentLocalizedText: LocalizedText
+     * }
+     *
+     * await User.passthrough({ locale: 'es-ES' })
+     *   .preload('posts', 'currentLocalizedText')
+     *   .first()
+     * ```
+     *
+     * @param passthroughWhereStatement - where statement used for associations that require passthrough data
+     * @returns A cloned Query with the passthrough data
+     */
+    passthrough<I extends Dream, PassthroughColumns extends PassthroughColumnNames<I>>(this: I, passthroughWhereStatement: PassthroughOnClause<PassthroughColumns>): LoadBuilder<I>;
+    /**
+     * Loads the requested associations upon execution
+     *
+     * NOTE: {@link #preload} is often a preferrable way of achieving the
+     * same goal.
+     *
+     * ```ts
+     * await user
+     *  .load('posts', { body: ops.ilike('%hello world%') }, 'comments', 'replies')
+     *  .load('images')
+     *  .execute()
+     *
+     * user.posts[0].comments[0].replies[0]
+     * // Reply{}
+     *
+     * user.images[0]
+     * // Image{}
+     * ```
+     *
+     * @param args - A list of associations (and optional where clauses) to load
+     * @returns A chainable LoadBuilder instance
+     */
+    load<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], const Arr extends readonly unknown[]>(this: I, ...args: [...Arr, VariadicLoadArgs<DB, Schema, TableName, Arr>]): LoadBuilder<I>;
+    /**
+     * Load each specified association using a single SQL query.
+     * See {@link #load} for loading in separate queries.
+     *
+     * Note: since leftJoinPreload loads via single query, it has
+     * some downsides and that may be avoided using {@link #load}:
+     * 1. `limit` and `offset` will be automatically removed
+     * 2. `through` associations will bring additional namespaces into the query that can conflict with through associations from other associations, creating an invalid query
+     * 3. each nested association will result in an additional record which duplicates data from the outer record. E.g., given `.leftJoinPreload('a', 'b', 'c')`, if each `a` has 10 `b` and each `b` has 10 `c`, then for one `a`, 100 records will be returned, each of which has all of the columns of `a`. `.load('a', 'b', 'c')` would perform three separate SQL queries, but the data for a single `a` would only be returned once.
+     * 4. the individual query becomes more complex the more associations are included
+     * 5. associations loading associations loading associations could result in exponential amounts of data; in those cases, `.load(...).findEach(...)` avoids instantiating massive amounts of data at once
+     * Loads the requested associations upon execution
+     *
+     * NOTE: {@link #leftJoinPreload} is often a preferrable way of achieving the
+     * same goal.
+     *
+     * ```ts
+     * await user
+     *  .leftJoinLoad('posts', { body: ops.ilike('%hello world%') }, 'comments', 'replies')
+     *  .leftJoinLoad('images')
+     *  .execute()
+     *
+     * user.posts[0].comments[0].replies[0]
+     * // Reply{}
+     *
+     * user.images[0]
+     * // Image{}
+     * ```
+     *
+     * @param args - A list of associations (and optional where clauses) to load
+     * @returns A chainable LeftJoinLoadBuilder instance
+     */
+    leftJoinLoad<I extends Dream, DB extends I['DB'], TableName extends I['table'], Schema extends I['schema'], const Arr extends readonly unknown[]>(this: I, ...args: [...Arr, VariadicLeftJoinLoadArgs<DB, Schema, TableName, Arr>]): LeftJoinLoadBuilder<I>;
+    /**
+     * Returns true if the association specified has
+     * been loaded on this instance
+     *
+     * Since accessing associations that haven't been
+     * loaded/preloaded will raise an exception, `loaded`
+     * is useful for conditionally loading from the database
+     * in contexts where an association may not yet be loaded.
+     *
+     * ```ts
+     * user.loaded('posts')
+     * // false
+     *
+     * user = await user.load('posts').execute()
+     * user.loaded('posts')
+     * // true
+     * ```
+     *
+     * @param associationName - the association name you wish to check the loading of
+     * @returns A boolean
+     */
+    loaded<I extends Dream, TableName extends I['table'], Schema extends I['schema'], AssociationName extends NextPreloadArgumentType<Schema, TableName>>(this: I, associationName: AssociationName): boolean;
+    /**
+     * Reloads an instance, refreshing all it's attribute values
+     * to those in the database.
+     *
+     * NOTE: this does not refresh associations
+     *
+     * ```ts
+     * await user.reload()
+     * ```
+     *
+     * @returns void
+     */
+    reload<I extends Dream>(this: I): Promise<void>;
+    /**
+     * Serializes an instance. You can specify a serializer key,
+     * or else the default will be used
+     *
+     * ```ts
+     * // uses the default serializer provided in the model's `serializers` getter
+     * await user.serialize()
+     *
+     * // uses the summary serializer provided in the model's `serializers` getter
+     * await user.serialize({ serializerKey: 'summary' })
+     * ```
+     *
+     * @param args.casing - Which casing to use when serializing (camel or snake, default camel)
+     * @param args.serializerKey - The key to use when referencing the object returned by the `serializers` getter on the given model instance (defaults to "default")
+     * @returns A serialized representation of the model
+     */
+    serialize<I extends Dream>(this: I, { casing, serializerKey }?: DreamSerializeOptions<I>): {
+        [key: string]: any;
+    };
+    /**
+     * Takes the attributes passed in and sets their values,
+     * leveraging any custom setters defined for these attributes.
+     *
+     * NOTE:
+     * To bypass custom-defined setters, use `#setAttributes` instead.
+     *
+     * ```ts
+     *  const user = new User()
+     *  user.assignAttributes({ email: 'my@email', password: 'my password' })
+     * ```
+     */
+    assignAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>): Partial<import("./helpers/typeutils.js").MergeUnionOfRecordTypes<{
+        [x: string]: any;
+    } | Partial<{
+        [x: string]: any;
+    }>>>;
+    /**
+     * Takes the attributes passed in and sets their values internally,
+     * bypassing any custom setters defined for these attributes.
+     *
+     * NOTE:
+     * To leverage custom-defined setters, use `#assignAttributes` instead.
+     *
+     * ```ts
+     *  const user = new User()
+     *  user.setAttributes({ email: 'my@email', password: 'my password' })
+     * ```
+     */
+    setAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>): Partial<import("./helpers/typeutils.js").MergeUnionOfRecordTypes<{
+        [x: string]: any;
+    } | Partial<{
+        [x: string]: any;
+    }>>>;
+    private _setAttributes;
+    /**
+     * Saves the state of the current instance to the
+     * database. For new instances (that have not been
+     * persisted), `save` and `create` model hooks will be called.
+     * For instances that have already been persisted,
+     * the `save` and `update` model hooks will be called.
+     *
+     * Upon saving a new instance, the primary key, timestamp
+     * fields (if defined), and `type` (if STI) will be set on
+     * the model.
+     *
+     * Upon updating an instance, the update timestamp (if defined)
+     * will be updated on the model.
+     *
+     * ```ts
+     * const user = User.new({ email: 'how@yadoin' })
+     * user.name = 'fred'
+     * await user.save()
+     *
+     * user.email // 'how@yadoin'
+     * user.name // 'fred'
+     * user.id // 1
+     * user.createdAt // A DateTime object
+     * user.updatedAt // A DateTime object
+     *
+     * // If User were STI:
+     * user.type // 'User'
+     * ```
+     *
+     * @param opts.skipHooks - if true, will skip applying model hooks. Defaults to false
+     * @returns void
+     */
+    save<I extends Dream>(this: I, { skipHooks }?: {
+        skipHooks?: boolean;
+    }): Promise<void>;
+    /**
+     * Applies transaction to a new Query instance
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   const user = await User.txn(txn).create({ email: 'how@yadoin' })
+     *   await Pet.txn(txn).create({ user })
+     * })
+     * ```
+     *
+     * @param txn - A DreamTransaction instance (collected by calling `ApplicationModel.transaction`)
+     * @returns A Query scoped to this model with the transaction applied
+     */
+    txn<I extends Dream>(this: I, txn: DreamTransaction<Dream>): DreamInstanceTransactionBuilder<I>;
+    /**
+     * Applies all attribute changes passed to the Dream
+     * instance, leveraging any custom-defined setters,
+     * and then saves the Dream instance. Can be called
+     * on an unpersisted Dream instance.
+     *
+     * See {@link Dream.save | save} for details on
+     * the side effects of saving.
+     *
+     * NOTE:
+     * To bypass custom-defined setters, use {@link Dream.updateAttributes | updateAttributes} instead.
+     *
+     * ```ts
+     *  const user = await User.create({ email: 'saly@gmail.com' })
+     *  await user.update({ email: 'sally@gmail.com' })
+     * ```
+     *
+     * @param attributes - the attributes to set on the model
+     * @param opts.skipHooks - if true, will skip applying model hooks. Defaults to false
+     * @returns void
+     */
+    update<I extends Dream>(this: I, attributes: UpdateableProperties<I>, { skipHooks }?: {
+        skipHooks?: boolean;
+    }): Promise<void>;
+    /**
+     * Applies all attribute changes passed to the dream,
+     * bypassing any custom-defined setters,
+     * and then saves the dream instance. Does not bypass
+     * model hooks.
+     *
+     * See {@link Dream.save | save} for details on
+     * the side effects of saving.
+     *
+     * NOTE:
+     * To update the values without bypassing any custom-defined
+     * setters, use {@link Dream.update | update} instead.
+     *
+     * ```ts
+     * const user = await User.create({ email: 'saly@gmail.com' })
+     * await user.updateAttributes({ email: 'sally@gmail.com' })
+     * ```
+     *
+     * @param attributes - The attributes to update on this instance
+     * @param opts.skipHooks - if true, will skip applying model hooks. Defaults to false
+     * @returns - void
+     */
+    updateAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>, { skipHooks }?: {
+        skipHooks?: boolean;
+    }): Promise<void>;
+    /**
+     * Flags a dream model so that it does not
+     * actually destroy when in a destroy phase.
+     * This is usually used for a soft-delete
+     * pattern
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @Deco.BeforeDestroy()
+     *   public softDelete() {
+     *     await this.update({ deletedAt: DateTime.now() })
+     *     this.preventDeletion()
+     *   }
+     * }
+     * ```
+     *
+     * @returns void
+     */
+    preventDeletion(): void;
+    /**
+     * Flags a dream model so that it allows
+     * deletion once again.
+     *
+     * Undoes {@link Dream.(preventDeletion:instance) | preventDeletion}
+     *
+     * ```ts
+     * class User extends ApplicationModel {
+     *   @Deco.BeforeDestroy()
+     *   public async softDelete() {
+     *     await this.update({ deletedAt: DateTime.now() })
+     *     this.preventDeletion()
+     *   }
+     *
+     *   @Deco.BeforeDestroy()
+     *   public async undoSoftDelete() {
+     *     await this.update({ deletedAt: null })
+     *     this.unpreventDeletion()
+     *   }
+     * }
+     * ```
+     *
+     * @returns void
+     */
+    unpreventDeletion(): this;
+    private _preventDeletion;
+}
+export interface CreateOrFindByExtraOps<T extends typeof Dream> {
+    createWith?: WhereStatement<InstanceType<T>['DB'], InstanceType<T>['schema'], InstanceType<T>['table']> | UpdateablePropertiesForClass<T>;
+}