declare function normalizeInclude(context: {}, include: string[]): Promise; type DescriptorHolder = { $MODEL_TYPE: 'descriptor'; descriptor: PropertyDescriptor; __type__: T; }; type Dictionary = { [K: string]: T; }; type Constructor = new (...args: any[]) => T; type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; type Value = T extends (...args: any[]) => any ? ReturnType : T; type Awaitable = T | Promise; type ArrayableVariadic = T[] | [T[]]; type Optional = T | null | undefined; type Falsy = null | undefined | false | 0 | -0 | 0n | ''; type OnlyTruthy = T extends Falsy ? never : T; type OnlyFalsy = T extends Falsy ? T : never; type HookCallback = (event: E) => Awaitable; type HooksDefinition = Dictionary>; type HooksRegistrar = { [K in keyof D]?: D[K][]; }; type Hookable = { $hooks: HooksRegistrar | null; }; type Normalizer = (value: T) => U; type FunctionTransform = (value: S) => Awaitable; type ObjectTransform = { serialize(value: T): Awaitable; deserialize(value: S): Awaitable; }; type Transform = FunctionTransform | ObjectTransform; /** * Configuration of a model class. */ type ModelConfig = { /** * Path which is used to query the model. * Defaults to the model's type. */ path?: Optional; /** * Normalize a model/relation path when injecting it inside an action context. */ normalizePath?: Optional>; /** * Normalize a model path when injecting it inside an action context. * Prioritized over `normalizePath`. */ normalizeModelPath?: Optional>; /** * Normalize a relation path when injecting it inside an action context. * Prioritized over `normalizePath`. */ normalizeRelationPath?: Optional>; /** * Normalize an attribute/relation key when (de)serializing for data source. */ normalizeKey?: Optional>; /** * Normalize an attribute key when (de)serializing for data source. * Prioritized over `normalizeKey`. */ normalizeAttributeKey?: Optional>; /** * Normalize a relation key when (de)serializing for data source. * Prioritized over `normalizeKey`. */ normalizeRelationKey?: Optional>; /** * Guess the type for a given relation. */ guessRelationType?: Optional; /** * Compare two values when checking model instance changed values. * * @param nextValue * @param prevValue * * @see {@link changed} */ compareValue?: Optional<((nextValue: unknown, prevValue: unknown) => boolean)>; /** * Clone two values when sync model instances values state. * * @param value * * @see {@link restore} * @see {@link markSynced} */ cloneValue?: Optional<((value: T) => T)>; /** * Dedicated base URL. Will overwrite the default base URL. */ baseURL?: Optional; }; /** * Guess a model's relation related type. */ type ModelRelationTypeGuesser = (model: ModelClass, def: ModelRelation) => Optional; /** * Unique identifier for a model instance. */ type ModelId = string | number; /** * Sync precise configuration for a property (will only do defined action). */ type ModelPropSync = 'retrieve' | 'write'; /** * Normalized part of a property's definition (attribute or relation). */ type ModelPropNormalized = { key: K; }; /** * Raw definition for a model's property (attribute or relation). */ type ModelPropRaw = { /** * Default value for the property. */ default?: T | (() => T) | undefined; /** * Alias of the property (might be used when (de)serializing). */ alias?: string | undefined; /** * Makes the property read-only. */ readOnly?: boolean; /** * Tells if the property should be synced with the data store. */ sync?: boolean | ModelPropSync; }; /** * Raw definition for a model's attribute. */ type ModelAttributeRaw = ModelPropRaw & { /** * Internal type identifier for Foscia's type guards. */ $MODEL_TYPE: 'attribute'; transformer?: Transform | undefined; }; /** * Definition for a model's attribute. */ type ModelAttribute = ModelPropNormalized & ModelAttributeRaw; /** * Available model relation types. */ type ModelRelationType = 'hasOne' | 'hasMany'; /** * Raw definition for a model's relation. */ type ModelRelationRaw = ModelPropRaw & { /** * Internal type identifier for Foscia's type guards. */ $MODEL_TYPE: 'relation'; $RELATION_TYPE: ModelRelationType; type?: string; path?: string; }; /** * Definition for a model's attribute. */ type ModelRelation = ModelPropNormalized & ModelRelationRaw; /** * The parsed model definition with non attributes/relations properties' * descriptors wrapped in holders. */ type ModelParsedDefinition = { [K in keyof D]: D[K] extends ModelAttributeRaw ? D[K] & ModelPropNormalized : D[K] extends ModelRelationRaw ? D[K] & ModelPropNormalized : D[K] extends DescriptorHolder ? D[K] : DescriptorHolder; }; /** * Extract model's attributes and relations from the whole definition. */ type ModelSchema = { [K in keyof D]: D[K] extends ModelAttribute ? D[K] : D[K] extends ModelRelation ? D[K] : never; }; /** * Model hook callback function. */ type ModelHookCallback = HookCallback; /** * Model's hooks definition. */ type ModelHooksDefinition = { retrieved: ModelHookCallback; creating: ModelHookCallback; created: ModelHookCallback; updating: ModelHookCallback; updated: ModelHookCallback; saving: ModelHookCallback; saved: ModelHookCallback; destroying: ModelHookCallback; destroyed: ModelHookCallback; }; /** * Extendable model class holding the configuration and schema. */ type ModelClass = Hookable & { /** * Internal type identifier for Foscia's type guards. */ readonly $MODEL_TYPE: 'model'; readonly $type: string; readonly $config: ModelConfig; readonly $schema: ModelSchema; configure(rawConfig?: ModelConfig, override?: boolean): void; extends(rawDefinition?: ND & ThisType>): Model>; }; /** * Model class of a dedicated instance. * This type is used to keep instance generic typing across actions enhancements. */ type Model = any> = ModelClass & Constructor; /** * Model instance for a dedicated model class. * This type is used to keep instance generic typing across actions enhancements. */ type ModelClassInstance = { readonly $model: ModelClass; }; /** * Model instance holding state and values. */ type ModelInstance = { /** * Internal type identifier for Foscia's type guards. */ readonly $MODEL_TYPE: 'instance'; readonly $model: ModelClass; id: ModelId; lid: Optional; exists: boolean; $loaded: Dictionary; $values: Partial>>; $raw: any; $original: ModelSnapshot>; } & { [K in keyof D]: D[K] extends ModelAttribute ? T : D[K] extends ModelRelation ? T : D[K] extends DescriptorHolder ? T : D[K]; }; /** * Model class or instance snapshot. */ type ModelSnapshot = { id: Optional; lid: Optional; exists: boolean; $raw: any; $loaded: Dictionary; $values: Partial>; }; type ModelClassOrInstance = ModelClass | ModelClassInstance; /** * Infer the definition from a model class or model instance. */ type ModelInferDefinition = M extends ModelClassOrInstance ? D : M extends {} ? M : never; /** * Infer the schema from a model class or model instance. */ type ModelInferSchema = ModelSchema>; /** * Model class or instance values map (only attributes/relations). */ type ModelValues = { [K in keyof ModelInferSchema]: ModelInferSchema[K] extends ModelAttribute ? T : ModelInferSchema[K] extends ModelRelation ? T : never; }; /** * Model class or instance attributes/relations key. */ type ModelKey = keyof ModelInferSchema; /** * Model class or instance relations key (only direct relations). * * @example * const keys: ModelRelationKey[] = ['comments', 'tags']; */ type ModelRelationKey = keyof ModelInferSchema extends infer K ? K extends string & keyof ModelInferSchema ? ModelInferSchema[K] extends never ? never : ModelInferSchema[K] extends ModelRelation ? K : never : never : never; /** * Model class or instance relations key (supports nested relation using dot separator). * * @example * const keys: ModelRelationDotKey[] = ['comments', 'comments.author', 'tags']; */ type ModelRelationDotKey = [ Depth ] extends [0] ? never : keyof ModelInferSchema extends infer K ? K extends string & keyof ModelInferSchema ? ModelInferSchema[K] extends never ? never : ModelInferSchema[K] extends ModelRelation ? T extends any[] ? K | `${K}.${ModelRelationDotKey}` : K | `${K}.${ModelRelationDotKey}` : never : never : never; type RefsCacheMode = { ref(instance: ModelInstance): Awaitable; deref(ref: R): Awaitable; }; type RefsCacheConfig = { mode?: RefsCacheMode; }; type RegistryI = { modelFor(rawType: string): Promise; }; type CacheI = { find(type: string, id: ModelId): Promise; put(type: string, id: ModelId, instance: ModelInstance): Promise; forget(type: string, id: ModelId): Promise; forgetAll(type: string): Promise; }; type AdapterI = { execute(context: {}): Awaitable; isNotFound(error: unknown): Awaitable; }; type SerializerI = { serialize(instance: ModelInstance, context: {}): Awaitable; }; type DeserializedData = { instances: I[]; }; type DeserializerI = { deserialize(data: AdapterData, context: {}): Awaitable; }; declare class RefsCache implements CacheI { private readonly instances; private mode; constructor(config?: RefsCacheConfig); configure(config?: RefsCacheConfig, override?: boolean): void; find(type: string, id: ModelId): Promise | null>; put(type: string, id: ModelId, instance: ModelInstance): Promise; forget(type: string, id: ModelId): Promise; forgetAll(type: string): Promise; } declare const weakRefCacheMode: RefsCacheMode>; /** * Extendable error class used inside Foscia. */ declare class FosciaError extends Error { /** * Construct a new FosciaError. Prefix the given message with "[foscia]". * * @param message */ constructor(message: string); } declare class AdapterError extends FosciaError { } /** * Error which occurs during deserialization. * * It should be thrown when encountering a deserializer configuration error * or a data source's data format mismatch. */ declare class DeserializerError extends FosciaError { } /** * Error which occurs on "xxxOrFail" runners. * * It can be handled globally by the underlying application * (e.g. to display a 404 Not Found page). */ declare class ExpectedRunFailureError extends FosciaError { } /** * Error which occurs during serialization. * * It should be thrown when encountering a serializer configuration error * or a data source's data format mismatch. */ declare class SerializerError extends FosciaError { } declare function registerHook(hookable: Hookable, key: K, callback: D[K]): () => void; declare function runHook(hookable: Hookable, key: K, event: D[K] extends HookCallback ? E : never): Promise; declare function unregisterHook(hookable: Hookable, key: K, callback: D[K]): void; declare function withoutHooks, R>(hookable: T, callback: (hookable: T) => R): R; declare const LOGGER_LEVELS: { error: string; warn: string; info: string; debug: string; }; type LoggerLevel = keyof typeof LOGGER_LEVELS; declare class Logger { level: LoggerLevel | null; error(message: string, args?: unknown[]): void; warn(message: string, args?: unknown[]): void; info(message: string, args?: unknown[]): void; debug(message: string, args?: unknown[]): void; private message; } declare const _default$1: Logger; declare function onCreated(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onCreating(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onDestroyed(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onDestroying(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onRetrieved(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onSaved(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onSaving(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onUpdated(model: Model, callback: (instance: I) => Awaitable): () => void; declare function onUpdating(model: Model, callback: (instance: I) => Awaitable): () => void; declare function isSame(value: unknown, otherValue: unknown): boolean; /** * Create a composable definition which will be used by a model factory. * * @param rawDefinition */ declare function makeComposable(rawDefinition?: D & ThisType>): ModelParsedDefinition; declare const _default: (rawConfig: string | (ModelConfig & { type: string; }), rawDefinition?: (D & ThisType>>) | undefined) => Model, ModelInstance>>; declare function makeModelFactory(baseRawDefinition?: ND & ThisType>>, baseConfig?: ModelConfig): (rawConfig: string | (ModelConfig & { type: string; }), rawDefinition?: (D & ThisType>>) | undefined) => Model, ModelInstance>>; declare function isAttributeDef(value: unknown): value is ModelAttribute; declare function isInstance(value: unknown): value is I; declare function isModel(value: unknown): value is M; declare function isPluralRelationDef(def: ModelRelation): boolean; declare function isPropDef(def: unknown): def is ModelAttribute | ModelRelation; declare function isRelationDef(value: unknown): value is ModelRelation; declare function eachAttributes(instance: ModelInstance, callback: (def: ModelAttribute) => R): any; declare function eachProps(instance: ModelInstance, callback: (def: ModelAttribute | ModelRelation) => R): R[]; declare function eachRelations(instance: ModelInstance, callback: (def: ModelRelation) => R): any; type AttrOptions = ModelPropRaw & { transformer?: Transform | undefined; }; type AttrOptionsVariadic = [] | [AttrOptions] | [Transform] | [Transform, Omit, 'transformer'>]; declare function attr(...config: AttrOptionsVariadic): ModelAttributeRaw; type RelationOptions = ModelPropRaw & { type?: string; path?: string; }; type HasManyOptions = RelationOptions; declare function hasMany(config?: string | HasManyOptions): ModelRelationRaw; type HasOneOptions = RelationOptions; declare function hasOne(config?: string | HasOneOptions): ModelRelationRaw; declare function shouldSync(def: ModelPropRaw, actions: ModelPropSync[]): boolean; declare function loaded(instance: I, ...relations: ArrayableVariadic>): boolean; declare function changed(instance: I, ...only: ArrayableVariadic>): boolean; declare function compareSnapshots(model: M, nextSnapshot: ModelSnapshot, prevSnapshot: ModelSnapshot, ...only: ArrayableVariadic>): boolean; declare function restore(instance: I, ...only: ArrayableVariadic>): I; declare function restoreSnapshot(instance: I, snapshot: ModelSnapshot, ...only: ArrayableVariadic>): I; declare function markSynced(instance: I, ...only: ArrayableVariadic>): I; declare function takeSnapshot(instance: I): ModelSnapshot; declare function fill(instance: I, values: Partial>): I; declare function normalizeDotRelations(model: ModelClass, relations: ModelRelationDotKey>[], registry?: Optional): Promise; declare function normalizeKey(model: ModelClass, key: ModelKey>): string; type ModelResolver = () => Promise; type ModelPreparator = (model: Model) => Awaitable; type MapRegistryConfig = { normalizeType?: Optional>; prepareModel?: Optional; }; declare class MapRegistry implements RegistryI { private modelsResolvers; private models; private normalizeType; private prepareModel; constructor(config?: MapRegistryConfig); configure(config?: MapRegistryConfig, override?: boolean): void; modelFor(rawType: string): Promise | null>; register(...models: ArrayableVariadic | [Dictionary]): this; registerSync(...models: ArrayableVariadic): this; registerAsync(models: Dictionary): this; private registerModel; } declare function toBoolean(trueValues?: unknown[]): FunctionTransform; declare function toDate(): ObjectTransform; declare function toNumber(): FunctionTransform; declare function toString(): FunctionTransform; type ActionHooksDefinition = { preparing: HookCallback; running: HookCallback<{ context: C; runner: Function; }>; success: HookCallback<{ context: C; result: unknown; }>; error: HookCallback<{ context: C; error: unknown; }>; finally: HookCallback<{ context: C; }>; }; type Action = { useContext(): Promise; updateContext(newContext: NewContext): Action; use(enhancer: ContextEnhancer): Action; run(runner: ContextRunner): Promise>; } & Hookable> & ExtendedAction; type ActionClass = { extends(newExtensions?: NewExtension): ActionClass; } & Constructor>; type ActionParsedExtension = { [K in keyof E]: E[K] extends DescriptorHolder ? E[K] : DescriptorHolder; }; type ExtendedAction = { [K in keyof E]: E[K] extends DescriptorHolder ? T : E[K]; }; type ContextEnhancer = (action: Action) => Awaitable | void>; type ContextRunner = (action: Action) => R; type InferConsumedInstance = C extends { relation: ModelRelationRaw>; } ? I extends ModelInstance ? I : never : C extends { relation: ModelRelationRaw; } ? I extends ModelInstance ? I : never : C extends { model: Constructor; } ? I extends ModelInstance ? I : never : never; type ConsumeAction = { action: 'read' | 'create' | 'update' | 'destroy' | string; }; type ConsumeData = { data: unknown; }; type ConsumeModel = { model: M; }; type ConsumeModelPath = { modelPath: string; }; type ConsumeInstance = { instance: I; }; type ConsumeRelation = { relation: ModelRelation; }; type ConsumeRelationPath = { relationPath: string; }; type ConsumeId = { id?: ModelId; }; type ConsumeInclude = { include?: string[]; }; type ConsumeCache = { cache: CacheI; }; type ConsumeRegistry = { registry: RegistryI; }; type ConsumeAdapter = { adapter: AdapterI; }; type ConsumeDeserializer = { deserializer: DeserializerI; }; type ConsumeSerializer = { serializer: SerializerI; }; declare function consumeAction(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["action"]>; declare function consumeAdapter(context: C & Partial>, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial>)["adapter"]>; declare function consumeCache(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["cache"]>; declare function consumeContext(context: Context, key: Key, enhancers: string[], defaultValue?: Default): (Default & ({} | null)) | NonNullable; declare function consumeData(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["data"]>; declare function consumeDeserializer(context: C & Partial>, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial>)["deserializer"]>; declare function consumeId(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["id"]>; declare function consumeInclude(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["include"]>; declare function consumeInstance(context: C & Partial>, defaultValue?: D): I | D; declare function consumeModel(context: C & Partial>, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial>)["model"]>; declare function consumeModelPath(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["modelPath"]>; declare function consumeRegistry(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["registry"]>; declare function consumeRelation(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["relation"]>; declare function consumeRelationPath(context: C & Partial, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial)["relationPath"]>; declare function consumeSerializer(context: C & Partial>, defaultValue?: D): (D & ({} | null)) | NonNullable<(C & Partial>)["serializer"]>; /** * Merge the given context into the action's current context. * The context is not deeply merged. * * @param contextToMerge * * @category Enhancers */ declare function context(contextToMerge: NC): (action: Action) => Promise & NC, {}>>; declare namespace context { var extension: ActionParsedExtension<{ context(this: Action, context: NC): Action; }>; } /** * Prepare context for an instance creation. * * @param instance * * @category Enhancers */ declare function create>(instance: ModelClassInstance & I): (action: Action>) => Action> & { model: Model; }> & { modelPath: string; baseURL: string | undefined; }> & { instance: I; }> & { id: ModelId | undefined; } & ConsumeSerializer> & { data: Awaited; }> & { id: ModelId | undefined; }> & { action: string; } & ConsumeInstance, {}>; declare namespace create { var extension: ActionParsedExtension<{ create>(this: Action, E>, instance: ModelClassInstance & I): Action> & ConsumeInstance & ConsumeId, E>; }>; } /** * Prepare context for an instance deletion. * * @param instance * * @category Enhancers */ declare function destroy>(instance: ModelClassInstance & I): (action: Action) => Action & { model: Model; }> & { modelPath: string; baseURL: string | undefined; }> & { instance: I; }> & { id: ModelId | undefined; }> & { action: string; } & ConsumeInstance, {}>; declare namespace destroy { var extension: ActionParsedExtension<{ destroy>(this: Action, instance: ModelClassInstance & I): Action> & ConsumeInstance & ConsumeId, E>; }>; } /** * Target a given model record using its ID. * * @param model * @param id * * @category Enhancers */ declare function find, M extends Model>(model: M, id: ModelId): (action: Action) => Action & { model: M; }> & { modelPath: string; baseURL: string | undefined; }> & { id: ModelId | undefined; }, {}>; declare namespace find { var extension: ActionParsedExtension<{ find>(this: Action, model: M, id: ModelId): Action & ConsumeId, E>; }>; } /** * Serialize the given instance as the context's data. * * @param instance * * @category Enhancers */ declare function instanceData(instance: ModelInstance): (action: Action>) => Promise> & { data: Awaited; }, {}>>; declare namespace instanceData { var extension: ActionParsedExtension<{ instanceData(this: Action, E>, instance: ModelInstance): Action; }>; } /** * Prepare context for an instance creation or update depending on its existence * state. Calls "update" if the instance exists, otherwise call "create". * * @param instance * * @category Enhancers */ declare function save>(instance: ModelClassInstance & I): (action: Action>) => Action> & ConsumeInstance & ConsumeId, {}>; declare namespace save { var extension: ActionParsedExtension<{ save>(this: Action, E>, instance: ModelClassInstance & I): Action> & ConsumeInstance & ConsumeId, E>; }>; } /** * Prepare context for an instance update. * * @param instance * * @category Enhancers */ declare function update>(instance: ModelClassInstance & I): (action: Action>) => Action> & { model: Model; }> & { modelPath: string; baseURL: string | undefined; }> & { instance: I; }> & { id: ModelId | undefined; } & ConsumeSerializer> & { data: Awaited; }> & { action: string; } & ConsumeInstance, {}>; declare namespace update { var extension: ActionParsedExtension<{ update>(this: Action, E>, instance: ModelClassInstance & I): Action> & ConsumeInstance & ConsumeId, E>; }>; } /** * Target the given ID. * * @param id * * @category Enhancers */ declare function forId(id: ModelId | undefined): (action: Action) => Promise & { id: ModelId | undefined; }, {}>>; declare namespace forId { var extension: ActionParsedExtension<{ forId(this: Action, id: Id): Action; }>; } /** * Target the given instance. * Use its type and other applicable model's context. * * @param instance * * @category Enhancers */ declare function forInstance>(instance: ModelClassInstance & I): (action: Action) => Action & { model: Model; }> & { modelPath: string; baseURL: string | undefined; }> & { instance: I; }> & { id: ModelId | undefined; }, {}>; declare namespace forInstance { var extension: ActionParsedExtension<{ forInstance>(this: Action, instance: ModelClassInstance & I): Action> & ConsumeInstance & ConsumeId, E>; }>; } /** * Target the given model. * Use its type and other applicable model's context. * * @param model * * @category Enhancers */ declare function forModel, M extends Model>(model: M): (action: Action) => Action & { model: M; }> & { modelPath: string; baseURL: string | undefined; }, {}>; declare namespace forModel { var extension: ActionParsedExtension<{ forModel>(this: Action, model: M): Action, E>; }>; } /** * Target the given instance's relation. * Use its type and other applicable model/relation context. * * @param instance * @param relationKey * * @category Enhancers */ declare function forRelation, K extends keyof ModelSchema>(instance: ModelClassInstance & I, relationKey: K & ModelRelationKey): (action: Action) => Action & { model: Model; }> & { modelPath: string; baseURL: string | undefined; }> & { instance: I; }> & { id: ModelId | undefined; }> & { relationPath: string; relation: D[K]; }, {}>; declare namespace forRelation { var extension: ActionParsedExtension<{ forRelation>(this: Action, instance: ModelClassInstance & I, relation: ModelRelationKey): Action> & ConsumeInstance & ConsumeId, E>; }>; } /** * Register a "error" hook callback on action. * Callback may be async. * * @param callback * * @category Enhancers */ declare function onError(callback: (event: { context: C; error: unknown; }) => Awaitable): (action: Action) => void; declare namespace onError { var extension: ActionParsedExtension<{ onError(this: Action, callback: (event: { context: C; error: unknown; }) => Awaitable): Action; }>; } /** * Register a "finally" hook callback on action. * Callback may be async. * * @param callback * * @category Enhancers */ declare function onFinally(callback: (event: { context: C; }) => Awaitable): (action: Action) => void; declare namespace onFinally { var extension: ActionParsedExtension<{ onFinally(this: Action, callback: (event: { context: C; }) => Awaitable): Action; }>; } /** * Register a "preparing" hook callback on action. * Callback may be async. * * @param callback * * @category Enhancers */ declare function onPreparing(callback: () => Awaitable): (action: Action) => Action; declare namespace onPreparing { var extension: ActionParsedExtension<{ onPreparing(this: Action, callback: () => Awaitable): Action; }>; } /** * Register a "running" hook callback on action. * Callback may be async. * * @param callback * * @category Enhancers */ declare function onRunning(callback: (event: { context: C; runner: Function; }) => Awaitable): (action: Action) => void; declare namespace onRunning { var extension: ActionParsedExtension<{ onRunning(this: Action, callback: (event: { context: C; runner: Function; }) => Awaitable): Action; }>; } /** * Register a "success" hook callback on action. * Callback may be async. * * @param callback * * @category Enhancers */ declare function onSuccess(callback: (event: { context: C; result: unknown; }) => Awaitable): (action: Action) => void; declare namespace onSuccess { var extension: ActionParsedExtension<{ onSuccess(this: Action, callback: (event: { context: C; result: unknown; }) => Awaitable): Action; }>; } /** * Eager load the given relations for the current model definition. It accepts * deep relations through dot notation. The new relations will be merged with * the previous ones. * * @param relations * * @category Enhancers */ declare function include(...relations: ArrayableVariadic>): (action: Action>) => Promise> & { include: string[]; }, {}>>; declare namespace include { var extension: ActionParsedExtension<{ include>(this: Action, E>, ...relations: ArrayableVariadic extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : K | `${K}.${keyof ModelInferDefinition extends infer K ? K extends string & K & keyof ModelInferDefinition ? ModelSchema>[K] extends never ? never : ModelSchema>[K] extends ModelRelation ? T extends any[] ? K : K : never : never : never}` : never : never : never}` : never : never : never}` : never : never : never}` : never : never : never>): Action; }>; } /** * Only target the given model. * In most cases, you should use {@link forModel}, {@link find} or any other * model's enhancers instead of `target`. * * @param model * * @category Enhancers */ declare function target, M extends Model>(model: M): (action: Action) => Promise & { model: M; }, {}>>; declare namespace target { var extension: ActionParsedExtension<{ target>(this: Action, model: M): Action, E>; }>; } type DeserializedDataOf = { instances: I[]; } & Omit; type AllData = { data: AD; deserialized: DD; instances: I[]; }; /** * Run the action and deserialize an array of model's instance. * * @param transform * * @category Runners */ declare function all, AD, DD extends DeserializedData, ND = I[]>(transform?: (data: AllData, I>) => Awaitable): (action: Action & ConsumeDeserializer>) => Promise; declare namespace all { var extension: ActionParsedExtension<{ all, AD, DD extends DeserializedData>, ND = I[]>(this: Action & ConsumeDeserializer, {}>, transform?: ((data: AllData, I>) => Awaitable) | undefined): Promise>; }>; } type CachedData = { instance: I; }; /** * Retrieve an instance from the cache. * If the instance is not in cache or if the included relations are not loaded, * run the given runner. * * @param nilRunner * @param transform * * @category Runners */ declare function cachedOr, RD, ND = I>(nilRunner: ContextRunner, Awaitable>, transform?: (data: CachedData) => Awaitable): (action: Action & ConsumeInclude & ConsumeId>) => Promise; declare namespace cachedOr { var extension: ActionParsedExtension<{ cachedOr, I extends InstanceType, RD, ND = I>(this: Action & ConsumeInclude & ConsumeId, {}>, nilRunner: ContextRunner, Awaitable>, transform?: ((data: CachedData) => Awaitable) | undefined): Promise | Awaited>; }>; } /** * Retrieve an instance from the cache. * If the instance is not in cache or if the included relations are not loaded, * returns null. * * @category Runners */ declare function cached, ND = I>(transform?: (data: CachedData) => Awaitable): (action: Action & ConsumeInclude & ConsumeId, {}>) => Promise; declare namespace cached { var extension: ActionParsedExtension<{ cached, I extends InstanceType, ND = I>(this: Action & ConsumeInclude & ConsumeId, {}>, transform?: ((data: CachedData) => Awaitable) | undefined): Promise; }>; } /** * Retrieve an instance from the cache. * If the instance is not in cache or if the included relations are not loaded, * throws an "ExpectedRunFailureError". * * @category Runners */ declare function cachedOrFail, ND = I>(transform?: (data: CachedData) => Awaitable): (action: Action & ConsumeInclude & ConsumeId, {}>) => Promise; declare namespace cachedOrFail { var extension: ActionParsedExtension<{ cachedOrFail, I extends InstanceType, ND = I>(this: Action & ConsumeInclude & ConsumeId, {}>, transform?: ((data: CachedData) => Awaitable) | undefined): Promise; }>; } /** * Run the action and ignore the content of the result. * Adapter errors are not caught and so may be thrown. * * @category Runners */ declare function none(): (action: Action) => Promise; declare namespace none { var extension: ActionParsedExtension<{ none(this: Action, {}>): Promise; }>; } type OneData = AllData & { instance: I; }; /** * Run the action and deserialize one model's instance. * * @param nilRunner * @param transform * * @category Runners */ declare function oneOr, AD, DD extends DeserializedData, RD, ND = I>(nilRunner: ContextRunner & ConsumeDeserializer, Awaitable>, transform?: (data: OneData, I>) => Awaitable): (action: Action & ConsumeDeserializer>) => Promise; declare namespace oneOr { var extension: ActionParsedExtension<{ oneOr, AD, DD extends DeserializedData>, RD, ND = I>(this: Action & ConsumeDeserializer, {}>, nilRunner: ContextRunner & ConsumeDeserializer, RD>, transform?: ((data: OneData, I>) => Awaitable) | undefined): Promise | Awaited>; }>; } /** * Run the action and deserialize one model's instance. * Returns null when not found or empty result. * * @category Runners */ declare function one, AD, DD extends DeserializedData, ND = I>(transform?: (data: OneData, I>) => Awaitable): (action: Action & ConsumeDeserializer, {}>) => Promise; declare namespace one { var extension: ActionParsedExtension<{ one, AD, DD extends DeserializedData>, ND = I>(this: Action & ConsumeDeserializer>>, {}>, transform?: ((data: OneData, I>) => Awaitable) | undefined): Promise; }>; } /** * Run the action and deserialize one model's instance. * Returns current instance when not found or empty result. * * @category Runners */ declare function oneOrCurrent, CI extends ModelInstance, I extends InferConsumedInstance, AD, DD extends DeserializedData, ND = CI>(transform?: (data: OneData, I>) => Awaitable): (action: Action & ConsumeAdapter & ConsumeDeserializer, {}>) => Promise; declare namespace oneOrCurrent { var extension: ActionParsedExtension<{ oneOrCurrent, CI extends ModelInstance, I extends InferConsumedInstance, AD, DD extends DeserializedData>, ND = I>(this: Action & ConsumeDeserializer>> & ConsumeInstance, {}>, transform?: ((data: OneData, I>) => Awaitable) | undefined): Promise; }>; } /** * Run the action and deserialize one model's instance. * Throw an "ExpectedRunFailureError" when not found or empty result. * * @category Runners */ declare function oneOrFail, AD, DD extends DeserializedData, ND = I>(transform?: (data: OneData, I>) => Awaitable): (action: Action & ConsumeDeserializer, {}>) => Promise; declare namespace oneOrFail { var extension: ActionParsedExtension<{ oneOrFail, AD, DD extends DeserializedData>, ND = I>(this: Action & ConsumeDeserializer>>, {}>, transform?: ((data: OneData, I>) => Awaitable) | undefined): Promise; }>; } /** * Run the action and retrieve the raw adapter's data. * * @category Runners */ declare function raw(transform?: (data: AD) => Awaitable): (action: Action>) => Promise; declare namespace raw { var extension: ActionParsedExtension<{ raw(this: Action, {}>): Promise; }>; } /** * Takes a dictionary of enhancers and returns an extension providing * those enhancers features. * * @param enhancersMap * * @todo This function returns value should be generically typed. */ declare function makeEnhancersExtension = {}>(enhancersMap: E): ActionParsedExtension<{}>; /** Takes a dictionary of runners and returns an extension providing those runners features. * * @param runnersMap * * @todo This function returns value should be generically typed. */ declare function makeRunnersExtension ContextRunner> = {}>(runnersMap: R): ActionParsedExtension<{}>; declare function makeActionClass(extensions?: Extension): ActionClass<{}, Extension>; declare function when(expression: V, truthyCallback: (action: Action, value: OnlyTruthy>>) => Awaitable | void>): ContextEnhancer; declare function when(expression: V, truthyCallback: (action: Action, value: OnlyTruthy>>) => Awaitable | void>, falsyCallback: (action: Action, value: OnlyFalsy>>) => Awaitable | void>): ContextEnhancer; declare function when(expression: V, truthyCallback: (action: Action, value: OnlyTruthy>>) => TR): ContextRunner; declare function when(expression: V, truthyCallback: (action: Action, value: OnlyTruthy>>) => TR, falsyCallback: (action: Action, value: OnlyFalsy>>) => FR): ContextRunner; declare namespace when { var extension: ActionParsedExtension<{ when(this: Action, expression: V, truthyCallback: (action: Action, value: OnlyTruthy>>) => Awaitable>): Action; when(this: Action, expression: V_1, truthyCallback: (action: Action, value: OnlyTruthy>>) => Awaitable>, falsyCallback: (action: Action, value: OnlyFalsy>>) => Awaitable>): Action; when(this: Action, expression: V_2, truthyCallback: (action: Action, value: OnlyTruthy>>) => TR): Promise; when(this: Action, expression: V_3, truthyCallback: (action: Action, value: OnlyTruthy>>) => TR_1, falsyCallback?: ((action: Action, value: OnlyFalsy>>) => FR) | undefined): Promise; }>; } export { Action, ActionClass, ActionHooksDefinition, ActionParsedExtension, AdapterError, AdapterI, AllData, CacheI, ConsumeAction, ConsumeAdapter, ConsumeCache, ConsumeData, ConsumeDeserializer, ConsumeId, ConsumeInclude, ConsumeInstance, ConsumeModel, ConsumeModelPath, ConsumeRegistry, ConsumeRelation, ConsumeRelationPath, ConsumeSerializer, ContextEnhancer, ContextRunner, DeserializedData, DeserializerError, DeserializerI, ExpectedRunFailureError, ExtendedAction, FosciaError, FunctionTransform, HookCallback, Hookable, HooksDefinition, HooksRegistrar, InferConsumedInstance, MapRegistry, MapRegistryConfig, Model, ModelAttribute, ModelAttributeRaw, ModelClass, ModelClassInstance, ModelClassOrInstance, ModelConfig, ModelHookCallback, ModelHooksDefinition, ModelId, ModelInferDefinition, ModelInferSchema, ModelInstance, ModelKey, ModelParsedDefinition, ModelPreparator, ModelPropNormalized, ModelPropRaw, ModelPropSync, ModelRelation, ModelRelationDotKey, ModelRelationKey, ModelRelationRaw, ModelRelationType, ModelRelationTypeGuesser, ModelResolver, ModelSchema, ModelSnapshot, ModelValues, Normalizer, ObjectTransform, OneData, RefsCache, RefsCacheConfig, RefsCacheMode, RegistryI, SerializerError, SerializerI, Transform, all, attr, cached, cachedOr, cachedOrFail, changed, compareSnapshots, consumeAction, consumeAdapter, consumeCache, consumeContext, consumeData, consumeDeserializer, consumeId, consumeInclude, consumeInstance, consumeModel, consumeModelPath, consumeRegistry, consumeRelation, consumeRelationPath, consumeSerializer, context, create, destroy, eachAttributes, eachProps, eachRelations, fill, find, forId, forInstance, forModel, forRelation, hasMany, hasOne, include, instanceData, isAttributeDef, isInstance, isModel, isPluralRelationDef, isPropDef, isRelationDef, isSame, loaded, _default$1 as logger, makeActionClass, makeComposable, makeEnhancersExtension, _default as makeModel, makeModelFactory, makeRunnersExtension, markSynced, none, normalizeDotRelations, normalizeInclude, normalizeKey, onCreated, onCreating, onDestroyed, onDestroying, onError, onFinally, onPreparing, onRetrieved, onRunning, onSaved, onSaving, onSuccess, onUpdated, onUpdating, one, oneOr, oneOrCurrent, oneOrFail, raw, registerHook, restore, restoreSnapshot, runHook, save, shouldSync, takeSnapshot, target, toBoolean, toDate, toNumber, toString, unregisterHook, update, weakRefCacheMode, when, withoutHooks };