@bluelibs/runner 4.8.6 → 5.0.0

package/dist/models/EventManager.d.ts

@@ -1,153 +0,0 @@
-import { DependencyValuesType, EventHandlerType, IEvent, IEventEmission } from "../defs";
-import { IHook } from "../types/hook";
-/**
- * Options for configuring event listeners
- */
-export interface IEventHandlerOptions<T = any> {
-    order?: number;
-    filter?: (event: IEventEmission<T>) => boolean;
-    /**
-     * Represents the listener ID. Use this to avoid a listener calling himself.
-     */
-    id?: string;
-}
-/**
- * Interceptor for event emissions
- */
-export type EventEmissionInterceptor = (next: (event: IEventEmission<any>) => Promise<void>, event: IEventEmission<any>) => Promise<void>;
-/**
- * Interceptor for hook execution
- */
-export type HookExecutionInterceptor = (next: (hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>, hook: IHook<any, any>, event: IEventEmission<any>) => Promise<any>;
-/**
- * EventManager handles event emission, listener registration, and event processing.
- * It supports both specific event listeners and global listeners that handle all events.
- * Listeners are processed in order based on their priority.
- */
-export declare class EventManager {
-    #private;
-    private listeners;
-    private globalListeners;
-    private cachedMergedListeners;
-    private globalListenersCacheValid;
-    private emissionInterceptors;
-    private hookInterceptors;
-    private readonly emissionStack;
-    private readonly currentHookIdContext;
-    private readonly runtimeCycleDetection;
-    constructor(options?: {
-        runtimeCycleDetection?: boolean;
-    });
-    /**
-     * Gets the current lock status of the EventManager
-     */
-    get isLocked(): boolean;
-    /**
-     * Locks the EventManager, preventing any further modifications to listeners
-     */
-    lock(): void;
-    /**
-     * Emits an event to all registered listeners for that event type.
-     * Listeners are processed in order of priority and can stop event propagation.
-     *
-     * @param eventDefinition - The event definition to emit
-     * @param data - The event payload data
-     * @param source - The source identifier of the event emitter
-     */
-    emit<TInput>(eventDefinition: IEvent<TInput>, data: TInput, source: string): Promise<void>;
-    /**
-     * Registers an event listener for specific event(s).
-     * Listeners are ordered by priority and executed in ascending order.
-     *
-     * @param event - The event definition(s) to listen for
-     * @param handler - The callback function to handle the event
-     * @param options - Configuration options for the listener
-     */
-    addListener<T>(event: IEvent<T> | Array<IEvent<T>>, handler: EventHandlerType<T>, options?: IEventHandlerOptions<T>): void;
-    /**
-     * Registers a global event listener that handles all events.
-     * Global listeners are mixed with specific listeners and ordered by priority.
-     *
-     * @param handler - The callback function to handle events
-     * @param options - Configuration options for the listener
-     */
-    addGlobalListener(handler: EventHandlerType, options?: IEventHandlerOptions): void;
-    /**
-     * Checks if there are any listeners registered for the given event
-     *
-     * @param eventDefinition - The event definition to check
-     * @returns true if listeners exist, false otherwise
-     */
-    hasListeners<T>(eventDefinition: IEvent<T>): boolean;
-    /**
-     * Adds an interceptor for all event emissions
-     * Interceptors are executed in the order they are added, with the ability to
-     * modify, log, or prevent event emissions
-     *
-     * @param interceptor - The interceptor function to add
-     */
-    intercept(interceptor: EventEmissionInterceptor): void;
-    /**
-     * Adds an interceptor for hook execution
-     * Interceptors are executed in the order they are added, with the ability to
-     * modify, log, or prevent hook execution
-     *
-     * @param interceptor - The interceptor function to add
-     */
-    interceptHook(interceptor: HookExecutionInterceptor): void;
-    /**
-     * Executes a hook with all registered hook interceptors applied
-     * This method should be used by TaskRunner when executing hooks
-     *
-     * @param hook - The hook to execute
-     * @param event - The event that triggered the hook
-     * @param computedDependencies - The computed dependencies for the hook
-     * @returns Promise resolving to the hook execution result
-     */
-    executeHookWithInterceptors(hook: IHook<any, any>, event: IEventEmission<any>, computedDependencies: DependencyValuesType<any>): Promise<any>;
-    /**
-     * Throws an error if the EventManager is locked
-     */
-    private checkLock;
-    /**
-     * Merges two sorted arrays of listeners while maintaining order.
-     * Used to combine event-specific listeners with global listeners.
-     *
-     * @param a - First array of listeners
-     * @param b - Second array of listeners
-     * @returns Merged and sorted array of listeners
-     */
-    private mergeSortedListeners;
-    /**
-     * Inserts a new listener into a sorted array using binary search.
-     * Maintains order based on listener priority.
-     *
-     * @param listeners - Array to insert into
-     * @param newListener - Listener to insert
-     */
-    private insertListener;
-    /**
-     * Returns true if the given emission carries the tag that marks
-     * it as excluded from global ("*") listeners.
-     *
-     * @param event - The event emission to check
-     * @returns true if event should exclude global listeners
-     */
-    private isExcludedFromGlobal;
-    /**
-     * Retrieves cached merged listeners for an event, or creates them if not cached.
-     * Combines event-specific listeners with global listeners and sorts them by priority.
-     *
-     * @param eventId - The event ID to get listeners for
-     * @returns Array of merged listeners sorted by priority
-     */
-    private getCachedMergedListeners;
-    /**
-     * Invalidates the cached merged listeners.
-     * If eventId is provided, only invalidates cache for that specific event.
-     * Otherwise, invalidates the global cache.
-     *
-     * @param eventId - Optional specific event ID to invalidate
-     */
-    private invalidateCache;
-}

package/dist/models/LogPrinter.d.ts

@@ -1,55 +0,0 @@
-export type PrintStrategy = "pretty" | "plain" | "json" | "json_pretty";
-export type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critical";
-export interface PrintableLog {
-    level: LogLevels;
-    source?: string;
-    message: any;
-    timestamp: Date;
-    error?: {
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-}
-export type ColorTheme = {
-    trace: string;
-    debug: string;
-    info: string;
-    warn: string;
-    error: string;
-    critical: string;
-    reset: string;
-    bold: string;
-    dim: string;
-    blue: string;
-    cyan: string;
-    gray: string;
-};
-export declare class LogPrinter {
-    private strategy;
-    private colors;
-    constructor(options: {
-        strategy: PrintStrategy;
-        useColors: boolean;
-        colorTheme?: Partial<ColorTheme>;
-    });
-    print(log: PrintableLog): void;
-    private pickWriter;
-    private formatTime;
-    private formatLevel;
-    private formatSource;
-    private formatMessage;
-    private formatError;
-    private formatData;
-    private formatContext;
-    private normalizeForJson;
-    private static NO_COLORS;
-    private static writers;
-    static setWriters(writers: Partial<{
-        log: (msg: any) => void;
-        error?: (msg: any) => void;
-    }>): void;
-    static resetWriters(): void;
-}

package/dist/models/Logger.d.ts

@@ -1,85 +0,0 @@
-import { LogPrinter, PrintStrategy as PrinterStrategy } from "./LogPrinter";
-export type LogLevels = "trace" | "debug" | "info" | "warn" | "error" | "critical";
-export interface ILogInfo {
-    source?: string;
-    error?: unknown | Error;
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-    [key: string]: any;
-}
-export interface ILog {
-    level: LogLevels;
-    source?: string;
-    message: any;
-    timestamp: Date;
-    error?: {
-        name: string;
-        message: string;
-        stack?: string;
-    };
-    data?: Record<string, any>;
-    context?: Record<string, any>;
-}
-export type PrintStrategy = PrinterStrategy;
-export declare class Logger {
-    private printThreshold;
-    private printStrategy;
-    private bufferLogs;
-    private buffer;
-    private boundContext;
-    private isLocked;
-    private useColors;
-    private printer;
-    private source?;
-    private rootLogger?;
-    localListeners: Array<(log: ILog) => void | Promise<void>>;
-    static Severity: {
-        trace: number;
-        debug: number;
-        info: number;
-        warn: number;
-        error: number;
-        critical: number;
-    };
-    constructor(options: {
-        printThreshold: null | LogLevels;
-        printStrategy: PrintStrategy;
-        bufferLogs: boolean;
-        useColors?: boolean;
-    }, boundContext?: Record<string, any>, source?: string, printer?: LogPrinter);
-    private detectColorSupport;
-    /**
-     * Creates a new logger instance with additional bound context
-     */
-    with({ source, additionalContext: context, }: {
-        source?: string;
-        additionalContext?: Record<string, any>;
-    }): Logger;
-    /**
-     * Core logging method with structured LogInfo
-     */
-    log(level: LogLevels, message: any, logInfo?: ILogInfo): Promise<void>;
-    private extractErrorInfo;
-    info(message: any, logInfo?: ILogInfo): Promise<void>;
-    error(message: any, logInfo?: ILogInfo): Promise<void>;
-    warn(message: any, logInfo?: ILogInfo): Promise<void>;
-    debug(message: any, logInfo?: ILogInfo): Promise<void>;
-    trace(message: any, logInfo?: ILogInfo): Promise<void>;
-    critical(message: any, logInfo?: ILogInfo): Promise<void>;
-    /**
-     * Direct print for tests and advanced scenarios. Delegates to LogPrinter.
-     */
-    print(log: ILog): void;
-    /**
-     * @param listener - A listener that will be triggered for every log.
-     */
-    onLog(listener: (log: ILog) => any): void;
-    /**
-     * Marks the logger as ready.
-     * This is used to trigger the local listeners and print the buffered logs (if they exists)
-     * @returns A promise that resolves when the logger is ready.
-     */
-    lock(): Promise<void>;
-    private canPrint;
-    private triggerLogListeners;
-}

package/dist/models/MiddlewareManager.d.ts

@@ -1,75 +0,0 @@
-import { DependencyMapType, ITask, IResource } from "../defs";
-import { EventManager } from "./EventManager";
-import { Store } from "./Store";
-import { Logger } from "./Logger";
-import { ITaskMiddleware, IResourceMiddleware } from "../defs";
-import { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor } from "./middleware/types";
-export type { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor };
-/**
- * Centralizes middleware composition and execution for both tasks and resources.
- * Keeps observability emissions and unhandled error routing consistent.
- *
- * This is a facade that delegates to specialized composer classes for maintainability.
- */
-export declare class MiddlewareManager {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    private readonly interceptorRegistry;
-    private readonly middlewareResolver;
-    private readonly taskComposer;
-    private readonly resourceComposer;
-    constructor(store: Store, eventManager: EventManager, logger: Logger);
-    /**
-     * @internal
-     */
-    get taskMiddlewareInterceptors(): TaskMiddlewareInterceptor[];
-    /**
-     * @internal
-     */
-    get resourceMiddlewareInterceptors(): ResourceMiddlewareInterceptor[];
-    /**
-     * Gets the current lock status of the MiddlewareManager
-     */
-    get isLocked(): boolean;
-    /**
-     * Locks the MiddlewareManager, preventing any further modifications to interceptors
-     */
-    lock(): void;
-    /**
-     * Adds an interceptor for task or resource middleware execution
-     * Interceptors are executed in the order they are added, with the ability to
-     * modify, log, or prevent middleware execution
-     *
-     * @param kind - The type of middleware to intercept ("task" or "resource")
-     * @param interceptor - The interceptor function to add
-     */
-    intercept(kind: "task" | "resource", interceptor: TaskMiddlewareInterceptor | ResourceMiddlewareInterceptor): void;
-    /**
-     * Adds an interceptor for a specific middleware instance with better type safety
-     * This method automatically determines the type and provides type-safe access
-     *
-     * @param middleware - The middleware instance to intercept
-     * @param interceptor - The interceptor function with proper typing
-     */
-    interceptMiddleware(middleware: ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any>, interceptor: TaskMiddlewareInterceptor | ResourceMiddlewareInterceptor): void;
-    /**
-     * Compose a runner for a task with its local interceptors and applicable middlewares.
-     * Returns a function that accepts the task input and resolves to the task output.
-     */
-    composeTaskRunner<TInput, TOutput extends Promise<any>, TDeps extends DependencyMapType>(task: ITask<TInput, TOutput, TDeps>): (input: TInput) => Promise<Awaited<TOutput>>;
-    /**
-     * Run a resource init wrapped with its applicable middlewares.
-     */
-    runResourceInit<C, V extends Promise<any>, D extends DependencyMapType, TContext>(resource: IResource<C, V, D, TContext>, config: C, dependencies: any, context: TContext): Promise<V | undefined>;
-    /**
-     * Gets all "everywhere" middlewares that apply to the given task
-     * @deprecated Internal method exposed for testing - may be removed in future versions
-     */
-    getEverywhereMiddlewareForTasks(task: ITask<any, any, any>): ITaskMiddleware[];
-    /**
-     * Gets all "everywhere" middlewares that apply to the given resource
-     * @deprecated Internal method exposed for testing - may be removed in future versions
-     */
-    getEverywhereMiddlewareForResources(resource: IResource<any, any, any, any>): IResourceMiddleware[];
-}

package/dist/models/OverrideManager.d.ts

@@ -1,13 +0,0 @@
-import { IResource, ITaskMiddleware, IResourceMiddleware, ITask, IResourceWithConfig, RegisterableItems, IHook } from "../defs";
-import { StoreRegistry } from "./StoreRegistry";
-export declare class OverrideManager {
-    private readonly registry;
-    overrides: Map<string, IResource | ITaskMiddleware | IResourceMiddleware | ITask | IResourceWithConfig | IHook>;
-    overrideRequests: Set<{
-        source: string;
-        override: RegisterableItems;
-    }>;
-    constructor(registry: StoreRegistry);
-    storeOverridesDeeply<C>(element: IResource<C, any, any>): void;
-    processOverrides(): void;
-}

package/dist/models/Queue.d.ts

@@ -1,26 +0,0 @@
-/**
- * Cooperative task queue.
- *  • Tasks run one‑after‑another (FIFO ordering).
- *  • Dead‑lock detection prevents nesting.
- *  • dispose() drains or cancels outstanding tasks, then rejects new ones.
- */
-export declare class Queue {
-    private tail;
-    private disposed;
-    private abortController;
-    private readonly executionContext;
-    private readonly hasAsyncLocalStorage;
-    /**
-     * Schedule an asynchronous task.
-     * @param task – receives an AbortSignal so it can cancel early if desired.
-     */
-    run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;
-    /**
-     * Disposes the queue.
-     * @param options.cancel – if true, broadcasts AbortSignal to running task.
-     *                         default: false (waits for tasks to finish).
-     */
-    dispose(options?: {
-        cancel?: boolean;
-    }): Promise<void>;
-}

package/dist/models/ResourceInitializer.d.ts

@@ -1,20 +0,0 @@
-import { DependencyMapType, IResource, ResourceDependencyValuesType } from "../defs";
-import { EventManager } from "./EventManager";
-import { Store } from "./Store";
-import { Logger } from "./Logger";
-export declare class ResourceInitializer {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    constructor(store: Store, eventManager: EventManager, logger: Logger);
-    private readonly middlewareManager;
-    /**
-     * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
-     * This function can throw only if any of the event listeners or run function throws
-     */
-    initializeResource<TConfig = null, TValue extends Promise<any> = Promise<any>, TDeps extends DependencyMapType = {}, TContext = any>(resource: IResource<TConfig, TValue, TDeps>, config: TConfig, dependencies: ResourceDependencyValuesType<TDeps>): Promise<{
-        value: TValue;
-        context: TContext;
-    }>;
-    initWithMiddleware<C, V extends Promise<any>, D extends DependencyMapType, TContext>(resource: IResource<C, V, D, TContext>, config: C, dependencies: ResourceDependencyValuesType<D>, context: TContext): Promise<V | undefined>;
-}

package/dist/models/RunResult.d.ts

@@ -1,35 +0,0 @@
-import { DependencyMapType, IEvent, ITask } from "../defs";
-import { IResource } from "../defs";
-import { EventManager } from "./EventManager";
-import { Logger } from "./Logger";
-import { Store } from "./Store";
-import { TaskRunner } from "./TaskRunner";
-export declare class RunResult<V> {
-    readonly value: V;
-    readonly logger: Logger;
-    readonly store: Store;
-    private readonly eventManager;
-    private readonly taskRunner;
-    private readonly disposeFn;
-    constructor(value: V, logger: Logger, store: Store, eventManager: EventManager, taskRunner: TaskRunner, disposeFn: () => Promise<void>);
-    /**
-     * Run a task within the context of the run result.
-     * @param task - The task to run.
-     * @param args - The arguments to pass to the task.
-     * @returns The result of the task.
-     */
-    runTask: <I = undefined, O extends Promise<any> = any, D extends DependencyMapType = any>(task: ITask<I, O, D> | string, ...args: I extends undefined | void ? [] : [I]) => Promise<O | undefined>;
-    /**
-     * Emit an event within the context of the run result.
-     * @param event - The event to emit.
-     * @param payload - The payload to emit.
-     */
-    emitEvent: <P>(event: IEvent<P> | string, payload?: P extends undefined | void ? undefined : P) => Promise<void>;
-    /**
-     * Get the value of a resource from the run result.
-     * @param resource - The resource to get the value of.
-     * @returns The value of the resource.
-     */
-    getResourceValue: <Output extends Promise<any>>(resource: string | IResource<any, Output, any, any, any>) => Output extends Promise<infer U> ? U : Output;
-    dispose: () => Promise<void>;
-}

package/dist/models/Semaphore.d.ts

@@ -1,61 +0,0 @@
-/**
- * A semaphore that limits the number of concurrent operations.
- * Used to prevent connection pool exhaustion by limiting concurrent
- * database operations to the pool size.
- */
-export declare class Semaphore {
-    private permits;
-    private readonly waitingQueue;
-    private disposed;
-    private readonly maxPermits;
-    constructor(maxPermits: number);
-    /**
-     * Acquire a permit. If no permits are available, waits until one becomes available.
-     */
-    acquire(options?: {
-        timeout?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Release a permit, allowing waiting operations to proceed.
-     */
-    release(): void;
-    private removeFromQueue;
-    /**
-     * Execute a function with a permit, automatically releasing it afterwards.
-     */
-    withPermit<T>(fn: () => Promise<T>, options?: {
-        timeout?: number;
-        signal?: AbortSignal;
-    }): Promise<T>;
-    /**
-     * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
-     */
-    dispose(): void;
-    /**
-     * Get current number of available permits (for debugging)
-     */
-    getAvailablePermits(): number;
-    /**
-     * Get current number of waiting operations (for debugging)
-     */
-    getWaitingCount(): number;
-    /**
-     * Get maximum number of permits
-     */
-    getMaxPermits(): number;
-    /**
-     * Check if the semaphore has been disposed
-     */
-    isDisposed(): boolean;
-    /**
-     * Get metrics about the current state of the semaphore
-     */
-    getMetrics(): {
-        availablePermits: number;
-        waitingCount: number;
-        maxPermits: number;
-        utilization: number;
-        disposed: boolean;
-    };
-}

package/dist/models/Store.d.ts

@@ -1,73 +0,0 @@
-import { IResource, ITask, RegisterableItems, ITaskMiddleware, IResourceMiddleware, ITag } from "../defs";
-import { EventManager } from "./EventManager";
-import { Logger } from "./Logger";
-import { ResourceStoreElementType, TaskStoreElementType, TaskMiddlewareStoreElementType, ResourceMiddlewareStoreElementType, EventStoreElementType } from "../types/storeTypes";
-import { TaskRunner } from "./TaskRunner";
-import { OnUnhandledError } from "./UnhandledError";
-import { MiddlewareManager } from "./MiddlewareManager";
-import { RunnerMode } from "../types/runner";
-export { ResourceStoreElementType, TaskStoreElementType, EventStoreElementType, };
-/**
- * Store class which is used to store all the resources, tasks, middleware and events.
- */
-export declare class Store {
-    #private;
-    protected readonly eventManager: EventManager;
-    protected readonly logger: Logger;
-    readonly onUnhandledError: OnUnhandledError;
-    root: ResourceStoreElementType;
-    private registry;
-    private overrideManager;
-    private validator;
-    private taskRunner?;
-    private middlewareManager;
-    mode: RunnerMode;
-    constructor(eventManager: EventManager, logger: Logger, onUnhandledError: OnUnhandledError, mode?: RunnerMode);
-    get tasks(): Map<string, TaskStoreElementType>;
-    get hooks(): Map<string, import("..").HookStoreElementType>;
-    get resources(): Map<string, ResourceStoreElementType>;
-    get events(): Map<string, EventStoreElementType>;
-    get errors(): Map<string, import("..").IErrorHelper<any>>;
-    get asyncContexts(): Map<string, import("..").IAsyncContext<any>>;
-    get taskMiddlewares(): Map<string, TaskMiddlewareStoreElementType>;
-    get resourceMiddlewares(): Map<string, ResourceMiddlewareStoreElementType>;
-    get tags(): Map<string, ITag<void, void, void>>;
-    get overrides(): Map<string, IResourceMiddleware<any, void, void, any> | ITaskMiddleware<any, void, void, any> | ITask<any, any, {}, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]> | IResource<void, Promise<any>, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]> | import("..").IResourceWithConfig<any, Promise<any>, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]> | import("..").IHook<{}, any, any>>;
-    get overrideRequests(): Set<{
-        source: string;
-        override: RegisterableItems;
-    }>;
-    getMiddlewareManager(): MiddlewareManager;
-    get isLocked(): boolean;
-    lock(): void;
-    checkLock(): void;
-    private registerGlobalComponents;
-    setTaskRunner(taskRunner: TaskRunner): void;
-    private setupRootResource;
-    validateDependencyGraph(): void;
-    validateEventEmissionGraph(): void;
-    initializeStore(root: IResource<any, any, any, any, any>, config: any): void;
-    dispose(): Promise<void>;
-    /**
-     * Internal, avoid using this method directly.
-     */
-    processOverrides(): void;
-    /**
-     * Internal, avoid using this method directly.
-     * @param item
-     * @returns
-     */
-    storeGenericItem<C>(item: RegisterableItems): void;
-    /**
-     * Returns all tasks with the given tag.
-     * @param tag - The tag to filter by.
-     * @returns The tasks with the given tag.
-     */
-    getTasksWithTag(tag: string | ITag<any, any, any>): ITask<any, any, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>[];
-    /**
-     * Returns all resources with the given tag.
-     * @param tag - The tag to filter by.
-     * @returns The resources with the given tag.
-     */
-    getResourcesWithTag(tag: string | ITag<any, any, any>): IResource<any, any, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>[];
-}

package/dist/models/StoreRegistry.d.ts

@@ -1,49 +0,0 @@
-import { IResource, ITask, IResourceWithConfig, RegisterableItems, ITaskMiddleware, IResourceMiddleware, IEvent, ITag, IHook } from "../defs";
-import { TaskStoreElementType, TaskMiddlewareStoreElementType, ResourceMiddlewareStoreElementType, ResourceStoreElementType, EventStoreElementType, HookStoreElementType } from "../defs";
-import { StoreValidator } from "./StoreValidator";
-import { Store } from "./Store";
-import { IDependentNode } from "./utils/findCircularDependencies";
-import { IErrorHelper } from "../types/error";
-import type { IAsyncContext } from "../types/asyncContext";
-type StoringMode = "normal" | "override";
-export declare class StoreRegistry {
-    protected readonly store: Store;
-    tasks: Map<string, TaskStoreElementType>;
-    resources: Map<string, ResourceStoreElementType>;
-    events: Map<string, EventStoreElementType>;
-    taskMiddlewares: Map<string, TaskMiddlewareStoreElementType>;
-    resourceMiddlewares: Map<string, ResourceMiddlewareStoreElementType>;
-    hooks: Map<string, HookStoreElementType>;
-    tags: Map<string, ITag>;
-    asyncContexts: Map<string, IAsyncContext<any>>;
-    errors: Map<string, IErrorHelper<any>>;
-    private validator;
-    constructor(store: Store);
-    getValidator(): StoreValidator;
-    storeGenericItem<C>(item: RegisterableItems): void;
-    storeError<C>(item: IErrorHelper<any>): void;
-    storeAsyncContext<C>(item: IAsyncContext<any>): void;
-    storeTag(item: ITag<any, any, any>): void;
-    storeHook<C>(item: IHook<any, any>, overrideMode?: StoringMode): void;
-    storeTaskMiddleware<C>(item: ITaskMiddleware<any>, storingMode?: StoringMode): void;
-    storeResourceMiddleware<C>(item: IResourceMiddleware<any>, overrideMode?: StoringMode): void;
-    storeEvent<C>(item: IEvent<void>): void;
-    storeResourceWithConfig<C>(item: IResourceWithConfig<any, any, any>, storingMode?: StoringMode): IResource<any, any, any, any, any, import("..").TagType[], IResourceMiddleware<any, void, void, any>[]>;
-    computeRegistrationDeeply<C>(element: IResource<C>, config?: C): void;
-    storeResource<C>(item: IResource<any, any, any>, overrideMode?: StoringMode): IResource<any, any, any, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
-    storeTask<C>(item: ITask<any, any, {}>, storingMode?: StoringMode): void;
-    getDependentNodes(): IDependentNode[];
-    /**
-     * Builds a directed graph of event emissions based on hooks listening to events
-     * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
-     */
-    buildEventEmissionGraph(): IDependentNode[];
-    private setupBlankNodes;
-    getTasksWithTag(tag: string | ITag): ITask<any, any, any, any, import("..").TagType[], import("..").TaskMiddlewareAttachmentType[]>[];
-    getResourcesWithTag(tag: string | ITag): IResource<any, any, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>[];
-    /**
-     * Used to fetch the value cloned, and if we're dealing with an override, we need to extend the previous value.
-     */
-    private getFreshValue;
-}
-export {};

package/dist/models/StoreValidator.d.ts

@@ -1,8 +0,0 @@
-import { StoreRegistry } from "./StoreRegistry";
-export declare class StoreValidator {
-    private registry;
-    constructor(registry: StoreRegistry);
-    checkIfIDExists(id: string): void | never;
-    runSanityChecks(): void;
-    ensureAllTagsUsedAreRegistered(): void;
-}