@rvoh/dream 0.29.1

package/dist/types/src/decorators/associations/shared.d.ts

@@ -0,0 +1,118 @@
+import { ComparisonOperatorExpression as KyselyComparisonOperatorExpression, SelectQueryBuilder, Updateable } from 'kysely';
+import { DateTime } from 'luxon';
+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 { 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>[];
+}
+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;
+export declare function applyGetterAndSetter(target: Dream, partialAssociation: PartialAssociationStatement, { foreignKeyBase, isBelongsTo, }?: {
+    foreignKeyBase?: string;
+    isBelongsTo?: boolean;
+}): void;
+export declare function associationPrimaryKeyAccessors(partialAssociation: Exclude<PartialAssociationStatement, 'primaryKey' | 'primaryKeyValue'>, dreamClass: typeof Dream): PartialAssociationStatement;
+export declare function validateHasStatementArgs({ dreamClass, dependent, methodName, on, }: {
+    dreamClass: typeof Dream;
+    dependent: DependentOptions | null;
+    methodName: string;
+    on: object | null;
+}): void;
+export {};

package/dist/types/src/decorators/helpers/freezeBaseClassArrayMap.d.ts

@@ -0,0 +1 @@
+export default function freezeBaseClassArrayMap<T extends Record<string, readonly any[] | any[]>>(map: T): Readonly<T>;

package/dist/types/src/decorators/hooks/AfterCreate.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../Dream.js';
+import { AfterHookOpts } from './shared.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/hooks/AfterCreateCommit.d.ts

@@ -0,0 +1,21 @@
+import Dream from '../../Dream.js';
+import { AfterHookOpts } from './shared.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being created. If the save takes place within a transaction,
+ * this method will not be called until the transaction is
+ * committed. However, if the save is not taking place in
+ * a transaction, the method will be run after the save
+ * is complete.
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.AfterCreateCommit()
+ *   public doSomething() {
+ *     ...
+ *   }
+ * }
+ *
+ * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
+ */
+export default function AfterCreateCommit<T extends Dream>(opts?: AfterHookOpts<T>): any;
+export declare function afterCreateCommitImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/hooks/AfterDestroy.d.ts

@@ -0,0 +1,3 @@
+import Dream from '../../Dream.js';
+export default function AfterDestroy(): any;
+export declare function afterDestroyImplementation(target: Dream, key: string): void;

package/dist/types/src/decorators/hooks/AfterDestroyCommit.d.ts

@@ -0,0 +1,18 @@
+import Dream from '../../Dream.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being destroyed. If the destroy takes place within a transaction,
+ * this method will not be called until the transaction is
+ * committed. However, if the destroy is not taking place in
+ * a transaction, the method will be run after the save
+ * is complete.
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.AfterDestroyCommit()
+ *   public doSomething() {
+ *     ...
+ *   }
+ * }
+ */
+export default function AfterDestroyCommit(): any;
+export declare function afterDestroyCommitImplementation<T extends Dream>(target: T, key: string): void;

package/dist/types/src/decorators/hooks/AfterSave.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../Dream.js';
+import { AfterHookOpts } from './shared.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/hooks/AfterSaveCommit.d.ts

@@ -0,0 +1,21 @@
+import Dream from '../../Dream.js';
+import { AfterHookOpts } from './shared.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being saved. If the save takes place within a transaction,
+ * this method will not be called until the transaction is
+ * committed. However, if the save is not taking place in
+ * a transaction, the method will be run after the save
+ * is complete.
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.AfterSaveCommit()
+ *   public doSomething() {
+ *     ...
+ *   }
+ * }
+ *
+ * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
+ */
+export default function AfterSaveCommit<T extends Dream>(opts?: AfterHookOpts<T>): any;
+export declare function afterSaveCommitImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/hooks/AfterUpdate.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../Dream.js';
+import { AfterHookOpts } from './shared.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/hooks/AfterUpdateCommit.d.ts

@@ -0,0 +1,21 @@
+import Dream from '../../Dream.js';
+import { AfterHookOpts } from './shared.js';
+/**
+ * Calls the decorated method whenever a dream has finished
+ * being updated. If the save takes place within a transaction,
+ * this method will not be called until the transaction is
+ * committed. However, if the save is not taking place in
+ * a transaction, the method will be run after the save
+ * is complete.
+ *
+ * class User extends ApplicationModel {
+ *   @Deco.AfterUpdateCommit()
+ *   public doSomething() {
+ *     ...
+ *   }
+ * }
+ *
+ * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
+ */
+export default function AfterUpdateCommit<T extends Dream>(opts?: AfterHookOpts<T>): any;
+export declare function afterUpdateCommitImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/hooks/BeforeCreate.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../Dream.js';
+import { BeforeHookOpts } from './shared.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/hooks/BeforeDestroy.d.ts

@@ -0,0 +1,3 @@
+import Dream from '../../Dream.js';
+export default function BeforeDestroy(): any;
+export declare function beforeDestroyImplementation(target: Dream, key: string): void;

package/dist/types/src/decorators/hooks/BeforeSave.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../Dream.js';
+import { BeforeHookOpts } from './shared.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/hooks/BeforeUpdate.d.ts

@@ -0,0 +1,4 @@
+import Dream from '../../Dream.js';
+import { BeforeHookOpts } from './shared.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;

package/dist/types/src/decorators/hooks/shared.d.ts

@@ -0,0 +1,34 @@
+import Dream from '../../Dream.js';
+import { DreamColumnNames } from '../../dream/types.js';
+export type HookType = 'beforeCreate' | 'beforeSave' | 'beforeUpdate' | 'beforeDestroy' | 'afterCreate' | 'afterSave' | 'afterUpdate' | 'afterDestroy' | CommitHookType;
+export type CommitHookType = 'afterCreateCommit' | 'afterSaveCommit' | 'afterUpdateCommit' | 'afterDestroyCommit';
+export interface HookStatement {
+    type: HookType;
+    className: string;
+    method: string;
+    ifChanging?: string[];
+    ifChanged?: string[];
+}
+export interface BeforeHookOpts<T extends Dream | null = null> {
+    ifChanging?: T extends Dream ? DreamColumnNames<T>[] : string[];
+}
+export interface AfterHookOpts<T extends Dream | null = null> {
+    ifChanged?: T extends Dream ? DreamColumnNames<T>[] : string[];
+}
+export interface HookStatementMap {
+    beforeCreate: readonly HookStatement[] | HookStatement[];
+    beforeUpdate: readonly HookStatement[] | HookStatement[];
+    beforeSave: readonly HookStatement[] | HookStatement[];
+    beforeDestroy: readonly HookStatement[] | HookStatement[];
+    afterCreate: readonly HookStatement[] | HookStatement[];
+    afterCreateCommit: readonly HookStatement[] | HookStatement[];
+    afterUpdate: readonly HookStatement[] | HookStatement[];
+    afterUpdateCommit: readonly HookStatement[] | HookStatement[];
+    afterSave: readonly HookStatement[] | HookStatement[];
+    afterSaveCommit: readonly HookStatement[] | HookStatement[];
+    afterDestroy: readonly HookStatement[] | HookStatement[];
+    afterDestroyCommit: readonly HookStatement[] | HookStatement[];
+}
+export declare function blankHooksFactory(dreamClass: typeof Dream, { freeze, }?: {
+    freeze?: boolean;
+}): HookStatementMap;

package/dist/types/src/decorators/sortable/Sortable.d.ts

@@ -0,0 +1,9 @@
+export default function Sortable(opts?: SortableOpts): any;
+interface SortableOpts {
+    scope?: string | string[];
+}
+export interface SortableFieldConfig {
+    scope: string[];
+    positionField: string;
+}
+export {};

package/dist/types/src/decorators/sortable/helpers/applySortableScopeToQuery.d.ts

@@ -0,0 +1,9 @@
+import Dream from '../../../Dream.js';
+import Query from '../../../dream/Query.js';
+export default function applySortableScopeToQuery(query: Query<Dream>, dream: Dream, scope?: string | string[]): Query<Dream, Readonly<{
+    joinedAssociations: Readonly<[]>;
+    rootTableName: string;
+    rootTableAlias: string;
+    allowPreload: true;
+    allowLeftJoinPreload: true;
+}>>;

package/dist/types/src/decorators/sortable/helpers/clearCachedSortableValues.d.ts

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

package/dist/types/src/decorators/sortable/helpers/decrementScopedRecordsGreaterThanPosition.d.ts

@@ -0,0 +1,8 @@
+import Dream from '../../../Dream.js';
+import Query from '../../../dream/Query.js';
+export default function decrementPositionForScopedRecordsGreaterThanPosition(position: number, { dream, positionField, query, scope, }: {
+    dream: Dream;
+    positionField: string;
+    query: Query<Dream>;
+    scope?: string | string[];
+}): Promise<void>;

package/dist/types/src/decorators/sortable/helpers/getColumnForSortableScope.d.ts

@@ -0,0 +1,2 @@
+import Dream from '../../../Dream.js';
+export default function getColumnForSortableScope(dream: Dream, scope?: string): any;

package/dist/types/src/decorators/sortable/helpers/isSortedCorrectly.d.ts

@@ -0,0 +1 @@
+export default function isSortedCorrectly(arr: any[], positionField: string): boolean;

package/dist/types/src/decorators/sortable/helpers/positionIsInvalid.d.ts

@@ -0,0 +1,8 @@
+import Dream from '../../../Dream.js';
+import Query from '../../../dream/Query.js';
+export default function positionIsInvalid({ query, dream, position, scope, }: {
+    query: Query<Dream>;
+    dream: Dream;
+    position: number | null | undefined;
+    scope?: string | string[];
+}): Promise<boolean>;

package/dist/types/src/decorators/sortable/helpers/resortAllRecords.d.ts

@@ -0,0 +1,2 @@
+import Dream from '../../../Dream.js';
+export default function resortAllRecords(dreamClass: typeof Dream, positionField: string, scope?: string | string[]): Promise<void>;

package/dist/types/src/decorators/sortable/helpers/scopeArray.d.ts

@@ -0,0 +1 @@
+export default function scopeArray(scope?: string | string[]): string[];

package/dist/types/src/decorators/sortable/helpers/setPosition.d.ts

@@ -0,0 +1,14 @@
+import { SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../../dream/DreamTransaction';
+import Query from '../../../dream/Query.js';
+export default function setPosition({ position, previousPosition, dream, positionField, scope, query, txn, }: {
+    dream: Dream;
+    position: number;
+    previousPosition?: number;
+    positionField: string;
+    query: Query<Dream>;
+    scope?: string | string[];
+    txn?: DreamTransaction<any>;
+}): Promise<void>;
+export declare function applySortableScopesToQuery<QB extends UpdateQueryBuilder<any, string, string, any> | SelectQueryBuilder<any, any, any>>(dream: Dream, kyselyQuery: QB, whereValueCB: (column: string) => any, scope?: string | string[]): QB;

package/dist/types/src/decorators/sortable/helpers/sortableCacheKeyName.d.ts

@@ -0,0 +1 @@
+export default function sortableCacheKeyName(positionField: string): string;

package/dist/types/src/decorators/sortable/helpers/sortableCacheValuesName.d.ts

@@ -0,0 +1 @@
+export default function sortableCacheValuesName(positionField: string): string;

package/dist/types/src/decorators/sortable/helpers/sortableQueryExcludingDream.d.ts

@@ -0,0 +1,9 @@
+import Dream from '../../../Dream.js';
+import Query from '../../../dream/Query.js';
+export default function sortableQueryExcludingDream(dream: Dream, query: Query<Dream>, scope?: string | string[]): Query<Dream, Readonly<{
+    joinedAssociations: Readonly<[]>;
+    rootTableName: string;
+    rootTableAlias: string;
+    allowPreload: true;
+    allowLeftJoinPreload: true;
+}>>;

package/dist/types/src/decorators/sortable/hooks/afterSortableCreate.d.ts

@@ -0,0 +1,10 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../../dream/DreamTransaction.js';
+import Query from '../../../dream/Query.js';
+export default function afterSortableCreate({ positionField, dream, query, txn, scope, }: {
+    positionField: string;
+    dream: Dream;
+    query: Query<Dream>;
+    txn?: DreamTransaction<any>;
+    scope?: string | string[];
+}): Promise<void>;

package/dist/types/src/decorators/sortable/hooks/afterSortableDestroy.d.ts

@@ -0,0 +1,8 @@
+import Dream from '../../../Dream.js';
+import Query from '../../../dream/Query.js';
+export default function afterSortableDestroy({ positionField, dream, query, scope, }: {
+    positionField: string;
+    dream: Dream;
+    query: Query<Dream>;
+    scope?: string | string[];
+}): Promise<void>;

package/dist/types/src/decorators/sortable/hooks/afterSortableUpdate.d.ts

@@ -0,0 +1,10 @@
+import Dream from '../../../Dream.js';
+import DreamTransaction from '../../../dream/DreamTransaction.js';
+import Query from '../../../dream/Query.js';
+export default function afterUpdateSortable({ positionField, dream, query, txn, scope, }: {
+    positionField: string;
+    dream: Dream;
+    query: Query<Dream>;
+    txn?: DreamTransaction<any>;
+    scope?: string | string[];
+}): Promise<void>;

package/dist/types/src/decorators/sortable/hooks/beforeSortableSave.d.ts

@@ -0,0 +1,8 @@
+import Dream from '../../../Dream.js';
+import Query from '../../../dream/Query.js';
+export default function beforeSortableSave({ positionField, dream, query, scope, }: {
+    positionField: string;
+    dream: Dream;
+    query: Query<Dream>;
+    scope?: string | string[];
+}): Promise<void>;

package/dist/types/src/decorators/validations/Validate.d.ts

@@ -0,0 +1 @@
+export default function Validate(): any;

package/dist/types/src/decorators/validations/Validates.d.ts

@@ -0,0 +1,18 @@
+import Dream from '../../Dream.js';
+import { ValidationType } from './shared.js';
+export default function Validates<VT extends ValidationType, VTArgs extends VT extends 'numericality' ? {
+    min?: number;
+    max?: number;
+} : VT extends 'length' ? {
+    min: number;
+    max?: number;
+} : VT extends 'contains' ? string | RegExp : never>(type: VT, args?: VTArgs): any;
+export declare function validatesImplementation<VT extends ValidationType, VTArgs extends VT extends 'numericality' ? {
+    min?: number;
+    max?: number;
+} : VT extends 'length' ? {
+    min: number;
+    max?: number;
+} : VT extends 'contains' ? string | RegExp : never>(target: Dream, key: string, type: VT, args?: VTArgs): void;
+export declare class ValidationInstantiationError extends Error {
+}

package/dist/types/src/decorators/validations/shared.d.ts

@@ -0,0 +1,19 @@
+export default interface ValidationStatement {
+    type: ValidationType;
+    column: string;
+    options?: {
+        presence?: object;
+        numericality?: {
+            max?: number;
+            min?: number;
+        };
+        contains?: {
+            value: string | RegExp;
+        };
+        length?: {
+            min: number;
+            max?: number;
+        };
+    };
+}
+export type ValidationType = 'presence' | 'numericality' | 'contains' | 'length' | 'requiredBelongsTo';