@decaf-ts/core 0.23.0 → 0.25.0

package/lib/types/repository/injectables.d.ts

@@ -1,95 +0,0 @@
-import { InjectableRegistryImp } from "@decaf-ts/injectable-decorators";
-import { Logger } from "@decaf-ts/logging";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Registry for injectable repositories with auto-resolution.
- * @summary Provides an InjectableRegistry implementation that resolves repositories by model name or constructor. If a repository
- * is not explicitly registered, it attempts to infer the correct repository using model metadata and the active or specified adapter flavour.
- * @param {void} [constructor] No constructor parameters required; the superclass handles internal state.
- * @class InjectablesRegistry
- * @example
- * // Basic usage: retrieve a repository by model name
- * const registry = new InjectablesRegistry();
- * const userRepo = registry.get<UserRepository>('User');
- * // If UserRepository is registered, it will be returned. Otherwise, a repository will be created if a User model exists.
- *
- * // Retrieve by constructor and specify adapter flavour
- * const repoByCtor = registry.get<UserRepository>(UserModel, 'ram');
- *
- * // Retrieve by symbol (e.g., injectable token)
- * const token = Symbol.for('UserRepository');
- * const byToken = registry.get<UserRepository>(token);
- * @mermaid
- * sequenceDiagram
- *   participant C as Consumer
- *   participant R as InjectablesRegistry
- *   participant B as BaseRegistry
- *   participant M as Model
- *   participant A as Adapter
- *   participant RP as Repository
- *   C->>R: get(name, flavour?)
- *   activate R
- *   R->>B: super.get(name)
- *   alt Found in base registry
- *     B-->>R: injectable
- *     R-->>C: injectable
- *   else Not found
- *     R->>M: Model.get(name)
- *     alt Model found
- *       R->>A: resolve flavour (from arg/metadata/current)
- *       R->>RP: Repository.forModel(modelCtor, alias)
- *       alt Repository instance
- *         RP-->>R: repository instance
- *         R-->>C: repository instance
- *       else Repository ctor
- *         R->>A: Adapter.get(resolvedFlavour) or Adapter.current
- *         A-->>R: adapter instance
- *         R->>RP: new repoCtor(adapter, modelCtor)
- *         R-->>C: repository instance
- *       end
- *     else Model not found
- *       R-->>C: undefined
- *     end
- *   end
- */
-export declare class InjectablesRegistry extends InjectableRegistryImp {
-    private logger?;
-    protected get log(): Logger;
-    constructor();
-    /**
-     * @description Retrieve an injectable with repository auto-resolution.
-     * @summary Attempts to get an injectable from the base registry; if not found and the name refers to a known model, it
-     * resolves the appropriate repository using the specified flavour or model metadata, falling back to the current adapter when needed.
-     * @template T The injectable type to be returned.
-     * @param {string | symbol | Constructor<T>} name Token, model name, or constructor associated with the injectable or model.
-     * @param {string} [flavour] Optional adapter flavour (e.g., "ram"). If omitted, derives from metadata or current adapter.
-     * @return {T | undefined} The located or auto-created injectable instance; otherwise undefined if it cannot be resolved.
-     * @mermaid
-     * sequenceDiagram
-     *   participant G as get(name, flavour?)
-     *   participant BR as BaseRegistry
-     *   participant M as Model
-     *   participant A as Adapter
-     *   participant RP as Repository
-     *   G->>BR: super.get(name)
-     *   alt Found
-     *     BR-->>G: injectable
-     *   else Not found
-     *     G->>M: derive modelCtor from name
-     *     alt modelCtor resolved
-     *       G->>A: resolve flavour (arg | metadata | current)
-     *       G->>RP: Repository.forModel(modelCtor, alias)
-     *       alt returns instance
-     *         RP-->>G: Repository instance
-     *       else returns ctor
-     *         G->>A: Adapter.get(flavour) | Adapter.current
-     *         A-->>G: adapter instance
-     *         G->>RP: new repoCtor(adapter, modelCtor)
-     *       end
-     *     else no modelCtor
-     *       G-->>G: return undefined
-     *     end
-     *   end
-     */
-    get<T>(name: symbol | Constructor<T> | string, flavour?: string): T | undefined;
-}

package/lib/types/repository/types.d.ts

@@ -1,28 +0,0 @@
-import { Cascade, OrderDirection } from "./constants";
-/**
- * @description Metadata for cascade operations on related entities.
- * @summary Defines how update and delete operations should cascade to related entities.
- * @typedef CascadeMetadata
- * @property {Cascade} update - Determines cascade behavior for update operations.
- * @property {Cascade} delete - Determines cascade behavior for delete operations.
- * @memberOf module:core
- */
-export type CascadeMetadata = {
-    update: Cascade;
-    delete: Cascade;
-};
-export type IndexMetadata = {
-    name?: string;
-    directions?: OrderDirection[2];
-    compositions?: string[];
-};
-/**
- * @description Metadata for a named index that extends IndexMetadata.
- * @summary Extends IndexMetadata with a suffix to identify the index.
- * @typedef NamedIndexMetadata
- * @property {string} suffix - The suffix to append to the index name.
- * @memberOf module:core
- */
-export type NamedIndexMetadata = IndexMetadata & {
-    suffix: string;
-};

package/lib/types/repository/utils.d.ts

@@ -1,36 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Generates a unique injectable name for a repository.
- * @summary Creates a standardized injectable token for repositories using the adapter flavour and model table name.
- * This helps the DI system register and resolve repository instances consistently across adapters.
- * @template T The model type that extends Model.
- * @param {Constructor<T> | T} model The model constructor or instance from which to derive the table name.
- * @param {string} [flavour] Optional adapter flavour/alias. If omitted, it is read from model metadata.
- * @return {string} A namespaced injectable token for the repository (e.g., "db:repo:ram:users").
- * @throws {InternalError} If the flavour cannot be determined from arguments or metadata.
- * @function generateInjectableNameForRepository
- * @mermaid
- * sequenceDiagram
- *   participant C as Caller
- *   participant U as generateInjectableNameForRepository
- *   participant R as Reflect Metadata
- *   participant A as Adapter
- *   participant S as String Formatter
- *   C->>U: call(model, flavour?)
- *   alt flavour provided
- *     U-->>U: use provided flavour
- *   else flavour not provided
- *     U->>A: ADAPTER
- *     U->>R: getMetadata(key, model|model.ctor)
- *     alt metadata present
- *       R-->>U: flavour
- *     else missing
- *       U-->>C: throw InternalError
- *     end
- *   end
- *   U->>S: sf(INJECTABLE, flavour, Model.tableName(model))
- *   S-->>C: token string
- * @memberOf module:core
- */
-export declare function generateInjectableNameForRepository<T extends Model>(model: Constructor<T> | T, flavour?: string): string;

package/lib/types/services/ModelService.d.ts

@@ -1,45 +0,0 @@
-import { type Constructor } from "@decaf-ts/decoration";
-import { Model, type ModelConstructor } from "@decaf-ts/decorator-validation";
-import { type Repo } from "../repository/Repository";
-import { Service } from "./services";
-import type { AllOperationKeys, ContextOf, EventIds, ObserverFilter, PersistenceObservable, PersistenceObserver } from "../persistence/types";
-import { type IRepository, type PrimaryKeyType } from "@decaf-ts/db-decorators";
-import type { ContextualArgs, ContextualizedArgs, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass";
-import { OrderDirection } from "../repository/constants";
-import { type DirectionLimitOffset } from "../query/types";
-import { type Observer } from "../interfaces";
-import { SelectSelector, WhereOption } from "../query/index";
-export type ArrayMode = "one" | "many";
-export declare class ModelService<M extends Model<boolean>, R extends Repo<M> = Repo<M>> extends Service implements IRepository<M, ContextOf<R>>, PersistenceObservable<ContextOf<R>>, PersistenceObserver<ContextOf<R>> {
-    private readonly clazz;
-    protected _repository: R;
-    get class(): Constructor<M>;
-    get repo(): R;
-    constructor(clazz: Constructor<M>, name?: string);
-    static getService<M extends Model<boolean>, S extends ModelService<M>>(name: string | symbol | Constructor<M>): S;
-    create(model: M, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M>;
-    createAll(models: M[], ...args: MaybeContextualArg<ContextOf<R>>): Promise<M[]>;
-    delete(key: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M>;
-    deleteAll(keys: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<R>>): Promise<M[]>;
-    read(key: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M>;
-    readAll(keys: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<R>>): Promise<M[]>;
-    query<M, R extends ArrayMode = "one">(methodName: string, ...args: unknown[]): Promise<R extends "one" ? M : M[]>;
-    update(model: M, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M>;
-    updateAll(models: M[], ...args: any[]): Promise<M[]>;
-    select<S extends readonly SelectSelector<M>[]>(): WhereOption<M, M[]>;
-    select<S extends readonly SelectSelector<M>[]>(selector: readonly [...S]): WhereOption<M, Pick<M, S[number]>[]>;
-    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M[]>;
-    paginateBy(key: keyof M, order: OrderDirection, ref: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<R>>): Promise<import("..").SerializedPage<M>>;
-    findOneBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M>;
-    findBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<R>>): Promise<M[]>;
-    findByPaginate(key: keyof M, value: any, ref: DirectionLimitOffset, ...args: MaybeContextualArg<ContextOf<R>>): Promise<import("..").SerializedPage<M>>;
-    statement(name: string, ...args: MaybeContextualArg<ContextOf<R>>): Promise<any>;
-    static forModel<M extends Model<boolean>, S extends ModelService<M>>(this: new (model: ModelConstructor<M>) => S, model: ModelConstructor<M>, alias?: string | symbol): S;
-    refresh(table: Constructor<M>, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<ContextOf<R>>): Promise<void>;
-    observe(observer: Observer, filter?: ObserverFilter): () => void;
-    unObserve(observer: Observer): void;
-    updateObservers(model: Constructor, operation: AllOperationKeys, ids: EventIds, ...args: ContextualArgs<ContextOf<R>>): Promise<void>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<this["repo"]>, ARGS>, operation: METHOD): ContextualizedArgs<ContextOf<this["repo"]>, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<this["repo"]>, ARGS>, operation: METHOD, allowCreate: false): ContextualizedArgs<ContextOf<this["repo"]>, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<this["repo"]>, ARGS>, operation: METHOD, allowCreate: true): Promise<ContextualizedArgs<ContextOf<this["repo"]>, ARGS, METHOD extends string ? true : false>>;
-}

package/lib/types/services/PersistenceService.d.ts

@@ -1,17 +0,0 @@
-import { ClientBasedService } from "./services";
-import { Adapter } from "../persistence/Adapter";
-import { ConfigOf, ContextOf } from "../persistence/types";
-import { MaybeContextualArg } from "../utils/ContextualLoggedClass";
-import { Constructor } from "@decaf-ts/decoration";
-export declare class PersistenceService<A extends Adapter<any, any, any, any>> extends ClientBasedService<A[], [
-    Constructor<A>,
-    ConfigOf<A>,
-    ...args: any[]
-][], ContextOf<A>> {
-    constructor();
-    for(conf: any, ...args: any[]): this;
-    initialize(...args: MaybeContextualArg<ContextOf<A>>): Promise<{
-        config: [Constructor<A>, ConfigOf<A>, ...args: any[]][];
-        client: A[];
-    }>;
-}

package/lib/types/services/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * @description Exports for the services module.
- * @summary This file exports all the necessary components for the services functionality, including ModelService, PersistenceService, and services.
- * @module core/services
- */
-export * from "./ModelService";
-export * from "./PersistenceService";
-export * from "./services";

package/lib/types/services/services.d.ts

@@ -1,96 +0,0 @@
-import type { AllOperationKeys, ContextFlags, EventIds, FlagsOf, ObserverFilter, PersistenceObservable, PersistenceObserver } from "../persistence/types";
-import { Context } from "../persistence/Context";
-import { ContextualArgs, ContextualizedArgs, ContextualLoggedClass, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass";
-import { Constructor } from "@decaf-ts/decoration";
-import type { Observer } from "../interfaces/Observer";
-import { ObserverHandler } from "../persistence/ObserverHandler";
-export declare abstract class Service<C extends Context<ContextFlags<any>> = Context<ContextFlags<any>>> extends ContextualLoggedClass<C> implements PersistenceObservable<C>, PersistenceObserver<C> {
-    readonly name?: string | undefined;
-    protected observers: Observer[];
-    protected observerHandler?: ObserverHandler;
-    protected constructor(name?: string | undefined);
-    for(conf: any, ...args: any[]): this;
-    override(conf: any, ...args: any[]): this;
-    /**
-     * @description Registers an observer for this repository.
-     * @summary Adds an observer that will be notified of changes to models in this repository.
-     * @param {Observer} observer - The observer to register.
-     * @param {ObserverFilter} [filter] - Optional filter to limit which events the observer receives.
-     * @return {void}
-     * @see {Observable#observe}
-     */
-    observe(observer: Observer, filter?: ObserverFilter): () => void;
-    /**
-     * @description Unregisters an observer from this repository.
-     * @summary Removes an observer so it will no longer receive notifications of changes.
-     * @param {Observer} observer - The observer to unregister.
-     * @return {void}
-     * @throws {InternalError} If the observer handler is not initialized.
-     * @see {Observable#unObserve}
-     */
-    unObserve(observer: Observer): void;
-    /**
-     * @description Notifies all observers of an event.
-     * @summary Updates all registered observers with information about a database event.
-     * @param {string} table - The table name where the event occurred.
-     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
-     * @param {EventIds} id - The ID or IDs of the affected records.
-     * @param {...any[]} args - Additional arguments.
-     * @return {Promise<void>} A promise that resolves when all observers have been notified.
-     * @throws {InternalError} If the observer handler is not initialized.
-     */
-    updateObservers(table: Constructor<any> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<C>): Promise<void>;
-    /**
-     * @description Creates repository flags for an operation
-     * @summary Generates a set of flags that describe a database operation, combining default flags with overrides
-     * @template F - The Repository Flags type
-     * @template M - The model type
-     * @param {OperationKeys} operation - The type of operation being performed
-     * @param {Partial<F>} flags - Custom flag overrides
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<F>} The complete set of flags
-     */
-    protected flags(operation: string, flags: Partial<FlagsOf<C>>, ...args: any[]): Promise<FlagsOf<C>>;
-    /**
-     * @description Alias for updateObservers.
-     * @summary Notifies all observers of an event (alias for updateObservers).
-     * @param {string} table - The table name where the event occurred.
-     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
-     * @param {EventIds} id - The ID or IDs of the affected records.
-     * @param {...any[]} args - Additional arguments.
-     * @return {Promise<void>} A promise that resolves when all observers have been notified.
-     */
-    refresh(table: Constructor<any> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<C>): Promise<void>;
-    /**
-     * @description The context constructor for this adapter
-     * @summary Reference to the context class constructor used by this adapter
-     */
-    protected readonly Context: Constructor<C>;
-    context(operation: ((...args: any[]) => any) | string, overrides: Partial<FlagsOf<C>>, ...args: MaybeContextualArg<Context<any>>): Promise<C>;
-    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<CONTEXT>>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<CONTEXT>>): Promise<ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>>;
-    /**
-     * @description Retrieves a Service instance by name/class
-     * @summary Looks up and returns a cached API instance by its name or constructor
-     * @template A Type extending Api
-     * @param {string | Constructor<A>} name - Name of the API or its constructor
-     * @return {A} The requested API instance
-     */
-    static get<A extends Service>(name: string | symbol | Constructor<A>): A;
-    static boot<C extends Context<any> = any>(...args: MaybeContextualArg<C>): Promise<void>;
-    static shutdown<C extends Context<any> = any>(...args: MaybeContextualArg<C>): Promise<void>;
-}
-export declare abstract class ClientBasedService<CLIENT, CONF, C extends Context<any> = any> extends Service {
-    protected _client?: CLIENT;
-    protected _config?: CONF;
-    protected constructor();
-    boot(...args: MaybeContextualArg<C>): Promise<void>;
-    abstract initialize(...args: ContextualArgs<C>): Promise<{
-        config: CONF;
-        client: CLIENT;
-    }>;
-    protected get config(): CONF;
-    get client(): CLIENT;
-    shutdown(...args: MaybeContextualArg<C>): Promise<void>;
-}

package/lib/types/tasks/CleanUpTask.d.ts

@@ -1,15 +0,0 @@
-import { TaskHandler } from "./TaskHandler";
-import { TaskContext } from "./TaskContext";
-import { type Repo } from "../repository/Repository";
-import { TaskModel } from "./models/TaskModel";
-import { Condition } from "../query/Condition";
-export type CleanUpTaskInput = {
-    successfulExpiry: Date;
-    failedExpiry: Date;
-    cancelledExpiry: Date;
-} | Condition<TaskModel>;
-export declare class CleanUpTask extends TaskHandler<CleanUpTaskInput, TaskModel[]> {
-    protected tasks: Repo<TaskModel>;
-    constructor();
-    run(input: CleanUpTaskInput, ctx: TaskContext): Promise<TaskModel[]>;
-}

package/lib/types/tasks/TaskContext.d.ts

@@ -1,30 +0,0 @@
-import { Context } from "../persistence/Context";
-import { TaskFlags } from "./types";
-import { TaskLogger } from "./logging";
-import { DateTarget } from "@decaf-ts/decorator-validation";
-import { TaskErrorModel } from "./models/TaskErrorModel";
-import { TaskStatus } from "./constants";
-import { TaskStateChangeRequest } from "./TaskStateChangeError";
-import { TaskStepSpecModel } from "./models/TaskStepSpecModel";
-export declare class TaskContext extends Context<TaskFlags> {
-    get taskId(): string;
-    get logger(): TaskLogger<any>;
-    get step(): number | undefined;
-    setStep(step?: number): void;
-    get pipe(): TaskFlags["pipe"];
-    flush(): Promise<void>;
-    get attempt(): number;
-    get progress(): (data: any) => Promise<void>;
-    get heartbeat(): () => Promise<void>;
-    cacheResult(taskId: string, payload: any): void;
-    protected changeState(status: TaskStatus, payload?: Partial<TaskStateChangeRequest>): never;
-    cancel(reason?: string | Error | TaskErrorModel, details?: any): never;
-    retry(reason?: string | Error | TaskErrorModel): never;
-    reschedule(when: DateTarget, reason?: string | Error | TaskErrorModel): never;
-    private toTaskError;
-    get resultCache(): Record<string, any> | undefined;
-    scheduleSteps(...steps: (TaskStepSpecModel | Partial<TaskStepSpecModel>)[]): {
-        afterCurrent: () => Promise<void>;
-    };
-    constructor(ctx?: Context<any>);
-}

package/lib/types/tasks/TaskEngine.d.ts

@@ -1,97 +0,0 @@
-import { TaskModel } from "./models/TaskModel";
-import { Repo } from "../repository/Repository";
-import { TaskEventModel } from "./models/TaskEventModel";
-import { TaskHandlerRegistry } from "./TaskHandlerRegistry";
-import { TaskEventBus } from "./TaskEventBus";
-import { TaskStepResultModel } from "./models/TaskStepResultModel";
-import { TaskLogEntryModel } from "./models/TaskLogEntryModel";
-import { TaskBackoffModel } from "./models/TaskBackoffModel";
-import { TaskStepSpecModel } from "./models/TaskStepSpecModel";
-import { TaskEventType, TaskStatus } from "./constants";
-import { Adapter } from "../persistence/Adapter";
-import { Context } from "../persistence/Context";
-import { ContextOf, FlagsOf } from "../persistence/types";
-import { LogLevel } from "@decaf-ts/logging";
-import { AbsContextual, ContextualArgs, MaybeContextualArg } from "../utils/ContextualLoggedClass";
-import { OperationKeys } from "@decaf-ts/db-decorators";
-import { TaskContext } from "./TaskContext";
-import { TaskStateChangeRequest } from "./TaskStateChangeError";
-import { DateTarget } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import { TaskEngineConfig, TaskFlags } from "./types";
-import { TaskTracker } from "./TaskTracker";
-import { Lock } from "@decaf-ts/transactional-decorators";
-type ParsedTaskDependency = {
-    taskId: string;
-    stepRef?: string;
-};
-export declare class TaskEngine<A extends Adapter<any, any, any, any>, C extends TaskEngineConfig<A> = TaskEngineConfig<A>> extends AbsContextual<ContextOf<A>> {
-    protected config: C;
-    private _tasks?;
-    private _events?;
-    private _adapter?;
-    protected lock: Lock;
-    protected get Context(): Constructor<ContextOf<A>>;
-    protected get adapter(): A;
-    protected get registry(): TaskHandlerRegistry;
-    protected get bus(): TaskEventBus;
-    protected get tasks(): Repo<TaskModel>;
-    protected get events(): Repo<TaskEventModel>;
-    protected running: boolean;
-    private idleDelayMs;
-    static createTaskContext(base?: Context<any>, overrides?: Partial<TaskFlags>): TaskContext;
-    constructor(config: C);
-    push<I, O>(task: TaskModel<I, O>, ...args: MaybeContextualArg<any>): Promise<TaskModel<I, O>>;
-    push<I, O>(task: TaskModel<I, O>, track: false, ...args: MaybeContextualArg<any>): Promise<TaskModel<I, O>>;
-    push<I, O>(task: TaskModel<I, O>, track: true, ...args: MaybeContextualArg<any>): Promise<{
-        task: TaskModel<I, O>;
-        tracker: TaskTracker<(typeof task)["output"]>;
-    }>;
-    schedule<I, O>(task: TaskModel<I, O>, ...args: MaybeContextualArg<any>): {
-        for: (when: DateTarget) => Promise<TaskModel<I, O>>;
-    };
-    schedule<I, O>(task: TaskModel<I, O>, track: false, ...args: MaybeContextualArg<any>): {
-        for: (when: DateTarget) => Promise<TaskModel<I, O>>;
-    };
-    schedule<I, O>(task: TaskModel<I, O>, track: true, ...args: MaybeContextualArg<any>): {
-        for: (when: DateTarget) => Promise<{
-            task: TaskModel<I, O>;
-            tracker: TaskTracker<O>;
-        }>;
-    };
-    track(id: string, ...args: MaybeContextualArg<any>): Promise<{
-        task: TaskModel<any, any>;
-        tracker: TaskTracker<any>;
-    }>;
-    protected ensureTaskError(task: TaskModel, ctx: Context): Promise<TaskModel>;
-    cancel(id: string, ...args: MaybeContextualArg<any>): Promise<TaskModel>;
-    isRunning(): Promise<boolean>;
-    start(...args: MaybeContextualArg<any>): Promise<void>;
-    stop(...args: MaybeContextualArg<any>): Promise<void>;
-    protected loop(...args: ContextualArgs<any>): Promise<void>;
-    protected claimBatch(ctx: Context<any>): Promise<TaskModel[]>;
-    protected tryClaim(task: TaskModel, ctx: Context): Promise<TaskModel | null>;
-    protected isTaskFinished(status?: TaskStatus): boolean;
-    protected parseTaskDependency(value: string): ParsedTaskDependency | undefined;
-    protected normalizeDependencies(deps: string[] | string | undefined): ParsedTaskDependency[];
-    protected resolveDependencyStepIndex(task: TaskModel, stepRef: string): number | undefined;
-    protected areDependenciesSatisfied(dependencies: ParsedTaskDependency[], ctx: Context): Promise<boolean>;
-    protected getStepLock(task: TaskModel, stepIndex: number | undefined): string | undefined;
-    protected hasLockConflict(task: TaskModel, stepIndex: number | undefined, ctx: Context): Promise<boolean>;
-    protected isRunnable(task: TaskModel, ctx: Context): Promise<boolean>;
-    protected executeClaimed(task: TaskModel): Promise<void>;
-    protected handleTaskStateChange(request: TaskStateChangeRequest, task: TaskModel, ctx: TaskContext): Promise<void>;
-    protected runComposite(task: TaskModel, context: TaskContext): Promise<any>;
-    protected normalizeBackoff(backoff: TaskBackoffModel | string | object | any): TaskBackoffModel;
-    protected normalizeSteps(steps: TaskStepSpecModel[] | string | undefined): TaskStepSpecModel[];
-    protected normalizeStepResults(results: TaskStepResultModel[] | string | undefined): TaskStepResultModel[];
-    protected appendLog(ctx: TaskContext | Context, task: TaskModel, logEntries: [LogLevel, string] | [LogLevel, string, any] | ([LogLevel, string] | [LogLevel, string, any])[]): Promise<[TaskModel, TaskLogEntryModel[]]>;
-    protected emitStatus(ctx: TaskContext | Context, task: TaskModel, status: TaskStatus, outputOrError?: any | Error, originalError?: Error): Promise<void>;
-    protected emitLog(ctx: TaskContext | Context, taskId: string, entries: TaskLogEntryModel[]): Promise<void>;
-    protected normalizePipeArgs(args: any[]): ([LogLevel, string] | [LogLevel, string, any])[];
-    protected emitProgress(ctx: TaskContext | Context, taskId: string, data: any): Promise<void>;
-    protected persistEvent(ctx: TaskContext | Context, taskId: string, type: TaskEventType, payload: any): Promise<TaskEventModel>;
-    toString(): string;
-    context(operation: ((...args: any[]) => any) | OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE | string, overrides: Partial<FlagsOf<ContextOf<A>>>, ...args: any[]): Promise<ContextOf<A>>;
-}
-export {};

package/lib/types/tasks/TaskErrors.d.ts

@@ -1,65 +0,0 @@
-import { BaseError } from "@decaf-ts/db-decorators";
-import { TaskErrorModel } from "./models/TaskErrorModel";
-import { TaskStatus } from "./constants";
-/**
- * Represents the next action to take after a task error.
- * Used to identify the appropriate response to task failures.
- */
-export type TaskNextAction = TaskStatus.CANCELED | TaskStatus.WAITING_RETRY | TaskStatus.SCHEDULED | TaskStatus.FAILED;
-/**
- * Additional properties added to errors from TaskTracker.resolve() and TaskTracker.wait()
- */
-export type TaskErrorProps = {
-    /** The next action to take in response to this error */
-    nextAction: TaskNextAction;
-    /** The task ID this error relates to (optional, present on TaskControlError) */
-    taskId?: string;
-    /** Additional error details (optional, present on TaskControlError) */
-    details?: TaskErrorModel;
-    /** Additional metadata (optional, present on TaskControlError) */
-    meta?: Record<string, any>;
-};
-/**
- * Generic type that preserves the original error type while adding task-specific properties.
- * Use this to type errors from TaskTracker.resolve() and TaskTracker.wait().
- *
- * The original error is preserved (e.g., ValidationError stays ValidationError),
- * with the nextAction property added to identify the appropriate response:
- * - `TaskStatus.CANCELED`: Task was explicitly canceled
- * - `TaskStatus.SCHEDULED`: Task was rescheduled
- * - `TaskStatus.WAITING_RETRY`: Task is waiting for retry
- * - `TaskStatus.FAILED`: Task has permanently failed
- *
- * @example
- * ```typescript
- * try {
- *   await tracker.resolve();
- * } catch (error: unknown) {
- *   if (isTaskError<ValidationError>(error, ValidationError)) {
- *     // error is typed as TaskErrorFrom<ValidationError>
- *     console.log(error.nextAction); // TaskNextAction
- *     console.log(error.code);       // ValidationError's code property
- *   }
- * }
- * ```
- */
-export type TaskErrorFrom<E extends Error> = E & TaskErrorProps;
-export declare function isTaskError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E): error is TaskErrorFrom<E>;
-export declare class TaskControlError extends BaseError {
-    readonly taskId: string;
-    readonly details?: TaskErrorModel;
-    readonly meta?: Record<string, any>;
-    constructor(name: string, taskId: string, message: string, details?: TaskErrorModel, meta?: Record<string, any>, code?: number);
-}
-export declare class TaskFailError extends TaskControlError {
-    constructor(taskId: string, details?: TaskErrorModel, meta?: Record<string, any>);
-}
-export declare class TaskRetryError extends TaskControlError {
-    constructor(taskId: string, details?: TaskErrorModel, meta?: Record<string, any>);
-}
-export declare class TaskCancelError extends TaskControlError {
-    constructor(taskId: string, details?: TaskErrorModel, meta?: Record<string, any>);
-}
-export declare class TaskRescheduleError extends TaskControlError {
-    constructor(taskId: string, details?: TaskErrorModel, meta?: Record<string, any>);
-}

package/lib/types/tasks/TaskEventBus.d.ts

@@ -1,17 +0,0 @@
-import { TaskEventModel } from "./models/TaskEventModel";
-import { Context } from "../persistence/Context";
-import { ObserverHandler } from "../persistence/ObserverHandler";
-import { EventIds, ObserverFilter } from "../persistence/types";
-import { TaskContext } from "./TaskContext";
-import { Observer } from "../interfaces/Observer";
-import { Constructor } from "@decaf-ts/decoration";
-import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
-import { ContextualArgs } from "../utils/index";
-import { Model } from "@decaf-ts/decorator-validation";
-export declare class TaskEventBus extends ObserverHandler<TaskContext> {
-    protected readonly listeners: Set<(evt: TaskEventModel) => void>;
-    observe(observer: Observer, filter?: ObserverFilter): () => void;
-    unObserve(observer: Observer): void;
-    emit(evt: TaskEventModel, ctx: Context): void;
-    updateObservers<M extends Model>(model: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, evt: TaskEventModel, ...args: ContextualArgs<any>): Promise<void>;
-}

package/lib/types/tasks/TaskEventService.d.ts

@@ -1,7 +0,0 @@
-import { type Repo } from "../repository/Repository";
-import { ModelService } from "../services/ModelService";
-import { TaskEventModel } from "./models/TaskEventModel";
-export declare class TaskEventService extends ModelService<TaskEventModel> {
-    constructor();
-    get repo(): Repo<TaskEventModel>;
-}

package/lib/types/tasks/TaskHandler.d.ts

@@ -1,12 +0,0 @@
-import { ITaskHandler } from "./types";
-import { AbsContextual, ContextualArgs } from "../utils/ContextualLoggedClass";
-import { TaskContext } from "./TaskContext";
-export declare abstract class TaskHandler<I, O> extends AbsContextual<TaskContext> implements ITaskHandler<I, O> {
-    private _type?;
-    get type(): string;
-    protected constructor();
-    protected runPrefix(input: I, ...args: ContextualArgs<TaskContext>): Promise<any[]>;
-    protected runSuffix(output: O, ctx: TaskContext): O;
-    catch(input: I, error: unknown, ctx: TaskContext): Promise<void>;
-    abstract run(input: I, ctx: TaskContext): Promise<O>;
-}

package/lib/types/tasks/TaskHandlerRegistry.d.ts

@@ -1,8 +0,0 @@
-import { ITaskHandler } from "./types";
-export declare class TaskHandlerRegistry {
-    private readonly handlers;
-    constructor();
-    protected initialize(): void;
-    register(handler: ITaskHandler): void;
-    get(type: string): ITaskHandler | undefined;
-}