@rvoh/dream 0.31.0 → 0.31.1

package/dist/esm/src/helpers/sortBy.js

@@ -1,3 +1,22 @@
+/**
+ * Returns a copy of the array, sorted by the value returned by calling the function in the second argument on each element in the array
+ * Returns a copy of the array sorted by the return value of the function passed as the second argument.
+ * ```ts
+ * import { sortBy } from '@rvoh/dream'
+ *
+ * sortBy(['aaa', 'a', 'aa'], (str: string) => str.length)
+ * // ['a', 'aa', 'aaa']
+ *
+ * sortBy(['aaa', 'a', 'aa'], (str: string) => -str.length)
+ * // ['aaa', 'aa', 'a']
+ *
+ * sortBy([5, 3, 7], (num: number) => num)
+ * // [3, 5, 7]
+ *
+ * sortBy([5, 3, 7], (num: number) => -num)
+ * // [7, 5, 3]
+ * ```
+ */
 export default function sortBy(array, valueToCompare) {
     const arrayClone = [...array];
     return arrayClone.sort((a, b) => {
@@ -7,8 +26,6 @@ export default function sortBy(array, valueToCompare) {
             return aPrime.localeCompare(bPrime);
         if (typeof aPrime === 'number' && typeof bPrime === 'number')
             return aPrime - bPrime;
-        if (typeof aPrime === 'bigint' && typeof bPrime === 'bigint')
-            return aPrime.toString().localeCompare(bPrime.toString());
         throw new UnsupportedValueFromComparisonFunction(aPrime, bPrime);
     });
 }

package/dist/esm/src/helpers/uniq.js

@@ -1,17 +1,18 @@
 export default function uniq(arr, toKey = undefined) {
     if (toKey)
         return uniqWith(arr, toKey);
-    else if (arr[0]?.isDreamInstance)
-        return uniqWith(arr, dreamKey);
-    else
-        return Array.from(new Set(arr));
+    return uniqWith(arr, a => String(a));
 }
 function dreamKey(dream) {
     return `${dream.constructor.globalName}:${dream.primaryKeyValue}`;
 }
 function uniqWith(arr, toKey) {
     const map = arr.reduce((acc, val) => {
-        acc[toKey(val)] ||= val;
+        // Prefix with underscore to ensure that the values cannot be interpreted as integers.
+        // If they can be interpreted as integers, then the keys are ordered not by the
+        // order in which they were added, but in ascending numerical order.
+        const key = val?.isDreamInstance ? dreamKey(val) : `_${toKey(val)}`;
+        acc[key] ||= val;
         return acc;
     }, {});
     return Object.values(map);

package/dist/esm/src/index.js

@@ -14,9 +14,9 @@ export { default as DreamImporter } from './dream-application/helpers/DreamImpor
 export { default as lookupClassByGlobalName } from './dream-application/helpers/lookupClassByGlobalName.js';
 export { default as DreamApplication, } from './dream-application/index.js';
 export { default as Dream } from './Dream.js';
+export { DreamConst, openapiPrimitiveTypes, openapiShorthandPrimitiveTypes, } from './dream/constants.js';
 export { default as DreamTransaction } from './dream/DreamTransaction.js';
 export { default as Query } from './dream/Query.js';
-export { DreamConst, } from './dream/types.js';
 export { default as Encrypt } from './encrypt/index.js';
 export { default as NonLoadedAssociation } from './errors/associations/NonLoadedAssociation.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from './errors/CreateOrFindByFailedToCreateAndFind.js';
@@ -46,11 +46,11 @@ export { Range, default as range } from './helpers/range.js';
 export { default as round } from './helpers/round.js';
 export { default as serializerNameFromFullyQualifiedModelName } from './helpers/serializerNameFromFullyQualifiedModelName.js';
 export { default as snakeify } from './helpers/snakeify.js';
+export { default as sort } from './helpers/sort.js';
 export { default as sortBy } from './helpers/sortBy.js';
 export { default as standardizeFullyQualifiedModelName } from './helpers/standardizeFullyQualifiedModelName.js';
 export { default as uncapitalize } from './helpers/uncapitalize.js';
 export { default as uniq } from './helpers/uniq.js';
-export { openapiPrimitiveTypes, openapiShorthandPrimitiveTypes, } from './openapi/types.js';
 export { default as ops } from './ops/index.js';
 export { default as RendersMany } from './serializer/decorators/associations/RendersMany.js';
 export { default as RendersOne } from './serializer/decorators/associations/RendersOne.js';

package/dist/esm/src/ops/ops-statement.js

@@ -1,4 +1,4 @@
-import { TRIGRAM_OPERATORS } from '../dream/types.js';
+import { TRIGRAM_OPERATORS } from '../dream/constants.js';
 import ScoreMustBeANormalNumber from '../errors/ops/ScoreMustBeANormalNumber.js';
 export default class OpsStatement {
     operator;

package/dist/esm/src/serializer/index.js

@@ -1,5 +1,5 @@
 import DreamApplication from '../dream-application/index.js';
-import { DreamConst, } from '../dream/types.js';
+import { DreamConst } from '../dream/constants.js';
 import GlobalNameNotSet from '../errors/dream-application/GlobalNameNotSet.js';
 import MissingSerializer from '../errors/MissingSerializersDefinition.js';
 import FailedToRenderThroughAssociationForSerializer from '../errors/serializers/FailedToRenderThroughAssociationForSerializer.js';

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

@@ -1,11 +1,6 @@
 import { CompiledQuery, DeleteQueryBuilder, InsertQueryBuilder, SelectQueryBuilder, Updateable, UpdateQueryBuilder } from 'kysely';
-import { AssociationTableNames } from './db/reflections.js';
-import { DbConnectionType } from './db/types.js';
 import { VirtualAttributeStatement } from './decorators/field-or-getter/Virtual.js';
-import { AssociationStatementsMap, PassthroughOnClause, WhereStatement } from './decorators/field/association/shared.js';
-import { HookStatement, HookStatementMap } from './decorators/field/lifecycle/shared.js';
 import { SortableFieldConfig } from './decorators/field/sortable/Sortable.js';
-import ValidationStatement, { ValidationType } from './decorators/field/validation/shared.js';
 import { ScopeStatement } from './decorators/static-method/Scope.js';
 import DreamClassTransactionBuilder from './dream/DreamClassTransactionBuilder.js';
 import DreamInstanceTransactionBuilder from './dream/DreamInstanceTransactionBuilder.js';
@@ -13,8 +8,14 @@ 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';
+import Query from './dream/Query.js';
+import { AssociationStatementsMap, PassthroughOnClause, WhereStatement } from './types/associations/shared.js';
+import { AssociationTableNames, DbConnectionType } from './types/db.js';
+import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamSerializeOptions, IdType, JoinOnStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass } from './types/dream.js';
+import { HookStatement, HookStatementMap } from './types/lifecycle.js';
+import { BaseModelColumnTypes, DefaultQueryTypeOptions, FindEachOpts, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from './types/query.js';
+import { ValidationStatement, ValidationType } from './types/validation.js';
+import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, RequiredOnClauseKeys, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from './types/variadic.js';
 export default class Dream {
     DB: any;
     /**
@@ -297,13 +298,12 @@ export default class Dream {
      */
     protected get stiBaseClassOrOwnClassName(): string;
     /**
-     * @internal
-     *
-     * Shadows .sanitizedName. Returns a string
+     * this.constructor.name may be prefixed with an underscore during conversion to Javascript.
+     * This method returns the constructor name without a leading underscore.
      *
      * @returns A string
      */
-    protected get sanitizedConstructorName(): string;
+    get sanitizedConstructorName(): string;
     /**
      * @internal
      *
@@ -2088,7 +2088,7 @@ export default class Dream {
      *  user.assignAttributes({ email: 'my@email', password: 'my password' })
      * ```
      */
-    assignAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>): Partial<import("./helpers/typeutils.js").MergeUnionOfRecordTypes<{
+    assignAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>): Partial<import("./types/utils.js").MergeUnionOfRecordTypes<{
         [x: string]: any;
     } | Partial<{
         [x: string]: any;
@@ -2105,7 +2105,7 @@ export default class Dream {
      *  user.setAttributes({ email: 'my@email', password: 'my password' })
      * ```
      */
-    setAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>): Partial<import("./helpers/typeutils.js").MergeUnionOfRecordTypes<{
+    setAttributes<I extends Dream>(this: I, attributes: UpdateableProperties<I>): Partial<import("./types/utils.js").MergeUnionOfRecordTypes<{
         [x: string]: any;
     } | Partial<{
         [x: string]: any;

package/dist/types/src/cli/logger/DreamCliLogger.d.ts

@@ -1,3 +1,4 @@
+import { DreamCliLoggerLogOpts } from '../../types/logger.js';
 import DreamCliLoggableSpinner from './loggable/DreamCliLoggableSpinner.js';
 import DreamCliLoggableText from './loggable/DreamCliLoggableText.js';
 export default class DreamCliLogger {
@@ -8,15 +9,3 @@ export default class DreamCliLogger {
     purge(): void;
     private clear;
 }
-export interface DreamCliLoggerLogOpts<IsSpinner extends boolean> {
-    permanent?: boolean;
-    spinner?: IsSpinner;
-    logPrefix?: string;
-    logPrefixColor?: DreamCliForegroundColor;
-    logPrefixBgColor?: DreamCliBgColor;
-    spinnerPrefixColor?: DreamCliForegroundColor;
-    spinnerPrefixBgColor?: DreamCliBgColor;
-}
-export type DreamCliColor = DreamCliForegroundColor | DreamCliBgColor;
-export type DreamCliForegroundColor = 'black' | 'red' | 'redBright' | 'green' | 'greenBright' | 'yellow' | 'yellowBright' | 'blue' | 'blueBright' | 'magenta' | 'magentaBright' | 'cyan' | 'cyanBright' | 'white' | 'whiteBright' | 'gray';
-export type DreamCliBgColor = 'bgBlack' | 'bgRed' | 'bgRedBright' | 'bgGreen' | 'bgGreenBright' | 'bgYellow' | 'bgYellowBright' | 'bgBlue' | 'bgBlueBright' | 'bgMagenta' | 'bgMagentaBright' | 'bgCyan' | 'bgCyanBright' | 'bgWhite' | 'bgWhiteBright';

package/dist/types/src/cli/logger/loggable/DreamCliLoggable.d.ts

@@ -1,4 +1,4 @@
-import { DreamCliBgColor, DreamCliForegroundColor } from '../DreamCliLogger.js';
+import { DreamCliBgColor, DreamCliForegroundColor } from '../../../types/logger.js';
 export default class DreamCliLoggable {
     permanent: boolean;
     logPrefix: string;

package/dist/types/src/cli/logger/loggable/DreamCliLoggableSpinner.d.ts

@@ -1,4 +1,4 @@
-import { DreamCliBgColor, DreamCliForegroundColor } from '../DreamCliLogger.js';
+import { DreamCliBgColor, DreamCliForegroundColor } from '../../../types/logger.js';
 import DreamCliLoggable from './DreamCliLoggable.js';
 import spinners from './spinners.js';
 export default class DreamCliLoggableSpinner extends DreamCliLoggable {

package/dist/types/src/cli/logger/loggable/DreamCliLoggableText.d.ts

@@ -1,4 +1,4 @@
-import { DreamCliBgColor, DreamCliForegroundColor } from '../DreamCliLogger.js';
+import { DreamCliBgColor, DreamCliForegroundColor } from '../../../types/logger.js';
 import DreamCliLoggable from './DreamCliLoggable.js';
 export default class DreamCliLoggableText extends DreamCliLoggable {
     private text;

package/dist/types/src/cli/logger/loggable/colorize.d.ts

@@ -1,4 +1,4 @@
-import { DreamCliBgColor, DreamCliForegroundColor } from '../DreamCliLogger.js';
+import { DreamCliBgColor, DreamCliForegroundColor } from '../../../types/logger.js';
 export default function colorize(text: string, { color, bgColor }: {
     color?: DreamCliForegroundColor;
     bgColor?: DreamCliBgColor;

package/dist/types/src/db/ConnectedToDB.d.ts

@@ -1,8 +1,8 @@
 import { Kysely, Transaction as KyselyTransaction } from 'kysely';
 import Dream from '../Dream.js';
 import DreamTransaction from '../dream/DreamTransaction.js';
-import { DreamConstructorType, SqlCommandType } from '../dream/types.js';
-import { DbConnectionType } from './types.js';
+import { DbConnectionType } from '../types/db.js';
+import { DreamConstructorType, SqlCommandType } from '../types/dream.js';
 export default class ConnectedToDB<DreamInstance extends Dream> {
     dreamInstance: DreamInstance;
     protected readonly dreamClass: DreamConstructorType<DreamInstance>;

package/dist/types/src/db/ConnectionConfRetriever.d.ts

@@ -1,5 +1,5 @@
 import { SingleDbCredential } from '../dream-application/index.js';
-import { DbConnectionType } from './types.js';
+import { DbConnectionType } from '../types/db.js';
 export default class ConnectionConfRetriever {
     getConnectionConf(connection: DbConnectionType): SingleDbCredential;
     hasReplicaConfig(): boolean;

package/dist/types/src/db/DreamDbConnection.d.ts

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
-import { DbConnectionType } from './types.js';
+import { DbConnectionType } from '../types/db.js';
 export default class DreamDbConnection {
     static getConnection<DB>(connectionType: DbConnectionType): Kysely<DB>;
     static dropAllConnections(): Promise<void>;

package/dist/types/src/db/dataTypes.d.ts

@@ -1,6 +1,3 @@
 export default function dataTypes(): readonly ["bigint", "bigserial", "bit", "bit varying", "boolean", "box", "bytea", "character", "character varying", "char", "cidr", "circle", "citext", "date", "double precision", "inet", "integer", "interval", "json", "jsonb", "line", "lseg", "macaddr", "money", "numeric", "path", "point", "polygon", "real", "smallint", "smallserial", "serial", "text", "time", "time with time zone", "timestamp", "timestamp with time zone", "timestamp without time zone", "tsquery", "tsvector", "txid_snapshot", "uuid", "xml"];
 export declare function isPrimitiveDataType(type: string): boolean;
 export declare const postgresDatatypes: readonly ["bigint", "bigserial", "bit", "bit varying", "boolean", "box", "bytea", "character", "character varying", "char", "cidr", "circle", "citext", "date", "double precision", "inet", "integer", "interval", "json", "jsonb", "line", "lseg", "macaddr", "money", "numeric", "path", "point", "polygon", "real", "smallint", "smallserial", "serial", "text", "time", "time with time zone", "timestamp", "timestamp with time zone", "timestamp without time zone", "tsquery", "tsvector", "txid_snapshot", "uuid", "xml"];
-type NonArrayDbTypes = (typeof postgresDatatypes)[number];
-export type DbTypes = NonArrayDbTypes | `${NonArrayDbTypes}[]`;
-export {};

package/dist/types/src/db/index.d.ts

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
 import Dream from '../Dream.js';
 import '../helpers/loadEnv.js';
-import { DbConnectionType } from './types.js';
+import { DbConnectionType } from '../types/db.js';
 export default function db<T extends Dream, DB extends T['DB'] = T['DB']>(connectionType?: DbConnectionType): Kysely<DB>;

package/dist/types/src/decorators/Decorators.d.ts

@@ -1,11 +1,11 @@
 import Dream from '../Dream.js';
-import { DreamColumnNames, GlobalModelNameTableMap, SortableOptions } from '../dream/types.js';
 import { SerializableTypes } from '../serializer/decorators/attribute.js';
-import { NonPolymorphicBelongsToOptions, PolymorphicBelongsToOptions } from './field/association/BelongsTo.js';
-import { HasManyOptions, HasManyThroughOptions, PolymorphicHasManyOptions } from './field/association/HasMany.js';
-import { HasOneOptions, HasOneThroughOptions, PolymorphicHasOneOptions } from './field/association/HasOne.js';
-import { AfterHookOpts, BeforeHookOpts } from './field/lifecycle/shared.js';
-import { ValidationType } from './field/validation/shared.js';
+import { NonPolymorphicBelongsToOptions, PolymorphicBelongsToOptions } from '../types/associations/belongsTo.js';
+import { HasManyOptions, HasManyThroughOptions, PolymorphicHasManyOptions } from '../types/associations/hasMany.js';
+import { HasOneOptions, HasOneThroughOptions, PolymorphicHasOneOptions } from '../types/associations/hasOne.js';
+import { DreamColumnNames, GlobalModelNameTableMap, SortableOptions } from '../types/dream.js';
+import { AfterHookOpts, BeforeHookOpts } from '../types/lifecycle.js';
+import { ValidationType } from '../types/validation.js';
 export default class Decorators<T extends Dream> {
     BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: NonPolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
     BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: PolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;

package/dist/types/src/decorators/field/association/BelongsTo.d.ts

@@ -1,33 +1,5 @@
-import { AssociationTableNames } from '../../../db/reflections.js';
 import Dream from '../../../Dream.js';
-import { DefaultScopeName, DefaultScopeNameForTable, DreamColumnNames, GlobalModelNames, GlobalModelNameTableMap, TableColumnNames, TableNameForGlobalModelName } from '../../../dream/types.js';
+import { NonPolymorphicBelongsToOptions, PolymorphicBelongsToOptions } from '../../../types/associations/belongsTo.js';
+import { GlobalModelNameTableMap } from '../../../types/dream.js';
 export default function BelongsTo<BaseInstance extends Dream, AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<BaseInstance> | (keyof GlobalModelNameTableMap<BaseInstance>)[]>(globalAssociationNameOrNames: AssociationGlobalNameOrNames, opts?: NonPolymorphicBelongsToOptions<BaseInstance, AssociationGlobalNameOrNames>): any;
 export default function BelongsTo<BaseInstance extends Dream, AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<BaseInstance> | (keyof GlobalModelNameTableMap<BaseInstance>)[]>(globalAssociationNameOrNames: AssociationGlobalNameOrNames, opts?: PolymorphicBelongsToOptions<BaseInstance, AssociationGlobalNameOrNames>): any;
-export interface BelongsToStatement<BaseInstance extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> {
-    modelCB: () => typeof Dream | (typeof Dream)[];
-    globalAssociationNameOrNames: string[];
-    type: 'BelongsTo';
-    as: string;
-    primaryKey: (associationInstance?: Dream) => keyof DB[TableName] & string;
-    primaryKeyValue: (associationInstance: Dream | null) => any;
-    primaryKeyOverride?: (keyof DB[TableName] & string) | null;
-    foreignKey: () => DreamColumnNames<BaseInstance> & string;
-    foreignKeyTypeField: () => DreamColumnNames<BaseInstance> & string;
-    optional: boolean;
-    distinct: null;
-    polymorphic: boolean;
-    withoutDefaultScopes?: DefaultScopeName<BaseInstance>[];
-}
-export interface NonPolymorphicBelongsToOptions<BaseInstance extends Dream, AssociationGlobalNameOrNames extends GlobalModelNames<BaseInstance> | readonly GlobalModelNames<BaseInstance>[], AssociationGlobalName = AssociationGlobalNameOrNames extends Readonly<any[]> ? AssociationGlobalNameOrNames[0] & string : AssociationGlobalNameOrNames & string, AssociationTableName extends AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB'] = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & GlobalModelNames<BaseInstance>> & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> {
-    foreignKey?: DreamColumnNames<BaseInstance>;
-    primaryKeyOverride?: TableColumnNames<BaseInstance['DB'], AssociationTableName> | null;
-    optional?: boolean;
-    withoutDefaultScopes?: DefaultScopeNameForTable<BaseInstance['schema'], AssociationTableName>[];
-}
-export interface PolymorphicBelongsToOptions<BaseInstance extends Dream, AssociationGlobalNameOrNames extends GlobalModelNames<BaseInstance> | readonly GlobalModelNames<BaseInstance>[], AssociationGlobalName = AssociationGlobalNameOrNames extends Readonly<any[]> ? AssociationGlobalNameOrNames[0] & string : AssociationGlobalNameOrNames & string, AssociationTableName extends AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB'] = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & GlobalModelNames<BaseInstance>> & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> {
-    foreignKey: DreamColumnNames<BaseInstance>;
-    primaryKeyOverride?: TableColumnNames<BaseInstance['DB'], AssociationTableName> | null;
-    optional?: boolean;
-    polymorphic: boolean;
-    withoutDefaultScopes?: DefaultScopeNameForTable<BaseInstance['schema'], AssociationTableName>[];
-}

package/dist/types/src/decorators/field/association/HasMany.d.ts

@@ -1,19 +1,6 @@
-import { AssociationTableNames } from '../../../db/reflections.js';
 import Dream from '../../../Dream.js';
-import { GlobalModelNames, GlobalModelNameTableMap, TableColumnNames, TableNameForGlobalModelName } from '../../../dream/types.js';
-import { HasOptions, HasStatement, HasThroughOptions, OrderStatement, PolymorphicHasOptions } from './shared.js';
+import { HasManyOptions, HasManyThroughOptions, PolymorphicHasManyOptions } from '../../../types/associations/hasMany.js';
+import { GlobalModelNameTableMap } from '../../../types/dream.js';
 export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyOptions<BaseInstance, AssociationGlobalName>): any;
 export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyThroughOptions<BaseInstance, AssociationGlobalName>): any;
 export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasManyOptions<BaseInstance, AssociationGlobalName>): any;
-export type HasManyStatement<BaseInstance extends Dream, DB, Schema, ForeignTableName extends AssociationTableNames<DB, Schema> & keyof DB> = HasStatement<BaseInstance, DB, Schema, ForeignTableName, 'HasMany'> & {
-    distinct?: TableColumnNames<DB, ForeignTableName>;
-    order?: OrderStatement<DB, Schema, ForeignTableName>;
-};
-interface HasManyOnlyOptions<BaseInstance extends Dream, AssociationGlobalNameOrNames extends GlobalModelNames<BaseInstance> | readonly GlobalModelNames<BaseInstance>[], AssociationGlobalName = AssociationGlobalNameOrNames extends any[] ? AssociationGlobalNameOrNames[0] & string : AssociationGlobalNameOrNames & string, AssociationTableName = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & GlobalModelNames<BaseInstance>>> {
-    distinct?: TableColumnNames<BaseInstance['DB'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> | boolean;
-    order?: OrderStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> | OrderStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>[];
-}
-export type HasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
-export type PolymorphicHasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
-export type HasManyThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasThroughOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
-export {};

package/dist/types/src/decorators/field/association/HasOne.d.ts

@@ -1,11 +1,6 @@
-import { AssociationTableNames } from '../../../db/reflections.js';
 import Dream from '../../../Dream.js';
-import { GlobalModelNameTableMap } from '../../../dream/types.js';
-import { HasOptions, HasStatement, HasThroughOptions, PolymorphicHasOptions } from './shared.js';
+import { HasOneOptions, HasOneThroughOptions, PolymorphicHasOneOptions } from '../../../types/associations/hasOne.js';
+import { GlobalModelNameTableMap } from '../../../types/dream.js';
 export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationName: AssociationGlobalName, opts?: HasOneOptions<BaseInstance, AssociationGlobalName>): any;
 export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasOneThroughOptions<BaseInstance, AssociationGlobalName>): any;
 export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasOneOptions<BaseInstance, AssociationGlobalName>): any;
-export type HasOneStatement<BaseInstance extends Dream, DB, Schema, ForeignTableName extends AssociationTableNames<DB, Schema> & keyof DB> = HasStatement<BaseInstance, DB, Schema, ForeignTableName, 'HasOne'>;
-export type HasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptions<BaseInstance, AssociationGlobalName>;
-export type PolymorphicHasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName>;
-export type HasOneThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasThroughOptions<BaseInstance, AssociationGlobalName>;

package/dist/types/src/decorators/field/association/associationToGetterSetterProp.d.ts

@@ -1,5 +1,5 @@
-import { BelongsToStatement } from './BelongsTo.js';
-import { HasManyStatement } from './HasMany.js';
-import { HasOneStatement } from './HasOne.js';
-import { PartialAssociationStatement } from './shared.js';
+import { BelongsToStatement } from '../../../types/associations/belongsTo.js';
+import { HasManyStatement } from '../../../types/associations/hasMany.js';
+import { HasOneStatement } from '../../../types/associations/hasOne.js';
+import { PartialAssociationStatement } from '../../../types/associations/shared.js';
 export default function associationToGetterSetterProp(association: BelongsToStatement<any, any, any, any> | HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | PartialAssociationStatement): string;

package/dist/types/src/decorators/field/association/shared.d.ts

@@ -1,106 +1,8 @@
-import { ComparisonOperatorExpression as KyselyComparisonOperatorExpression, SelectQueryBuilder, Updateable } from 'kysely';
-import { AssociationTableNames } from '../../../db/reflections.js';
 import Dream from '../../../Dream.js';
-import { DefaultScopeName, DefaultScopeNameForTable, DreamBelongsToAssociationMetadata, DreamColumnNames, DreamConst, GlobalModelNameTableMap, IdType, JoinedAssociation, OrderDir, TableColumnEnumTypeArray, TableColumnNames, TableColumnType, TableNameForGlobalModelName, TrigramOperator } from '../../../dream/types.js';
-import CalendarDate from '../../../helpers/CalendarDate.js';
-import { DateTime } from '../../../helpers/DateTime.js';
-import { Range } from '../../../helpers/range.js';
-import { Inc, MergeUnionOfRecordTypes, ReadonlyTail, UnionToIntersection } from '../../../helpers/typeutils.js';
-import CurriedOpsStatement from '../../../ops/curried-ops-statement.js';
-import OpsStatement, { ExtraSimilarityArgs } from '../../../ops/ops-statement.js';
-import { BelongsToStatement } from './BelongsTo.js';
-import { HasManyStatement } from './HasMany.js';
-import { HasOneStatement } from './HasOne.js';
-type MAX_JOINED_TABLES_DEPTH = 25;
-type AssociatedBelongsToModelType<I extends Dream, AssociationName extends keyof DreamBelongsToAssociationMetadata<I>, PossibleArrayAssociationType extends I[AssociationName & keyof I] = I[AssociationName & keyof I], AssociationType extends PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType = PossibleArrayAssociationType extends (infer ElementType)[] ? ElementType : PossibleArrayAssociationType> = AssociationType;
-export type AssociatedModelParam<I extends Dream, AssociationExists = keyof DreamBelongsToAssociationMetadata<I> extends never ? false : true, AssociationName = AssociationExists extends false ? never : keyof DreamBelongsToAssociationMetadata<I> & string, RetObj = AssociationExists extends false ? never : AssociationName extends never ? never : {
-    [K in AssociationName & keyof DreamBelongsToAssociationMetadata<I> & string]: AssociatedBelongsToModelType<I, K> | null;
-}> = Partial<UnionToIntersection<RetObj>>;
-export type PassthroughOnClause<PassthroughColumns extends string[]> = Partial<Record<PassthroughColumns[number], any>>;
-type DreamSelectable<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<{
-    [ColumnName in keyof DB[TableName]]: NonKyselySupportedSupplementalWhereClauseValues<DB, Schema, TableName, ColumnName>;
-}>;
-type NonKyselySupportedSupplementalWhereClauseValues<DB, Schema, TableName, Column, ColumnType = TableColumnType<Schema, TableName, Column>, EnumTypeArray extends string[] | null = TableColumnEnumTypeArray<Schema, TableName, Column>, PermanentOpsValTypes = null | readonly [], OpsValType = EnumTypeArray extends string[] ? EnumTypeArray[number] | PermanentOpsValTypes : ColumnType | PermanentOpsValTypes, PartialTypes = EnumTypeArray extends null ? ColumnType extends DateTime ? DateTime[] | Range<DateTime> | (() => Range<DateTime>) | Range<CalendarDate> | (() => Range<CalendarDate>) | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ColumnType extends CalendarDate ? CalendarDate[] | Range<CalendarDate> | (() => Range<CalendarDate>) | Range<DateTime> | (() => Range<DateTime>) | OpsStatement<KyselyComparisonOperatorExpression, OpsValType> : ColumnType extends number ? (number | bigint)[] | Range<number> | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : ColumnType extends string ? string[] | OpsStatement<KyselyComparisonOperatorExpression, string, any> | OpsStatement<TrigramOperator, OpsValType, ExtraSimilarityArgs> : ColumnType extends IdType ? IdType[] | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : never : EnumTypeArray extends string[] ? EnumTypeArray | OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> : never> = PartialTypes extends never ? OpsStatement<KyselyComparisonOperatorExpression, OpsValType, any> | CurriedOpsStatement<any, any, any, OpsValType> | SelectQueryBuilder<DB, keyof DB, any> : PartialTypes | CurriedOpsStatement<any, any, any, OpsValType> | SelectQueryBuilder<DB, keyof DB, any>;
-export type WhereStatementForDreamClass<DreamClass extends typeof Dream> = WhereStatement<InstanceType<DreamClass>['DB'], InstanceType<DreamClass>['schema'], InstanceType<DreamClass>['table']>;
-export type WhereStatementForDream<DreamInstance extends Dream> = WhereStatement<DreamInstance['DB'], DreamInstance['schema'], DreamInstance['table']>;
-type AssociationNameToDotReferencedColumns<DB, TableName extends keyof DB, AssociationName> = `${AssociationName & string}.${TableColumnNames<DB, TableName>}`;
-export type ColumnNamesAccountingForJoinedAssociations<JoinedAssociations extends Readonly<JoinedAssociation[]>, DB, RootTableName extends keyof DB, RootTableAlias extends string> = JoinedAssociations['length'] extends 0 ? TableColumnNames<DB, RootTableName> : JoinedAssociationColumnNames<JoinedAssociations, DB, AssociationNameToDotReferencedColumns<DB, RootTableName & keyof DB, RootTableAlias>>;
-type JoinedAssociationColumnNames<JoinedAssociations extends Readonly<JoinedAssociation[]>, DB, AllColumnNames, Depth extends number = 0, CurrentJoinedAssociation = Readonly<JoinedAssociations[0]>, NextTableName = CurrentJoinedAssociation extends Readonly<JoinedAssociation> ? CurrentJoinedAssociation['table'] : never, NextAssociationName = CurrentJoinedAssociation extends Readonly<JoinedAssociation> ? CurrentJoinedAssociation['alias'] : never> = JoinedAssociations['length'] extends 0 ? AllColumnNames : Depth extends MAX_JOINED_TABLES_DEPTH ? AllColumnNames : JoinedAssociationColumnNames<ReadonlyTail<JoinedAssociations>, DB, AllColumnNames | AssociationNameToDotReferencedColumns<DB, NextTableName & keyof DB, NextAssociationName>, Inc<Depth>>;
-export type WhereStatement<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<MergeUnionOfRecordTypes<Updateable<DB[TableName]> | DreamSelectable<DB, Schema, TableName>>>;
-export type OnStatementForAssociation<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, OnStatement extends WhereStatement<DB, Schema, TableName> = WhereStatement<DB, Schema, TableName>> = RequiredOnClauseKeysForThisAssociation extends null ? WhereStatement<DB, Schema, TableName> : RequiredOnClauseKeysForThisAssociation extends string[] ? Required<Pick<OnStatement, RequiredOnClauseKeysForThisAssociation[number] & keyof OnStatement>> & Partial<Omit<OnStatement, RequiredOnClauseKeysForThisAssociation[number] & keyof OnStatement>> : never;
-type OnStatementForAssociationDefinition<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<MergeUnionOfRecordTypes<Updateable<DB[TableName]> | Partial<{
-    [ColumnName in keyof DB[TableName]]: NonKyselySupportedSupplementalWhereClauseValues<DB, Schema, TableName, ColumnName> | typeof DreamConst.passthrough | typeof DreamConst.required;
-}>>>;
-export type SelfOnStatement<BaseInstance extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<Record<keyof DB[TableName], DreamColumnNames<BaseInstance>>>;
-export type WhereStatementForJoinedAssociation<JoinedAssociations extends Readonly<JoinedAssociation[]>, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = RecursiveWhereStatementForJoinedAssociation<JoinedAssociations, DB, Schema, WhereStatement<DB, Schema, TableName>>;
-type RecursiveWhereStatementForJoinedAssociation<JoinedAssociations extends Readonly<JoinedAssociation[]>, DB, Schema, OriginalOnStatement, Depth extends number = 0, CurrentJoinedAssociation = JoinedAssociations[0], TableName = CurrentJoinedAssociation extends JoinedAssociation ? CurrentJoinedAssociation['table'] : never, AssociationName = CurrentJoinedAssociation extends JoinedAssociation ? CurrentJoinedAssociation['alias'] : never, NonNamespacedAssociationOnStatement = TableName extends never ? never : AssociationName extends never ? never : WhereStatement<DB, Schema, TableName & AssociationTableNames<DB, Schema> & keyof DB>, NextOnStatement = NonNamespacedAssociationOnStatement extends never ? OriginalOnStatement : OriginalOnStatement & {
-    [K in keyof NonNamespacedAssociationOnStatement as `${AssociationName & string}.${K & string}`]: NonNamespacedAssociationOnStatement[K & keyof NonNamespacedAssociationOnStatement];
-}> = JoinedAssociations['length'] extends 0 ? OriginalOnStatement : Depth extends MAX_JOINED_TABLES_DEPTH ? OriginalOnStatement : TableName extends never ? OriginalOnStatement : RecursiveWhereStatementForJoinedAssociation<ReadonlyTail<JoinedAssociations>, DB, Schema, NextOnStatement, Inc<Depth>>;
-export type OrderStatement<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = TableColumnNames<DB, TableName> | Partial<Record<TableColumnNames<DB, TableName>, OrderDir>>;
-export type LimitStatement = number;
-export type OffsetStatement = number;
-export type OrderQueryStatement<ColumnType> = {
-    column: ColumnType & string;
-    direction: OrderDir;
-};
-export interface HasStatement<BaseInstance extends Dream, DB, Schema, ForeignTableName extends AssociationTableNames<DB, Schema> & keyof DB, HasType extends 'HasOne' | 'HasMany'> {
-    modelCB: () => typeof Dream;
-    as: string;
-    dependent?: DependentOptions;
-    foreignKey: () => keyof DB[ForeignTableName] & string;
-    foreignKeyTypeField: () => keyof DB[ForeignTableName] & string;
-    globalAssociationNameOrNames: string[];
-    on?: OnStatementForAssociationDefinition<DB, Schema, ForeignTableName>;
-    notOn?: WhereStatement<DB, Schema, ForeignTableName>;
-    onAny?: WhereStatement<DB, Schema, ForeignTableName>[];
-    polymorphic: boolean;
-    preloadThroughColumns?: string[] | Record<string, string>;
-    primaryKey: (associationInstance?: Dream) => DreamColumnNames<BaseInstance>;
-    primaryKeyOverride?: DreamColumnNames<BaseInstance> | null;
-    primaryKeyValue: (associationInstance: Dream) => any;
-    selfOn?: SelfOnStatement<BaseInstance, DB, Schema, ForeignTableName>;
-    selfNotOn?: SelfOnStatement<BaseInstance, DB, Schema, ForeignTableName>;
-    source: string;
-    through?: string;
-    type: HasType;
-    withoutDefaultScopes?: DefaultScopeName<BaseInstance>[];
-}
-interface HasOptionsBase<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, AssociationTableName = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & keyof GlobalModelNameTableMap<BaseInstance>>> {
-    dependent?: DependentOptions;
-    foreignKey?: TableColumnNames<BaseInstance['DB'], AssociationTableName & keyof BaseInstance['DB']>;
-    on?: OnStatementForAssociationDefinition<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
-    notOn?: WhereStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
-    onAny?: WhereStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>[];
-    polymorphic?: boolean;
-    preloadThroughColumns?: string[] | Record<string, string>;
-    primaryKeyOverride?: DreamColumnNames<BaseInstance> | null;
-    selfOn?: SelfOnStatement<BaseInstance, BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
-    selfNotOn?: SelfOnStatement<BaseInstance, BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
-    source?: string;
-    through?: keyof BaseInstance['schema'][BaseInstance['table']]['associations'];
-    withoutDefaultScopes?: DefaultScopeNameForTable<BaseInstance['schema'], AssociationTableName & keyof BaseInstance['DB']>[];
-}
-export type PolymorphicOption = 'polymorphic';
-export type ForeignKeyOption = 'foreignKey';
-type ThroughIncompatibleOptions = 'dependent' | 'primaryKeyOverride' | 'withoutDefaultScopes' | ForeignKeyOption | PolymorphicOption;
-type ThroughOnlyOptions = 'through' | 'source' | 'preloadThroughColumns';
-export type HasOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = Omit<HasOptionsBase<BaseInstance, AssociationGlobalName>, ThroughOnlyOptions | PolymorphicOption>;
-export type PolymorphicHasOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptionsBase<BaseInstance, AssociationGlobalName> & Required<Pick<HasOptionsBase<BaseInstance, AssociationGlobalName>, PolymorphicOption | ForeignKeyOption>>;
-export type HasThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = Omit<HasOptionsBase<BaseInstance, AssociationGlobalName>, ThroughIncompatibleOptions>;
-export interface AssociationStatementsMap {
-    belongsTo: readonly BelongsToStatement<any, any, any, any>[] | BelongsToStatement<any, any, any, any>[];
-    hasMany: readonly HasManyStatement<any, any, any, any>[] | HasManyStatement<any, any, any, any>[];
-    hasOne: readonly HasOneStatement<any, any, any, any>[] | HasOneStatement<any, any, any, any>[];
-}
+import { AssociationStatementsMap, DependentOptions, PartialAssociationStatement } from '../../../types/associations/shared.js';
 export declare function blankAssociationsFactory(dreamClass: typeof Dream, { freeze, }?: {
     freeze?: boolean;
 }): AssociationStatementsMap;
-type DependentOptions = 'destroy';
-type partialTypeFields = 'modelCB' | 'type' | 'polymorphic' | 'as' | 'primaryKey' | 'primaryKeyValue' | 'primaryKeyOverride';
-type hasOneManySpecificFields = 'source' | 'through' | 'preloadThroughColumns' | 'on' | 'notOn' | 'selfOn' | 'selfNotOn';
-type belongsToSpecificFields = 'optional';
-export type PartialAssociationStatement = Pick<HasManyStatement<any, any, any, any>, partialTypeFields | hasOneManySpecificFields> | Pick<HasOneStatement<any, any, any, any>, partialTypeFields | hasOneManySpecificFields> | Pick<BelongsToStatement<any, any, any, any>, partialTypeFields | belongsToSpecificFields>;
-export type AssociationStatement = HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | BelongsToStatement<any, any, any, any>;
 export declare function finalForeignKey(foreignKey: string | undefined, dreamClass: typeof Dream, partialAssociation: PartialAssociationStatement): string;
 export declare function foreignKeyTypeField(foreignKey: any, dream: typeof Dream, partialAssociation: PartialAssociationStatement): string;
 export declare function modelCBtoSingleDreamClass(dreamClass: typeof Dream, partialAssociation: PartialAssociationStatement): typeof Dream;
@@ -115,4 +17,3 @@ export declare function validateHasStatementArgs({ dreamClass, dependent, method
     methodName: string;
     on: object | null;
 }): void;
-export {};

package/dist/types/src/decorators/field/lifecycle/AfterCreate.d.ts

@@ -1,4 +1,4 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from './shared.js';
+import { AfterHookOpts } from '../../../types/lifecycle.js';
 export default function AfterCreate<T extends Dream>(opts?: AfterHookOpts<T>): any;
 export declare function afterCreateImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/AfterCreateCommit.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from './shared.js';
+import { AfterHookOpts } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being created. If the save takes place within a transaction,

package/dist/types/src/decorators/field/lifecycle/AfterSave.d.ts

@@ -1,4 +1,4 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from './shared.js';
+import { AfterHookOpts } from '../../../types/lifecycle.js';
 export default function AfterSave<T extends Dream>(opts?: AfterHookOpts<T>): any;
 export declare function afterSaveImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/AfterSaveCommit.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from './shared.js';
+import { AfterHookOpts } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being saved. If the save takes place within a transaction,

package/dist/types/src/decorators/field/lifecycle/AfterUpdate.d.ts

@@ -1,4 +1,4 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from './shared.js';
+import { AfterHookOpts } from '../../../types/lifecycle.js';
 export default function AfterUpdate<T extends Dream>(opts?: AfterHookOpts<T>): any;
 export declare function afterUpdateImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/AfterUpdateCommit.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from './shared.js';
+import { AfterHookOpts } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being updated. If the save takes place within a transaction,

package/dist/types/src/decorators/field/lifecycle/BeforeCreate.d.ts

@@ -1,4 +1,4 @@
 import Dream from '../../../Dream.js';
-import { BeforeHookOpts } from './shared.js';
+import { BeforeHookOpts } from '../../../types/lifecycle.js';
 export default function BeforeCreate<T extends Dream>(opts?: BeforeHookOpts<T>): any;
 export declare function beforeCreateImplementation<T extends Dream>(target: T, key: string, opts?: BeforeHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/BeforeSave.d.ts

@@ -1,4 +1,4 @@
 import Dream from '../../../Dream.js';
-import { BeforeHookOpts } from './shared.js';
+import { BeforeHookOpts } from '../../../types/lifecycle.js';
 export default function BeforeSave<T extends Dream>(opts?: BeforeHookOpts<T>): any;
 export declare function beforeSaveImplementation<T extends Dream>(target: T, key: string, opts?: BeforeHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/BeforeUpdate.d.ts

@@ -1,4 +1,4 @@
 import Dream from '../../../Dream.js';
-import { BeforeHookOpts } from './shared.js';
+import { BeforeHookOpts } from '../../../types/lifecycle.js';
 export default function BeforeUpdate<T extends Dream>(opts?: BeforeHookOpts<T>): any;
 export declare function beforeUpdateImplementation<T extends Dream>(target: T, key: string, opts?: BeforeHookOpts<T>): void;