@rvoh/dream 0.29.1

package/dist/types/src/dream/internal/applyScopeBypassingSettingsToQuery.d.ts

@@ -0,0 +1,13 @@
+import Dream from '../../Dream.js';
+import Query from '../Query.js';
+import { AllDefaultScopeNames } from '../types.js';
+export default function applyScopeBypassingSettingsToQuery<DreamInstance extends Dream>(query: Query<DreamInstance>, { bypassAllDefaultScopes, defaultScopesToBypass, }: {
+    bypassAllDefaultScopes: boolean;
+    defaultScopesToBypass: AllDefaultScopeNames<DreamInstance>[];
+}): Query<DreamInstance, Readonly<{
+    joinedAssociations: Readonly<[]>;
+    rootTableName: DreamInstance["table"];
+    rootTableAlias: DreamInstance extends Dream ? DreamInstance["table"] : DreamInstance;
+    allowPreload: true;
+    allowLeftJoinPreload: true;
+}>>;

package/dist/types/src/dream/internal/associations/associationQuery.d.ts

@@ -0,0 +1,9 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../DreamTransaction.js';
+import Query from '../../Query.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../types.js';
+export default function associationQuery<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], AssociationQuery = Query<AssociationNameToDream<DreamInstance, AssociationName>>>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }: {
+    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+    bypassAllDefaultScopes: boolean;
+    defaultScopesToBypass: string[];
+}): AssociationQuery;

package/dist/types/src/dream/internal/associations/associationUpdateQuery.d.ts

@@ -0,0 +1,9 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../DreamTransaction.js';
+import Query from '../../Query.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../types.js';
+export default function associationUpdateQuery<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table'], AssociationQuery = Query<AssociationNameToDream<DreamInstance, AssociationName>>>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }: {
+    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+    bypassAllDefaultScopes: boolean;
+    defaultScopesToBypass: string[];
+}): AssociationQuery;

package/dist/types/src/dream/internal/associations/createAssociation.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../DreamTransaction.js';
+import { DreamAssociationNames, UpdateableAssociationProperties } from '../../types.js';
+export default function createAssociation<DreamInstance extends Dream, AssociationName extends DreamAssociationNames<DreamInstance>, PossibleArrayAssociationType = DreamInstance[AssociationName & keyof DreamInstance], AssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType & typeof Dream : PossibleArrayAssociationType & typeof Dream, RestrictedAssociationType extends AssociationType extends Dream ? AssociationType : never = AssociationType extends Dream ? AssociationType : never>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, opts?: UpdateableAssociationProperties<DreamInstance, RestrictedAssociationType>): Promise<NonNullable<AssociationType>>;

package/dist/types/src/dream/internal/associations/destroyAssociation.d.ts

@@ -0,0 +1,11 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../DreamTransaction.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../types.js';
+export default function destroyAssociation<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, reallyDestroy, skipHooks, }: {
+    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+    bypassAllDefaultScopes: boolean;
+    defaultScopesToBypass: string[];
+    cascade: boolean;
+    reallyDestroy: boolean;
+    skipHooks: boolean;
+}): Promise<number>;

package/dist/types/src/dream/internal/associations/undestroyAssociation.d.ts

@@ -0,0 +1,10 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../DreamTransaction.js';
+import { AssociationNameToDream, DreamAssociationNames, JoinOnStatements } from '../../types.js';
+export default function undestroyAssociation<DreamInstance extends Dream, DB extends DreamInstance['DB'], Schema extends DreamInstance['schema'], AssociationName extends DreamAssociationNames<DreamInstance>, AssociationDream extends AssociationNameToDream<DreamInstance, AssociationName>, AssociationTableName extends AssociationDream['table']>(dream: DreamInstance, txn: (DreamTransaction<Dream> | null) | undefined, associationName: AssociationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, cascade, skipHooks, }: {
+    joinOnStatements: JoinOnStatements<DB, Schema, AssociationTableName, null>;
+    bypassAllDefaultScopes: boolean;
+    defaultScopesToBypass: string[];
+    cascade: boolean;
+    skipHooks: boolean;
+}): Promise<number>;

package/dist/types/src/dream/internal/checkSingleValidation.d.ts

@@ -0,0 +1,3 @@
+import ValidationStatement from '../../decorators/validations/shared.js';
+import Dream from '../../Dream.js';
+export default function checkSingleValidation(dream: Dream, validation: ValidationStatement): any;

package/dist/types/src/dream/internal/destroyAssociatedRecords.d.ts

@@ -0,0 +1,10 @@
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+import { ReallyDestroyOptions } from './destroyDream.js';
+/**
+ * @internal
+ *
+ * Destroys all HasOne/HasMany associations on this
+ * dream that are marked as `dependent: 'destroy'`
+ */
+export default function destroyAssociatedRecords<I extends Dream>(dream: I, txn: DreamTransaction<I>, options: ReallyDestroyOptions<I>): Promise<void>;

package/dist/types/src/dream/internal/destroyDream.d.ts

@@ -0,0 +1,19 @@
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+import { DestroyOptions as OptionalDestroyOptions } from './destroyOptions.js';
+type DestroyOptions<DreamInstance extends Dream> = Required<OptionalDestroyOptions<DreamInstance>>;
+export interface ReallyDestroyOptions<DreamInstance extends Dream> extends DestroyOptions<DreamInstance> {
+    reallyDestroy: boolean;
+}
+/**
+ * @internal
+ *
+ * Destroys the Dream and any `dependent: 'destroy'` associations
+ * within a transaction. If a transaction is passed, it will be used.
+ * Otherwise, a new transaction will be created automatically.
+ * If any of the nested associations fails to destroy, then this
+ * record will also fail to destroy. If skipHooks is true, model hooks
+ * will be bypassed.
+ */
+export default function destroyDream<I extends Dream>(dream: I, txn: (DreamTransaction<I> | null) | undefined, options: ReallyDestroyOptions<I>): Promise<I>;
+export {};

package/dist/types/src/dream/internal/destroyOptions.d.ts

@@ -0,0 +1,46 @@
+import Dream from '../../Dream.js';
+import { AllDefaultScopeNames } from '../types.js';
+/**
+ * Options for destroying a Dream instance or its associations.
+ */
+export interface DestroyOptions<DreamInstance extends Dream> {
+    /**
+     * If true, bypasses all default scopes when destroying the instance.
+     * Defaults to false.
+     */
+    bypassAllDefaultScopes?: boolean;
+    /**
+     * An array of default scope names to bypass when destroying the instance.
+     * Defaults to an empty array.
+     */
+    defaultScopesToBypass?: AllDefaultScopeNames<DreamInstance>[];
+    /**
+     * If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true.
+     */
+    cascade?: boolean;
+    /**
+     * If true, skips applying model hooks during the destroy operation.
+     * Defaults to false.
+     */
+    skipHooks?: boolean;
+}
+export declare function destroyOptions<DreamInstance extends Dream>(options: DestroyOptions<DreamInstance>): {
+    reallyDestroy: boolean;
+    bypassAllDefaultScopes: boolean;
+    defaultScopesToBypass: Exclude<DreamInstance["globalSchema" & keyof DreamInstance]["allDefaultScopeNames" & keyof DreamInstance["globalSchema" & keyof DreamInstance]][number & keyof DreamInstance["globalSchema" & keyof DreamInstance]["allDefaultScopeNames" & keyof DreamInstance["globalSchema" & keyof DreamInstance]]], "dream:STI">[];
+    cascade: boolean;
+    skipHooks: boolean;
+};
+export declare function undestroyOptions<DreamInstance extends Dream>(options: DestroyOptions<DreamInstance>): {
+    defaultScopesToBypass: Exclude<DreamInstance["globalSchema" & keyof DreamInstance]["allDefaultScopeNames" & keyof DreamInstance["globalSchema" & keyof DreamInstance]][number & keyof DreamInstance["globalSchema" & keyof DreamInstance]["allDefaultScopeNames" & keyof DreamInstance["globalSchema" & keyof DreamInstance]]], "dream:STI">[];
+    bypassAllDefaultScopes: boolean;
+    cascade: boolean;
+    skipHooks: boolean;
+};
+export declare function reallyDestroyOptions<DreamInstance extends Dream>(options: DestroyOptions<DreamInstance>): {
+    reallyDestroy: boolean;
+    defaultScopesToBypass: Exclude<DreamInstance["globalSchema" & keyof DreamInstance]["allDefaultScopeNames" & keyof DreamInstance["globalSchema" & keyof DreamInstance]][number & keyof DreamInstance["globalSchema" & keyof DreamInstance]["allDefaultScopeNames" & keyof DreamInstance["globalSchema" & keyof DreamInstance]]], "dream:STI">[];
+    bypassAllDefaultScopes: boolean;
+    cascade: boolean;
+    skipHooks: boolean;
+};

package/dist/types/src/dream/internal/ensureSTITypeFieldIsSet.d.ts

@@ -0,0 +1,2 @@
+import Dream from '../../Dream.js';
+export default function ensureSTITypeFieldIsSet<T extends Dream>(dream: T): void;

package/dist/types/src/dream/internal/executeDatabaseQuery.d.ts

@@ -0,0 +1 @@
+export default function executeDatabaseQuery<Command extends 'execute' | 'executeTakeFirst' | 'executeTakeFirstOrThrow', ReturnType extends Command extends 'execute' ? any[] : Command extends 'executeTakeFirst' ? any : Command extends 'executeTakeFirstOrThrow' ? any : never>(kyselyQuery: any, command: Command): Promise<ReturnType>;

package/dist/types/src/dream/internal/extractAssociationMetadataFromAssociationName.d.ts

@@ -0,0 +1,4 @@
+export default function extractAssociationMetadataFromAssociationName(associationName: string): {
+    name: string;
+    alias: string;
+};

package/dist/types/src/dream/internal/orderByDirection.d.ts

@@ -0,0 +1,2 @@
+import { OrderDir } from '../types.js';
+export default function orderByDirection(dir: OrderDir | null): import("kysely").RawBuilder<unknown>;

package/dist/types/src/dream/internal/reload.d.ts

@@ -0,0 +1,3 @@
+import Dream from '../../Dream';
+import DreamTransaction from '../DreamTransaction.js';
+export default function reload<DreamInstance extends Dream>(dream: DreamInstance, txn?: DreamTransaction<Dream> | null): Promise<DreamInstance>;

package/dist/types/src/dream/internal/runHooksFor.d.ts

@@ -0,0 +1,8 @@
+import { HookStatement, HookType } from '../../decorators/hooks/shared.js';
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+export default function runHooksFor<T extends Dream>(key: HookType, dream: T, alreadyPersisted: boolean, beforeSaveChanges: Partial<Record<string, {
+    was: any;
+    now: any;
+}>> | null, txn?: DreamTransaction<any>): Promise<void>;
+export declare function runHook<T extends Dream>(statement: HookStatement, dream: T, txn?: DreamTransaction<any>): Promise<void>;

package/dist/types/src/dream/internal/runValidations.d.ts

@@ -0,0 +1,2 @@
+import Dream from '../../Dream.js';
+export default function runValidations(dream: Dream): void;

package/dist/types/src/dream/internal/safelyRunCommitHooks.d.ts

@@ -0,0 +1,7 @@
+import { CommitHookType } from '../../decorators/hooks/shared.js';
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+export default function safelyRunCommitHooks<DreamInstance extends Dream>(dream: DreamInstance, hookType: CommitHookType, alreadyPersisted: boolean, beforeSaveChanges: Partial<Record<string, {
+    was: any;
+    now: any;
+}>> | null, txn?: DreamTransaction<Dream> | null): Promise<void>;

package/dist/types/src/dream/internal/saveDream.d.ts

@@ -0,0 +1,5 @@
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+export default function saveDream<DreamInstance extends Dream>(dream: DreamInstance, txn?: DreamTransaction<Dream> | null, { skipHooks }?: {
+    skipHooks?: boolean;
+}): Promise<DreamInstance>;

package/dist/types/src/dream/internal/scopeHelpers.d.ts

@@ -0,0 +1,7 @@
+import Dream from '../../Dream.js';
+import { AllDefaultScopeNames } from '../types.js';
+export declare const DEFAULT_BYPASS_ALL_DEFAULT_SCOPES = false;
+export declare const DEFAULT_CASCADE = true;
+export declare const DEFAULT_DEFAULT_SCOPES_TO_BYPASS: never[];
+export declare const DEFAULT_SKIP_HOOKS = false;
+export declare function addSoftDeleteScopeToUserScopes<DreamInstance extends Dream>(userScopes?: AllDefaultScopeNames<DreamInstance>[]): AllDefaultScopeNames<DreamInstance>[];

package/dist/types/src/dream/internal/shouldBypassDefaultScope.d.ts

@@ -0,0 +1,4 @@
+export default function shouldBypassDefaultScope(scopeName: string, { bypassAllDefaultScopes, defaultScopesToBypass, }: {
+    bypassAllDefaultScopes?: boolean;
+    defaultScopesToBypass: string[];
+}): boolean;

package/dist/types/src/dream/internal/similarity/SimilarityBuilder.d.ts

@@ -0,0 +1,38 @@
+import { SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
+import ConnectedToDB from '../../../db/ConnectedToDB.js';
+import { DbConnectionType } from '../../../db/types.js';
+import { WhereStatement } from '../../../decorators/associations/shared.js';
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../DreamTransaction.js';
+import { JoinOnStatements, RelaxedJoinOnStatement, SimilarityStatement } from '../../types.js';
+export default class SimilarityBuilder<DreamInstance extends Dream, DB extends DreamInstance['DB'] = DreamInstance['DB'], Schema extends DreamInstance['schema'] = DreamInstance['schema']> extends ConnectedToDB<DreamInstance> {
+    readonly whereStatement: readonly WhereStatement<DB, Schema, any>[];
+    readonly whereNotStatement: readonly WhereStatement<DB, Schema, any>[];
+    readonly joinOnStatements: JoinOnStatements<DB, Schema, any, any>;
+    constructor(dreamInstance: DreamInstance, opts?: SimilarityBuilderOpts<DreamInstance>);
+    select<T extends SimilarityBuilder<DreamInstance>>(this: T, kyselyQuery: SelectQueryBuilder<DB, any, object>, { bypassOrder }?: {
+        bypassOrder?: boolean;
+    }): SelectQueryBuilder<DB, any, object>;
+    update<T extends SimilarityBuilder<DreamInstance>>(this: T, kyselyQuery: UpdateQueryBuilder<DreamInstance['DB'], any, any, any>): UpdateQueryBuilder<DreamInstance['DB'], any, any, any>;
+    get hasSimilarityClauses(): boolean;
+    whereStatementsWithSimilarityClauses(): SimilarityStatement[];
+    whereNotStatementsWithSimilarityClauses(): SimilarityStatement[];
+    joinOnStatementsWithSimilarityClauses(): SimilarityStatement[];
+    private recursiveJoinsOnFinder;
+    statementsWithSimilarityClauses(): SimilarityStatement[];
+    private addStatementToSelectQuery;
+    private addStatementToUpdateQuery;
+    private buildNestedSelectQuery;
+    private similarityStatementFilter;
+    private similaritySearchId;
+    private rankSQLAlias;
+}
+export interface SimilarityBuilderOpts<DreamInstance extends Dream, DB extends DreamInstance['DB'] = DreamInstance['DB'], Schema extends DreamInstance['schema'] = DreamInstance['schema']> {
+    where?: WhereStatement<DB, Schema, any>[];
+    whereNot?: WhereStatement<DB, Schema, any>[];
+    joinOnStatements?: RelaxedJoinOnStatement<DB, Schema>;
+    transaction?: DreamTransaction<Dream> | null | undefined;
+    connection?: DbConnectionType;
+}
+export declare const SIMILARITY_TYPES: readonly ["where", "on"];
+export type SimilarityStatementType = (typeof SIMILARITY_TYPES)[number];

package/dist/types/src/dream/internal/similarity/similaritySelectSql.d.ts

@@ -0,0 +1,11 @@
+import { ExpressionBuilder } from 'kysely';
+import Dream from '../../../Dream.js';
+import OpsStatement from '../../../ops/ops-statement.js';
+export default function similaritySelectSql<DreamInstance extends Dream>({ eb, tableName, columnName, opsStatement, schema, rankSQLAlias, }: {
+    eb: ExpressionBuilder<DreamInstance['DB'], string | (any extends keyof DreamInstance['DB'] ? any : never)>;
+    tableName: DreamInstance['table'];
+    columnName: string;
+    opsStatement: OpsStatement<any, any>;
+    schema: any;
+    rankSQLAlias: string;
+}): import("kysely").AliasedRawBuilder<string, string>;

package/dist/types/src/dream/internal/similarity/similarityWhereSql.d.ts

@@ -0,0 +1,10 @@
+import { ExpressionBuilder } from 'kysely';
+import Dream from '../../../Dream.js';
+import OpsStatement from '../../../ops/ops-statement.js';
+export default function similarityWhereSql<DreamInstance extends Dream>({ eb, tableName, columnName, opsStatement, schema, }: {
+    eb: ExpressionBuilder<any, any>;
+    tableName: DreamInstance['table'];
+    columnName: string;
+    opsStatement: OpsStatement<any, any>;
+    schema: any;
+}): any;

package/dist/types/src/dream/internal/softDeleteDream.d.ts

@@ -0,0 +1,3 @@
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+export default function softDeleteDream(dream: Dream, txn: DreamTransaction<any>): Promise<void>;

package/dist/types/src/dream/internal/sqlResultToDreamInstance.d.ts

@@ -0,0 +1,4 @@
+import { AssociationTableNames } from '../../db/reflections.js';
+import Dream from '../../Dream.js';
+export default function sqlResultToDreamInstance<DreamClass extends typeof Dream, DreamInstance extends InstanceType<DreamClass> = InstanceType<DreamClass>, Schema extends DreamInstance['schema'] = DreamInstance['schema'], DB extends DreamInstance['DB'] = DreamInstance['DB'], TableName extends AssociationTableNames<DB, Schema> & keyof DB = InstanceType<DreamClass>['table'], Table extends DB[TableName] = DB[TableName]>(dreamClass: DreamClass, sqlResult: any): InstanceType<DreamClass> | Dream;
+export declare function findExtendingDreamClass(dreamClass: typeof Dream, type: string): typeof Dream | undefined;

package/dist/types/src/dream/internal/undestroyDream.d.ts

@@ -0,0 +1,16 @@
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+import { DestroyOptions as OptionalDestroyOptions } from './destroyOptions.js';
+type UndestroyOptions<DreamInstance extends Dream> = Required<OptionalDestroyOptions<DreamInstance>>;
+/**
+ * @internal
+ *
+ * Destroys the Dream and any `dependent: 'destroy'` associations
+ * within a transaction. If a transaction is passed, it will be used.
+ * Otherwise, a new transaction will be created automatically.
+ * If any of the nested associations fails to destroy, then this
+ * record will also fail to destroy. If skipHooks is true, model hooks
+ * will be bypassed.
+ */
+export default function undestroyDream<I extends Dream>(dream: I, txn: (DreamTransaction<I> | null) | undefined, options: UndestroyOptions<I>): Promise<I>;
+export {};

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

@@ -0,0 +1,184 @@
+import { ColumnType, Updateable } from 'kysely';
+import { DateTime } from 'luxon';
+import { AssociationTableNames } from '../db/reflections.js';
+import { BelongsToStatement } from '../decorators/associations/BelongsTo.js';
+import { HasManyStatement } from '../decorators/associations/HasMany.js';
+import { HasOneStatement } from '../decorators/associations/HasOne.js';
+import { AssociatedModelParam, OnStatementForAssociation, WhereStatement } from '../decorators/associations/shared.js';
+import { STI_SCOPE_NAME } from '../decorators/STI.js';
+import Dream from '../Dream.js';
+import CalendarDate from '../helpers/CalendarDate.js';
+import { Camelized } from '../helpers/stringCasing.js';
+import { FilterInterface, Inc, ReadonlyTail } from '../helpers/typeutils.js';
+import OpsStatement from '../ops/ops-statement.js';
+import DreamSerializer from '../serializer/index.js';
+import { FindEachOpts } from './Query.js';
+export declare const primaryKeyTypes: readonly ["bigserial", "bigint", "uuid", "integer"];
+export type PrimaryKeyType = (typeof primaryKeyTypes)[number];
+export type IdType = string | number | bigint;
+export type Timestamp = ColumnType<DateTime | CalendarDate>;
+type MAX_VARIADIC_DEPTH = 25;
+declare class RequiredAttribute {
+    constructor();
+}
+declare class PassthroughAttribute {
+    constructor();
+}
+export declare const DreamConst: {
+    passthrough: typeof PassthroughAttribute;
+    required: typeof RequiredAttribute;
+};
+export declare const TRIGRAM_OPERATORS: readonly ["%", "<%", "<<%"];
+export type TrigramOperator = (typeof TRIGRAM_OPERATORS)[number];
+export type OrderDir = 'asc' | 'desc';
+export interface SortableOptions<T extends Dream> {
+    scope?: keyof DreamBelongsToAssociationMetadata<T> | DreamColumnNames<T> | (keyof DreamBelongsToAssociationMetadata<T> | DreamColumnNames<T>)[];
+}
+export type PrimaryKeyForFind<I extends Dream, Schema extends I['schema'] = I['schema'], TableName extends keyof Schema = I['table'] & keyof Schema> = Schema[TableName]['columns'][I['primaryKey'] & keyof Schema[TableName]['columns']]['coercedType'] | string | null | undefined;
+export type DreamColumnNames<DreamInstance extends Dream, DB = DreamInstance['DB'], TableName extends keyof DB = DreamInstance['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName]> = keyof Table & string;
+export type DreamParamSafeColumnNames<DreamInstance extends Dream, BelongsToForeignKeys = DreamBelongsToForeignKeys<DreamInstance>, Schema = DreamInstance['schema'], TableSchema = Schema[DreamInstance['table'] & keyof Schema]> = Exclude<DreamColumnNames<DreamInstance>, BelongsToForeignKeys | DreamVirtualColumns<DreamInstance> | TableSchema['primaryKey' & keyof TableSchema] | TableSchema['createdAtField' & keyof TableSchema] | TableSchema['updatedAtField' & keyof TableSchema] | TableSchema['deletedAtField' & keyof TableSchema]>;
+export type DreamBelongsToForeignKeys<DreamInstance extends Dream, Schema = DreamInstance['schema'], TableSchema = Schema[DreamInstance['table'] & keyof Schema], AssociationSchema = TableSchema['associations' & keyof TableSchema], BelongsToAssociationSchema = AssociationSchema[keyof DreamBelongsToAssociationMetadata<DreamInstance> & keyof AssociationSchema], BelongsToForeignKeys = Exclude<BelongsToAssociationSchema['foreignKey' & keyof BelongsToAssociationSchema], null>> = BelongsToForeignKeys;
+export type DreamClassColumnNames<DreamClass extends typeof Dream, DreamInstance extends InstanceType<DreamClass> = InstanceType<DreamClass>, DB = DreamInstance['DB'], TableName extends keyof DB = DreamInstance['table'] & keyof DB, Table extends DB[keyof DB] = DB[TableName]> = keyof Table & string;
+export type TableColumnNames<DB, TableName extends keyof DB, Table extends DB[keyof DB] = DB[TableName]> = keyof Table & string;
+export type DreamColumn<DreamInstance extends Dream, Column extends keyof Attrs, Attrs = DreamAttributes<DreamInstance>> = Attrs[Column & keyof Attrs];
+export type DreamClassColumn<DreamClass extends typeof Dream, Column extends keyof DreamAttributes<DreamInstance>, DreamInstance extends InstanceType<DreamClass> = InstanceType<DreamClass>> = DreamColumn<DreamInstance, Column>;
+export type AssociationNameToDream<DreamInstance extends Dream, AssociationName extends DreamAssociationNames<DreamInstance>, PossibleArrayAssociationType = DreamInstance[AssociationName & keyof DreamInstance], AssociationType extends Dream = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType extends Dream ? ElementType : never : PossibleArrayAssociationType extends Dream ? PossibleArrayAssociationType : never> = AssociationType;
+export type DreamAssociationMetadata<DreamInstance extends Dream, Schema = DreamInstance['schema'], AssociationMetadata = Schema[DreamInstance['table'] & keyof Schema]['associations' & keyof Schema[DreamInstance['table'] & keyof Schema]]> = AssociationMetadata;
+export type DreamAssociationNamesWithoutRequiredOnClauses<DreamInstance extends Dream, SchemaAssociations = DreamAssociationMetadata<DreamInstance>, SchemaTypeInterface = {
+    [K in keyof SchemaAssociations]: SchemaAssociations[K]['requiredOnClauses' & keyof SchemaAssociations[K]];
+}, RequiredOnClauses = keyof FilterInterface<SchemaTypeInterface, null> & string> = RequiredOnClauses;
+export type DreamAssociationNames<DreamInstance extends Dream, SchemaAssociations = DreamAssociationMetadata<DreamInstance>> = keyof SchemaAssociations;
+type VirtualColumnsForTable<Schema, TableName extends keyof Schema, TableSchema = Schema[TableName]> = TableSchema['virtualColumns' & keyof TableSchema];
+export type DreamVirtualColumns<DreamInstance extends Dream, Schema = DreamInstance['schema']> = VirtualColumnsForTable<Schema, DreamInstance['table'] & keyof Schema>;
+export type DreamBelongsToAssociationMetadata<DreamInstance extends Dream, SchemaAssociations = DreamAssociationMetadata<DreamInstance>, SchemaTypeInterface = {
+    [K in keyof SchemaAssociations]: SchemaAssociations[K]['type' & keyof SchemaAssociations[K]];
+}, BelongsToKeys = keyof FilterInterface<SchemaTypeInterface, 'BelongsTo'> & string, TypeRecord = {
+    [K in BelongsToKeys & string]: SchemaAssociations[K & keyof SchemaAssociations];
+}> = TypeRecord;
+export type DreamAttributes<DreamInstance extends Dream, Schema = DreamInstance['schema'], SchemaColumns = Schema[DreamInstance['table'] & keyof Schema]['columns' & keyof Schema[DreamInstance['table'] & keyof Schema]]> = {
+    -readonly [K in keyof SchemaColumns]: SchemaColumns[K]['coercedType' & keyof SchemaColumns[K]];
+};
+export type DreamAttributeDbTypes<DreamInstance extends Dream, Schema = DreamInstance['schema'], SchemaColumns = Schema[DreamInstance['table'] & keyof Schema]['columns' & keyof Schema[DreamInstance['table'] & keyof Schema]]> = {
+    -readonly [K in keyof SchemaColumns]: SchemaColumns[K]['dbType' & keyof SchemaColumns[K]];
+};
+export type DreamParamSafeAttributes<DreamInstance extends Dream> = {
+    [K in keyof DreamAttributes<DreamInstance> & DreamParamSafeColumnNames<DreamInstance>]: DreamAttributes<DreamInstance>[K];
+};
+export type DreamTableSchema<DreamInstance extends Dream> = Updateable<DreamInstance['DB'][DreamInstance['table']]>;
+export type TableColumnType<Schema, TableName, Column, TableSchema extends Schema[TableName & keyof Schema] = Schema[TableName & keyof Schema], TableColumns extends TableSchema['columns' & keyof TableSchema] = TableSchema['columns' & keyof TableSchema], TableColumnMetadata extends TableColumns[Column & keyof TableColumns] = TableColumns[Column & keyof TableColumns], ColumnType extends TableColumnMetadata['coercedType' & keyof TableColumnMetadata] = TableColumnMetadata['coercedType' & keyof TableColumnMetadata]> = ColumnType;
+export type TableColumnEnumTypeArray<Schema, TableName, Column, TableSchema extends Schema[TableName & keyof Schema] = Schema[TableName & keyof Schema], TableColumns extends TableSchema['columns' & keyof TableSchema] = TableSchema['columns' & keyof TableSchema], TableColumnMetadata extends TableColumns[Column & keyof TableColumns] = TableColumns[Column & keyof TableColumns], EnumTypeCandidate = TableColumnMetadata['enumArrayType' & keyof TableColumnMetadata], EnumTypeArray extends string[] | null = EnumTypeCandidate extends null ? null : EnumTypeCandidate extends undefined ? null : EnumTypeCandidate extends string[] ? EnumTypeCandidate : never> = EnumTypeArray;
+type AssociationMetadataForTable<Schema, TableName extends keyof Schema> = Schema[TableName]['associations' & keyof Schema[TableName]];
+type AssociationNamesForTable<Schema, TableName extends keyof Schema> = keyof AssociationMetadataForTable<Schema, TableName> | AliasedSchemaAssociation<Schema, TableName>;
+type MetadataForAssociation<Schema, TableName extends keyof Schema, AssociationName, AssociationMetadata = AssociationMetadataForTable<Schema, TableName>> = AssociationMetadata[AssociationName & keyof AssociationMetadata];
+export type AssociationTableName<Schema, TableName extends keyof Schema, AssociationName, AssociationData = MetadataForAssociation<Schema, TableName, AssociationName>> = (AssociationData['tables' & keyof AssociationData] & any[])[0] & keyof Schema;
+export type JoinOnStatements<DB, Schema, TableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation> = RequiredOnClauseKeysForThisAssociation extends null ? {
+    on?: WhereStatement<DB, Schema, TableName>;
+    notOn?: WhereStatement<DB, Schema, TableName>;
+    onAny?: WhereStatement<DB, Schema, TableName>[];
+} : RequiredOnClauseKeysForThisAssociation extends string[] ? {
+    on: OnStatementForAssociation<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>;
+    notOn?: WhereStatement<DB, Schema, TableName>;
+    onAny?: WhereStatement<DB, Schema, TableName>[];
+} : never;
+export type UpdateablePropertiesForClass<DreamClass extends typeof Dream, TableName extends AssociationTableNames<InstanceType<DreamClass>['DB'], InstanceType<DreamClass>['schema']> & InstanceType<DreamClass>['table'] = InstanceType<DreamClass>['table'], VirtualColumns = DreamVirtualColumns<InstanceType<DreamClass>>> = Partial<Updateable<InstanceType<DreamClass>['DB'][TableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object) & (AssociatedModelParam<InstanceType<DreamClass>> extends never ? object : AssociatedModelParam<InstanceType<DreamClass>>)>;
+export type UpdateableAssociationProperties<DreamInstance extends Dream, AssociationClass extends Dream, Schema = DreamInstance['schema'], AssociationTableName extends AssociationTableNames<DreamInstance['DB'], DreamInstance['schema']> & keyof DreamInstance['DB'] = AssociationClass['table'], VirtualColumns = VirtualColumnsForTable<Schema, AssociationTableName>> = Partial<Updateable<DreamInstance['DB'][AssociationTableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object) & (AssociatedModelParam<AssociationClass> extends never ? object : AssociatedModelParam<AssociationClass>)>;
+export type AttributeKeys<I extends Dream, TableName extends AssociationTableNames<I['DB'], I['schema']> & I['table'] = I['table'], VirtualColumns = DreamVirtualColumns<I>> = keyof (Updateable<I['DB'][TableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object));
+export type UpdateableProperties<I extends Dream, TableName extends AssociationTableNames<I['DB'], I['schema']> & I['table'] = I['table'], VirtualColumns = DreamVirtualColumns<I>> = Partial<Updateable<I['DB'][TableName]> & (VirtualColumns extends readonly any[] ? Record<VirtualColumns[number], any> : object) & (AssociatedModelParam<I> extends never ? object : AssociatedModelParam<I>)>;
+export type TableNameForGlobalModelName<I extends Dream, GMN extends keyof GlobalModelNameTableMap<I>> = GlobalModelNameTableMap<I>[GMN];
+export type GlobalModelNames<I extends Dream> = keyof GlobalModelNameTableMap<I>;
+export type GlobalModelNameTableMap<I extends Dream, GlobalSchema = I['globalSchema'], GlobalNames = GlobalSchema['globalNames' & keyof GlobalSchema]> = GlobalNames['models' & keyof GlobalNames];
+export type GlobalSerializerName<I extends Dream> = GlobalSerializerNames<I>[number];
+type GlobalSerializerNames<I extends Dream, GlobalSchema = I['globalSchema'], GlobalNames = GlobalSchema['globalNames' & keyof GlobalSchema]> = GlobalNames['serializers' & keyof GlobalNames];
+export type DreamSerializers<I extends Dream> = Record<'default', GlobalSerializerName<I>> & Record<string, GlobalSerializerName<I>>;
+export type DreamConstructorType<T extends Dream> = (new (...arguments_: any[]) => T) & typeof Dream;
+export type ViewModel = {
+    serializers: Record<string, string>;
+};
+export type ViewModelClass = abstract new (...args: any) => ViewModel;
+export type SerializableDreamOrViewModel = ViewModel;
+export type SerializableDreamClassOrViewModelClass = abstract new (...args: any) => SerializableDreamOrViewModel;
+export type DreamSerializerCallback = () => typeof DreamSerializer;
+export type SerializableClassOrSerializerCallback = SerializableDreamClassOrViewModelClass | DreamSerializerCallback;
+export type SerializableClassOrClasses = DreamSerializerCallback | SerializableDreamClassOrViewModelClass | SerializableDreamClassOrViewModelClass[];
+export type NextPreloadArgumentType<Schema, PreviousTableNames, PreviousSchemaAssociations = PreviousTableNames extends undefined ? undefined : Schema[PreviousTableNames & keyof Schema]['associations' & keyof Schema[PreviousTableNames & keyof Schema]]> = PreviousTableNames extends undefined ? undefined : (keyof PreviousSchemaAssociations & string) | (keyof PreviousSchemaAssociations & string)[];
+export type PreloadArgumentTypeAssociatedTableNames<Schema, PreviousTableNames, ArgumentType, PreviousSchemaAssociations = PreviousTableNames extends undefined ? undefined : Schema[PreviousTableNames & keyof Schema]> = ArgumentType extends string[] ? undefined : (PreviousSchemaAssociations[ArgumentType & (keyof PreviousSchemaAssociations & string)] & string[])[number];
+export type AssociationNameToDreamClassMap = Record<string, typeof Dream>;
+export type AssociationNameToAssociationMap = Record<string, BelongsToStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | HasManyStatement<any, any, any, any>>;
+export type AssociationNameToAssociationDataAndDreamClassMap = Record<string, {
+    dreamClass: typeof Dream;
+    association: BelongsToStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | HasManyStatement<any, any, any, any>;
+}>;
+type IdToDreamMap = Map<string | number, Dream>;
+export type AliasToDreamIdMap = Record<string, IdToDreamMap>;
+export type RelaxedPreloadStatement<Depth extends number = 0> = RelaxedJoinStatement<Depth>;
+export type RelaxedJoinStatement<Depth extends number = 0> = Depth extends 7 ? object : Record<string, RelaxedJoinStatement<Inc<Depth>>>;
+export type RelaxedPreloadOnStatement<DB, Schema, Depth extends number = 0> = Depth extends 7 ? object : {
+    [key: string]: RelaxedPreloadOnStatement<DB, Schema, Inc<Depth>> | JoinOnStatements<any, any, any, any> | FakeOnClauseValue | object;
+};
+export type RelaxedJoinOnStatement<DB, Schema, Depth extends number = 0> = Depth extends 7 ? object : {
+    [key: string]: RelaxedJoinOnStatement<DB, Schema, Inc<Depth>> | JoinOnStatements<any, any, any, any> | FakeOnClauseValue | object;
+};
+type FakeOnClauseValue = string | string[] | number | number[] | null;
+export type TableOrAssociationName<Schema> = (keyof Schema & string) | (keyof Schema[keyof Schema] & string);
+export type SqlCommandType = 'select' | 'update' | 'delete' | 'insert';
+export type DreamSerializeOptions<T> = {
+    serializerKey?: DreamSerializerKey<T>;
+    casing?: 'camel' | 'snake' | null;
+};
+export type DreamOrViewModelSerializerKey<T> = T extends Dream ? DreamSerializerKey<T> : ViewModelSerializerKey<T>;
+export type DreamSerializerKey<T, U = T extends (infer R)[] ? R : T, Table = U['table' & keyof U] extends string ? U['table' & keyof U] : never, Schema = U['schema' & keyof U] extends object ? U['schema' & keyof U] : never, TableSchema = Table extends never ? never : Schema extends never ? never : Schema[Table & keyof Schema], SerializerKeys = TableSchema extends never ? never : TableSchema['serializerKeys' & keyof TableSchema] & (string[] | Readonly<string[]>), SerializerKey = SerializerKeys extends string[] | Readonly<string[]> ? SerializerKeys[number] : never> = SerializerKey;
+export type ViewModelSerializerKey<T, U = T extends (infer R)[] ? R : T, SerializerType = U extends null ? never : U['serializers' & keyof U] extends object ? keyof U['serializers' & keyof U] : never> = SerializerType;
+export interface SimilarityStatement {
+    tableName: string;
+    tableAlias: string;
+    columnName: string;
+    opsStatement: OpsStatement<any, any>;
+}
+export type PassthroughColumnNames<DreamConf, GlobalSchema = DreamConf['globalSchema' & keyof DreamConf], PassthroughColumns = GlobalSchema['passthroughColumns' & keyof GlobalSchema]> = PassthroughColumns;
+export type DefaultScopeName<DreamInstance extends Dream, Schema = DreamInstance['schema'], TableName extends keyof Schema = DreamInstance['table'] & keyof Schema> = DefaultScopeNameForTable<Schema, TableName>;
+export type DefaultScopeNameForTable<Schema, TableName extends keyof Schema, SchemaTable = Schema[TableName], SchemaDefaultScopes extends string[] = SchemaTable['scopes' & keyof SchemaTable]['default' & keyof SchemaTable['scopes' & keyof SchemaTable]] & string[]> = Exclude<SchemaDefaultScopes[number], typeof STI_SCOPE_NAME>;
+export type AllDefaultScopeNames<DreamConf, GlobalSchema = DreamConf['globalSchema' & keyof DreamConf], AllNames = GlobalSchema['allDefaultScopeNames' & keyof GlobalSchema]> = Exclude<AllNames[number & keyof AllNames], typeof STI_SCOPE_NAME>;
+export type NamedScopeName<DreamInstance extends Dream, Schema = DreamInstance['schema'], SchemaTable = Schema[DreamInstance['table'] & keyof Schema], SchemaNamedScopes extends string[] = SchemaTable['scopes' & keyof SchemaTable]['named' & keyof SchemaTable['scopes' & keyof SchemaTable]] & string[]> = SchemaNamedScopes[number];
+export type DefaultOrNamedScopeName<DreamInstance extends Dream> = DefaultScopeName<DreamInstance> | NamedScopeName<DreamInstance>;
+export type PluckEachArgs<ColumnNames extends unknown[], CbArgTypes extends unknown[]> = [...fields: ColumnNames] | [...fields: ColumnNames, callback: (...values: CbArgTypes) => void | Promise<void>] | [...fields: ColumnNames, callback: (...values: CbArgTypes) => void | Promise<void>, opts: FindEachOpts];
+type VALID = 'valid';
+type INVALID = 'invalid';
+type IS_ASSOCIATION_ALIAS = 'association_alias';
+type IS_ASSOCIATION_NAME = 'association_name';
+type IS_NOT_ASSOCIATION_NAME = 'not_association_name';
+type RecursionTypes = 'load' | 'leftJoinLoad' | 'join';
+export type VariadicLoadArgs<DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNextArgValues = (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName>> = VariadicCheckThenRecurse<DB, Schema, ConcreteTableName, ConcreteArgs, 'load', ConcreteTableName, 0, null, never, AllowedNextArgValues | Readonly<AllowedNextArgValues[]>>;
+export type VariadicLeftJoinLoadArgs<DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNextArgValues = (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName>> = VariadicCheckThenRecurse<DB, Schema, ConcreteTableName, ConcreteArgs, 'leftJoinLoad', Camelized<ConcreteTableName>, 0, null, never, AllowedNextArgValues | Readonly<AllowedNextArgValues[]>>;
+export type VariadicJoinsArgs<DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNextArgValues = (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName>> = VariadicCheckThenRecurse<DB, Schema, ConcreteTableName, ConcreteArgs, 'join', Camelized<ConcreteTableName>, 0, null, never, AllowedNextArgValues>;
+export type RequiredOnClauseKeys<Schema, TableName, AssociationName, Associations = TableName extends null ? null : TableName extends keyof Schema & string ? Schema[TableName]['associations' & keyof Schema[TableName]] : null, Association = Associations extends null ? null : AssociationName extends keyof Associations ? Associations[AssociationName] : null, RequiredOnClauses = Association extends null ? null : Association['requiredOnClauses' & keyof Association] & (string[] | null)> = RequiredOnClauses;
+type VariadicCheckThenRecurse<DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, AssociationNamesOrOnClause, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], NthArgument extends VALID | INVALID = ConcreteArgs['length'] extends 0 ? VALID : ConcreteArgs[0] extends keyof SchemaAssociations & string ? VALID : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? VALID : ConcreteArgs[0] extends JoinOnStatements<DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? VALID : INVALID> = NthArgument extends INVALID ? `invalid where clause in argument ${Inc<Depth>}` : ConcreteArgs['length'] extends 0 ? AssociationNamesOrOnClause : VariadicRecurse<DB, Schema, ConcreteTableName, ConcreteArgs, RecursionType, UsedNamespaces, Depth, PreviousConcreteTableName, ConcreteAssociationName>;
+export type AliasedSchemaAssociation<Schema, ConcreteTableName extends keyof Schema, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]]> = `${keyof SchemaAssociations & string} as ${string}`;
+type VariadicRecurse<DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], ConcreteNthArg extends (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName> | null = ConcreteArgs[0] extends undefined ? null : ConcreteArgs[0] extends null ? null : ConcreteArgs[0] extends keyof SchemaAssociations & string ? ConcreteArgs[0] & keyof SchemaAssociations & string : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? ConcreteArgs[0] & AliasedSchemaAssociation<Schema, ConcreteTableName> : null, NextUsedNamespaces = ConcreteArgs[0] extends undefined ? never : ConcreteArgs[0] extends null ? never : ConcreteArgs[0] extends keyof SchemaAssociations & string ? UsedNamespaces | ConcreteNthArg : UsedNamespaces, CurrentArgumentType extends IS_ASSOCIATION_NAME | IS_ASSOCIATION_ALIAS | IS_NOT_ASSOCIATION_NAME = ConcreteNthArg extends null ? IS_NOT_ASSOCIATION_NAME : ConcreteNthArg extends keyof SchemaAssociations & string ? IS_ASSOCIATION_NAME : ConcreteNthArg extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? IS_ASSOCIATION_ALIAS : IS_NOT_ASSOCIATION_NAME, NextPreviousConcreteTableName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteTableName : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteTableName : PreviousConcreteTableName, NextUnaliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${infer AssocName extends string} as ${string}` ? AssocName & keyof SchemaAssociations & string : never : never, NextAliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${string} as ${infer AssocAlias extends string}` ? AssocAlias & string : ConcreteAssociationName : ConcreteAssociationName, NextTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = CurrentArgumentType extends IS_ASSOCIATION_NAME ? AssociationTableName<Schema, ConcreteTableName, NextUnaliasedAssociationName> : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? AssociationTableName<Schema, ConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName & AssociationTableNames<DB, Schema> & keyof DB, AllowedNextArgValues = RecursionType extends 'load' ? AllowedNextArgValuesForLoad<DB, Schema, NextTableName, RequiredOnClauseKeys<Schema, ConcreteTableName, NextAliasedAssociationName>> : RecursionType extends 'leftJoinLoad' ? AllowedNextArgValuesForLeftJoinLoad<DB, Schema, NextTableName, RequiredOnClauseKeys<Schema, ConcreteTableName, NextAliasedAssociationName>, NextUsedNamespaces> : RecursionType extends 'join' ? AllowedNextArgValuesForJoin<DB, Schema, NextTableName, RequiredOnClauseKeys<Schema, ConcreteTableName, NextAliasedAssociationName>, NextUsedNamespaces> : never> = Depth extends MAX_VARIADIC_DEPTH ? never : VariadicCheckThenRecurse<DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, RecursionType, NextUsedNamespaces, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, AllowedNextArgValues>;
+type AllowedNextArgValuesForLoad<DB, Schema, TableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation> = AssociationNamesForTable<Schema, TableName> | AssociationNamesForTable<Schema, TableName>[] | JoinOnStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>;
+type AllowedNextArgValuesForLeftJoinLoad<DB, Schema, TableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, UsedNamespaces> = Exclude<AssociationNamesForTable<Schema, TableName>, UsedNamespaces> | Exclude<AssociationNamesForTable<Schema, TableName>, UsedNamespaces>[] | JoinOnStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>;
+type AllowedNextArgValuesForJoin<DB, Schema, TableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, UsedNamespaces> = Exclude<AssociationNamesForTable<Schema, TableName>, UsedNamespaces> | JoinOnStatements<DB, Schema, TableName, RequiredOnClauseKeysForThisAssociation>;
+export interface JoinedAssociation {
+    table: string;
+    alias: string;
+}
+export type QueryTypeOptions = {
+    joinedAssociations: Readonly<JoinedAssociation[]>;
+    rootTableName: string;
+    rootTableAlias: string;
+    allowPreload: boolean;
+    allowLeftJoinPreload: boolean;
+};
+export type JoinedAssociationsTypeFromAssociations<DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], Depth extends number = 0, PreviousConcreteTableName = ConcreteTableName, ConcreteAssociationName = never, JoinedAssociationsType extends Readonly<JoinedAssociation[]> = Readonly<[]>, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], ConcreteNthArg extends (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName> | Readonly<unknown[]> | null = ConcreteArgs[0] extends undefined ? null : ConcreteArgs[0] extends null ? null : ConcreteArgs[0] extends keyof SchemaAssociations & string ? ConcreteArgs[0] & keyof SchemaAssociations & string : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? ConcreteArgs[0] & AliasedSchemaAssociation<Schema, ConcreteTableName> : ConcreteArgs[0] extends Readonly<unknown[]> ? Readonly<unknown[]> : null, CurrentArgumentType extends IS_ASSOCIATION_NAME | IS_ASSOCIATION_ALIAS | IS_NOT_ASSOCIATION_NAME = ConcreteNthArg extends null ? IS_NOT_ASSOCIATION_NAME : ConcreteNthArg extends Readonly<unknown[]> ? IS_NOT_ASSOCIATION_NAME : ConcreteNthArg extends keyof SchemaAssociations & string ? IS_ASSOCIATION_NAME : ConcreteNthArg extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? IS_ASSOCIATION_ALIAS : IS_NOT_ASSOCIATION_NAME, NextPreviousConcreteTableName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteTableName : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteTableName : PreviousConcreteTableName, NextUnaliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${infer AssocName extends string} as ${string}` ? AssocName & keyof SchemaAssociations : never : never, NextAliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${string} as ${infer Alias extends string}` ? Alias : ConcreteAssociationName : ConcreteAssociationName, NextTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = CurrentArgumentType extends IS_ASSOCIATION_NAME ? AssociationTableName<Schema, ConcreteTableName, NextUnaliasedAssociationName> : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? AssociationTableName<Schema, ConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName & AssociationTableNames<DB, Schema> & keyof DB> = ConcreteArgs['length'] extends 0 ? JoinedAssociationsType : Depth extends MAX_VARIADIC_DEPTH ? never : ConcreteArgs['length'] extends 1 ? ConcreteNthArg extends Readonly<unknown[]> ? JoinedAssociationsType : JoinedAssociationsTypeFromAssociations<DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, CurrentArgumentType extends IS_NOT_ASSOCIATION_NAME ? JoinedAssociationsType : Readonly<[
+    ...JoinedAssociationsType,
+    {
+        table: NextTableName & string;
+        alias: NextAliasedAssociationName & string;
+    }
+]>> : JoinedAssociationsTypeFromAssociations<DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, CurrentArgumentType extends IS_NOT_ASSOCIATION_NAME ? JoinedAssociationsType : Readonly<[
+    ...JoinedAssociationsType,
+    {
+        table: NextTableName & string;
+        alias: NextAliasedAssociationName & string;
+    }
+]>>;
+export {};

package/dist/types/src/dream-application/cache.d.ts

@@ -0,0 +1,3 @@
+import DreamApplication from './index.js';
+export declare function cacheDreamApplication(dreamconf: DreamApplication): void;
+export declare function getCachedDreamApplicationOrFail(): DreamApplication;

package/dist/types/src/dream-application/helpers/DreamImporter.d.ts

@@ -0,0 +1,8 @@
+import Dream from '../../Dream';
+import DreamSerializer from '../../serializer';
+export default class DreamImporter {
+    static ls(dir: string): Promise<string[]>;
+    static importDreams(pathToModels: string, importCb: (path: string) => Promise<any>): Promise<[string, typeof Dream][]>;
+    static importSerializers(pathToSerializers: string, importCb: (path: string) => Promise<any>): Promise<[string, Record<string, typeof DreamSerializer>][]>;
+    static importServices(pathToServices: string, importCb: (path: string) => Promise<any>): Promise<[string, any][]>;
+}

package/dist/types/src/dream-application/helpers/globalModelKeyFromPath.d.ts

@@ -0,0 +1 @@
+export default function (filepath: string, dirPath: string): string;

package/dist/types/src/dream-application/helpers/globalSerializerKeyFromPath.d.ts

@@ -0,0 +1 @@
+export default function (filepath: string, dirPath: string, exportKey?: string): string;

package/dist/types/src/dream-application/helpers/globalServiceKeyFromPath.d.ts

@@ -0,0 +1 @@
+export default function (filepath: string, dirPath: string): string;

package/dist/types/src/dream-application/helpers/importers/importModels.d.ts

@@ -0,0 +1,5 @@
+import Dream from '../../../Dream.js';
+export default function importModels(modelsPath: string, modelImportCb: (path: string) => Promise<any>): Promise<Record<string, typeof Dream>>;
+export declare function setCachedModels(models: Record<string, typeof Dream>): void;
+export declare function getModelsOrFail(): Record<string, typeof Dream>;
+export declare function getModelsOrBlank(): Record<string, typeof Dream>;

package/dist/types/src/dream-application/helpers/importers/importSerializers.d.ts

@@ -0,0 +1,5 @@
+import DreamSerializer from '../../../serializer/index.js';
+export default function importSerializers(serializersPath: string, serializerImportCb: (path: string) => Promise<any>): Promise<Record<string, typeof DreamSerializer>>;
+export declare function setCachedSerializers(serializers: Record<string, typeof DreamSerializer>): void;
+export declare function getSerializersOrFail(): Record<string, typeof DreamSerializer>;
+export declare function getSerializersOrBlank(): Record<string, typeof DreamSerializer>;

package/dist/types/src/dream-application/helpers/importers/importServices.d.ts

@@ -0,0 +1,4 @@
+export default function importServices(servicesPath: string, serviceImportCb: (path: string) => Promise<any>): Promise<Record<string, any>>;
+export declare function setCachedServices(services: Record<string, any>): void;
+export declare function getServicesOrFail(): Record<string, any>;
+export declare function getServicesOrBlank(): Record<string, any>;

package/dist/types/src/dream-application/helpers/lookupClassByGlobalName.d.ts

@@ -0,0 +1 @@
+export default function lookupClassByGlobalName(globalName: string): any;

package/dist/types/src/dream-application/helpers/lookupModelByGlobalName.d.ts

@@ -0,0 +1 @@
+export default function lookupModelByGlobalName(globalName: string): any;

package/dist/types/src/dream-application/helpers/lookupModelByGlobalNameOrNames.d.ts

@@ -0,0 +1 @@
+export default function lookupModelByGlobalNameOrNames(globalName: string | string[]): any;