@bluelibs/runner 4.8.6 → 5.0.0

package/dist/globals/resources/debug/globalEvent.hook.d.ts

@@ -1,27 +0,0 @@
-export declare const globalEventListener: import("../../..").IHook<{
-    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
-        logResourceConfig: boolean;
-        logResourceValue: boolean;
-        logResourceBeforeRun: boolean;
-        logResourceAfterRun: boolean;
-        logTaskBeforeRun: boolean;
-        logTaskInput: boolean;
-        logTaskOutput: boolean;
-        logTaskAfterRun: boolean;
-        logMiddlewareBeforeRun: boolean;
-        logMiddlewareAfterRun: boolean;
-        logEventEmissionOnRun: boolean;
-        logEventEmissionInput: boolean;
-        logHookTriggered: boolean;
-        logHookCompleted: boolean;
-    }>, {}, any, {
-        title: string;
-        description: string;
-    }, import("../../..").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-}, "*", {
-    title: string;
-    description: string;
-}>;

package/dist/globals/resources/debug/hook.hook.d.ts

@@ -1,30 +0,0 @@
-export declare const hookInterceptorResource: import("../../..").IResource<void, Promise<void>, {
-    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
-        logResourceConfig: boolean;
-        logResourceValue: boolean;
-        logResourceBeforeRun: boolean;
-        logResourceAfterRun: boolean;
-        logTaskBeforeRun: boolean;
-        logTaskInput: boolean;
-        logTaskOutput: boolean;
-        logTaskAfterRun: boolean;
-        logMiddlewareBeforeRun: boolean;
-        logMiddlewareAfterRun: boolean;
-        logEventEmissionOnRun: boolean;
-        logEventEmissionInput: boolean;
-        logHookTriggered: boolean;
-        logHookCompleted: boolean;
-    }>, {}, any, {
-        title: string;
-        description: string;
-    }, import("../../..").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../../..").IResource<void, Promise<import("../../..").EventManager>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-}, any, {
-    title: string;
-    description: string;
-}, import("../../..").ITag<{
-    metadata?: Record<string, any>;
-}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/debug/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./debug.resource";
-export * from "./debugConfig.resource";
-export * from "./types";
-export * from "./globalEvent.hook";
-export * from "./executionTracker.middleware";
-export * from "./debug.tag";

package/dist/globals/resources/debug/middleware.hook.d.ts

@@ -1,30 +0,0 @@
-export declare const middlewareInterceptorResource: import("../../..").IResource<void, Promise<void>, {
-    logger: import("../../..").IResource<void, Promise<import("../../..").Logger>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-    debugConfig: import("../../..").IResource<import("./types").DebugFriendlyConfig, Promise<{
-        logResourceConfig: boolean;
-        logResourceValue: boolean;
-        logResourceBeforeRun: boolean;
-        logResourceAfterRun: boolean;
-        logTaskBeforeRun: boolean;
-        logTaskInput: boolean;
-        logTaskOutput: boolean;
-        logTaskAfterRun: boolean;
-        logMiddlewareBeforeRun: boolean;
-        logMiddlewareAfterRun: boolean;
-        logEventEmissionOnRun: boolean;
-        logEventEmissionInput: boolean;
-        logHookTriggered: boolean;
-        logHookCompleted: boolean;
-    }>, {}, any, {
-        title: string;
-        description: string;
-    }, import("../../..").ITag<{
-        metadata?: Record<string, any>;
-    }, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-    middlewareManager: import("../../..").IResource<void, Promise<import("../../..").MiddlewareManager>, {}, any, any, import("../../..").TagType[], import("../../..").ResourceMiddlewareAttachmentType[]>;
-}, any, {
-    title: string;
-    description: string;
-}, import("../../..").ITag<{
-    metadata?: Record<string, any>;
-}, void, void>[], import("../../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/debug/types.d.ts

@@ -1,25 +0,0 @@
-import { ITaggable } from "../../../defs";
-export type DebugConfig = {
-    logResourceConfig: boolean;
-    logResourceValue: boolean;
-    logResourceBeforeRun: boolean;
-    logResourceAfterRun: boolean;
-    logTaskBeforeRun: boolean;
-    logTaskInput: boolean;
-    logTaskOutput: boolean;
-    logTaskAfterRun: boolean;
-    logMiddlewareBeforeRun: boolean;
-    logMiddlewareAfterRun: boolean;
-    logEventEmissionOnRun: boolean;
-    logEventEmissionInput: boolean;
-    logHookTriggered: boolean;
-    logHookCompleted: boolean;
-};
-export declare const allFalse: DebugConfig;
-export declare const levelNormal: DebugConfig;
-export declare const levelVerbose: DebugConfig;
-/**
- * If you choose to specify your own config, all values will be set to false by default and extended by your config.
- */
-export type DebugFriendlyConfig = "normal" | "verbose" | Partial<DebugConfig>;
-export declare const getConfig: (config: DebugFriendlyConfig, taggable?: ITaggable) => DebugConfig;

package/dist/globals/resources/debug/utils.d.ts

@@ -1,2 +0,0 @@
-import { ITaggable } from "../../../defs";
-export declare const hasSystemTag: (definition: ITaggable) => boolean;

package/dist/globals/resources/httpClientFactory.resource.d.ts

@@ -1,28 +0,0 @@
-import { type HttpClient } from "../../http-client";
-import type { HttpClientConfig } from "../../http-client";
-/**
- * Factory for creating HTTP clients with automatic injection of:
- * - serializer (EJSON-compatible)
- * - error registry (from Store)
- * - async contexts (from Store)
- *
- * Note: Node streaming clients are exposed via the Node entry only
- * (see createHttpSmartClient/createHttpMixedClient in `@bluelibs/runner/node`).
- * Keeping this universal factory browser-safe avoids dynamic imports.
- */
-export interface HttpClientFactoryConfig {
-    baseUrl: string;
-    auth?: HttpClientConfig["auth"];
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    onRequest?: HttpClientConfig["onRequest"];
-}
-export type HttpClientFactory = (config: HttpClientFactoryConfig) => HttpClient;
-export declare const httpClientFactory: import("../..").IResource<void, Promise<HttpClientFactory>, {
-    serializer: import("../..").IResource<void, Promise<import("./tunnel/serializer").Serializer>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    store: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, any, {
-    title: string;
-    description: string;
-}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-export type { HttpClient };

package/dist/globals/resources/queue.resource.d.ts

@@ -1,10 +0,0 @@
-import { Queue } from "../../models/Queue";
-export declare const queueResource: import("../..").IResource<void, Promise<{
-    map: Map<string, Queue>;
-    run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-}>, {}, {
-    map: Map<string, Queue>;
-}, {
-    title: string;
-    description: string;
-}, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;

package/dist/globals/resources/tunnel/ejson-extensions.d.ts

@@ -1 +0,0 @@
-export declare const EJSON: import("@bluelibs/ejson").EJSONModule;

package/dist/globals/resources/tunnel/error-utils.d.ts

@@ -1 +0,0 @@
-export declare function normalizeError(input: unknown): Error;

package/dist/globals/resources/tunnel/plan.d.ts

@@ -1,19 +0,0 @@
-import type { ITaskMiddleware } from "../../../defs";
-export type ValidationSide = "client" | "server" | "both";
-export interface ExecutionPlan {
-    clientMiddleware: string[];
-    serverMiddleware: string[];
-    validation: ValidationSide;
-}
-export interface PlanMeta {
-    plan?: ExecutionPlan;
-    headers?: Record<string, string>;
-    traceId?: string;
-    context?: unknown;
-}
-export declare function computeExecutionPlanFromWhitelist(whitelist: {
-    client?: Array<string | ITaskMiddleware<any, any, any, any>>;
-    server?: Array<string | ITaskMiddleware<any, any, any, any>>;
-}, opts?: {
-    defaultValidation?: ValidationSide;
-}): ExecutionPlan;

package/dist/globals/resources/tunnel/protocol.d.ts

@@ -1,47 +0,0 @@
-import type { ITask, IEventEmission } from "../../../defs";
-export interface ProtocolErrorShape {
-    code: string;
-    message: string;
-    details?: unknown;
-    id?: string;
-    data?: unknown;
-}
-export interface ProtocolEnvelope<T = unknown> {
-    ok: boolean;
-    result?: T;
-    error?: ProtocolErrorShape;
-    meta?: {
-        protocolVersion?: string;
-        traceId?: string;
-        taskVersion?: string;
-    };
-}
-export interface TaskRequest {
-    id: string;
-    input?: unknown;
-    plan?: unknown;
-    context?: Record<string, unknown>;
-    traceId?: string;
-}
-export interface EventRequest {
-    id: string;
-    payload?: unknown;
-    context?: Record<string, unknown>;
-    traceId?: string;
-}
-export declare class TunnelError extends Error {
-    readonly code: string;
-    readonly details?: unknown;
-    readonly id?: string;
-    readonly data?: unknown;
-    constructor(code: string, message: string, details?: unknown, extras?: {
-        id?: string;
-        data?: unknown;
-    });
-}
-export declare function toTunnelError(input: unknown, fallbackMessage?: string): TunnelError;
-export declare function assertOkEnvelope<T>(envelope: ProtocolEnvelope<T> | undefined, opts?: {
-    fallbackMessage?: string;
-}): T;
-export declare function runViaTunnel(runner: (task: ITask<any, any, any, any, any, any>, input?: unknown) => Promise<unknown>, task: ITask<any, any, any, any, any, any>, input?: unknown): Promise<unknown>;
-export declare function emitViaTunnel(runner: (emission: IEventEmission<any>) => Promise<unknown>, emission: IEventEmission<any>): Promise<void>;

package/dist/globals/resources/tunnel/serializer.d.ts

@@ -1,9 +0,0 @@
-import { EJSON } from "@bluelibs/ejson";
-export interface Serializer {
-    stringify(value: unknown): string;
-    parse<T = unknown>(text: string): T;
-    addType?<TJson = unknown, T = unknown>(name: string, factory: (json: TJson) => T): void;
-}
-export declare const EjsonSerializer: Serializer;
-export declare function getDefaultSerializer(): Serializer;
-export { EJSON };

package/dist/globals/resources/tunnel/tunnel.policy.tag.d.ts

@@ -1,18 +0,0 @@
-import type { ITaskMiddleware } from "../../../defs";
-export type TunnelPolicySide = "client" | "server";
-export type TunnelMiddlewareId = string | ITaskMiddleware<any, any, any, any>;
-export interface TunnelTaskMiddlewarePolicyConfig {
-    /**
-     * Whitelist of middleware ids/definitions allowed to run on the caller side
-     * when the task is tunneled (mode: "client"). If omitted, defaults to
-     * allowing all (the framework default remains "both").
-     */
-    client?: TunnelMiddlewareId[];
-    /**
-     * Whitelist of middleware ids/definitions intended to run on the executor side.
-     * Note: The local runner cannot enforce server-side policy; this is a declarative
-     * contract that a Runner-based executor can consume to apply a symmetric filter.
-     */
-    server?: TunnelMiddlewareId[];
-}
-export declare const tunnelPolicyTag: import("../../..").ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;

package/dist/globals/resources/tunnel/tunnel.tag.d.ts

@@ -1,2 +0,0 @@
-import type { TunnelRunner } from "./types";
-export declare const tunnelTag: import("../../..").ITag<void, void, TunnelRunner>;

package/dist/globals/resources/tunnel/types.d.ts

@@ -1,42 +0,0 @@
-import type { ITask, IEvent, IEventEmission } from "../../../defs";
-import type { IAsyncContext } from "../../../types/asyncContext";
-import type { IErrorHelper } from "../../../types/error";
-import type { Serializer } from "./serializer";
-export type { Serializer } from "./serializer";
-export type TunnelMode = "client" | "server" | "both" | "none";
-export type TunnelTaskSelector = Array<string | ITask<any, any, any, any, any, any>> | ((task: ITask<any, any, any, any, any, any>) => boolean);
-export type TunnelEventSelector = Array<string | IEvent<any>> | ((event: IEvent<any>) => boolean);
-export type EventDeliveryMode = "mirror" | "remote-only" | "local-only" | "remote-first";
-export interface TunnelTagConfig {
-}
-export type TunnelTaskRunner = (task: ITask<any, any, any, any, any, any>, input?: any) => Promise<any>;
-export interface TunnelRunner {
-    transport?: "http" | string;
-    mode?: TunnelMode;
-    tasks?: TunnelTaskSelector;
-    events?: TunnelEventSelector;
-    eventDeliveryMode?: EventDeliveryMode;
-    run?: TunnelTaskRunner;
-    emit?: (event: IEventEmission<any>) => Promise<any>;
-}
-export interface ExposureFetchAuthConfig {
-    header?: string;
-    token: string;
-}
-export interface ExposureFetchConfig {
-    baseUrl: string;
-    auth?: ExposureFetchAuthConfig;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    serializer: Serializer;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<any>>;
-    errorRegistry?: Map<string, IErrorHelper<any>>;
-}
-export interface ExposureFetchClient {
-    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O>;
-    event<P = unknown>(id: string, payload?: P): Promise<void>;
-}

package/dist/globals/tunnels/index.d.ts

@@ -1,23 +0,0 @@
-import type { Serializer } from "../resources/tunnel/serializer";
-import type { ExposureFetchClient } from "../../http-fetch-tunnel.resource";
-export interface HttpClientAuthConfig {
-    header?: string;
-    token: string;
-}
-export interface HttpCreateClientConfig {
-    url: string;
-    auth?: HttpClientAuthConfig;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    serializer: Serializer;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-}
-export declare const tunnels: Readonly<{
-    http: Readonly<{
-        createClient(cfg: HttpCreateClientConfig): ExposureFetchClient;
-    }>;
-}>;
-export type { ExposureFetchClient };

package/dist/globals/types.d.ts

@@ -1,4 +0,0 @@
-export * from "./resources/debug/types";
-export * from "./resources/tunnel/types";
-export * from "./debug";
-export type { HttpClientFactoryConfig, HttpClientFactory, } from "./resources/httpClientFactory.resource";

package/dist/http-client.d.ts

@@ -1,25 +0,0 @@
-import type { Serializer } from "./globals/resources/tunnel/serializer";
-import type { IAsyncContext } from "./types/asyncContext";
-import type { IErrorHelper } from "./types/error";
-export interface HttpClientAuth {
-    header?: string;
-    token: string;
-}
-export interface HttpClientConfig {
-    baseUrl: string;
-    auth?: HttpClientAuth;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    serializer: Serializer;
-    onRequest?: (ctx: {
-        url: string;
-        headers: Record<string, string>;
-    }) => void | Promise<void>;
-    contexts?: Array<IAsyncContext<any>>;
-    errorRegistry?: Map<string, IErrorHelper<any>>;
-}
-export interface HttpClient {
-    task<I = unknown, O = unknown>(id: string, input?: I): Promise<O>;
-    event<P = unknown>(id: string, payload?: P): Promise<void>;
-}
-export declare function createHttpClient(cfg: HttpClientConfig): HttpClient;

package/dist/http-fetch-tunnel.resource.d.ts

@@ -1,11 +0,0 @@
-import type { ExposureFetchConfig, ExposureFetchClient } from "./globals/resources/tunnel/types";
-export { normalizeError } from "./globals/resources/tunnel/error-utils";
-export type { ExposureFetchAuthConfig, ExposureFetchConfig, ExposureFetchClient, } from "./globals/resources/tunnel/types";
-/**
- * This functions communicates with the exposure server over HTTP.
- * It uses the @readmes/TUNNEL_HTTP_POLICY.md strategy.
- *
- * @param cfg
- * @returns
- */
-export declare function createExposureFetch(cfg: ExposureFetchConfig): ExposureFetchClient;

package/dist/index.d.ts

@@ -1,117 +0,0 @@
-import { defineTask, defineResource, defineEvent, defineTaskMiddleware, defineResourceMiddleware, defineTag, defineOverride, defineHook } from "./define";
-import { defineAsyncContext, createContext as oldCreateContext } from "./definers/defineAsyncContext";
-import { run } from "./run";
-import { createTestResource } from "./testing";
-declare const globals: {
-    events: {
-        readonly ready: import(".").IEvent<void>;
-    };
-    resources: {
-        readonly store: import(".").IResource<void, Promise<import("./models").Store>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly middlewareManager: import(".").IResource<void, Promise<import("./models").MiddlewareManager>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly eventManager: import(".").IResource<void, Promise<import("./models").EventManager>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly taskRunner: import(".").IResource<void, Promise<import("./models").TaskRunner>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly logger: import(".").IResource<void, Promise<import("./models").Logger>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly serializer: import(".").IResource<void, Promise<import(".").Serializer>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly cache: import(".").IResource<{
-            defaultOptions?: any;
-        }, Promise<{
-            map: Map<string, import(".").ICacheInstance>;
-            cacheFactoryTask: import(".").TaskDependencyWithIntercept<any, Promise<import(".").ICacheInstance>>;
-            defaultOptions: any;
-        }>, {
-            cacheFactoryTask: import(".").ITask<any, Promise<import(".").ICacheInstance>, any, any, import(".").TagType[], import(".").TaskMiddlewareAttachmentType[]>;
-        }, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly queue: import(".").IResource<void, Promise<{
-            map: Map<string, import("./models").Queue>;
-            run: <T>(id: string, task: (signal: AbortSignal) => Promise<T>) => Promise<T>;
-        }>, {}, {
-            map: Map<string, import("./models").Queue>;
-        }, {
-            title: string;
-            description: string;
-        }, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        readonly httpClientFactory: import(".").IResource<void, Promise<import(".").HttpClientFactory>, {
-            serializer: import(".").IResource<void, Promise<import(".").Serializer>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-            store: import(".").IResource<void, Promise<import("./models").Store>, {}, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-        }, any, {
-            title: string;
-            description: string;
-        }, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-    };
-    middleware: {
-        requireContext: import(".").ITaskMiddleware<{
-            context: import(".").IAsyncContext<any>;
-        }, void, void, any>;
-        task: {
-            requireContext: import(".").ITaskMiddleware<{
-                context: import(".").IAsyncContext<any>;
-            }, void, void, any>;
-            cache: import(".").ITaskMiddleware<any, void, void, {
-                cache: import(".").IResource<{
-                    defaultOptions?: any;
-                }, Promise<{
-                    map: Map<string, import(".").ICacheInstance>;
-                    cacheFactoryTask: import(".").TaskDependencyWithIntercept<any, Promise<import(".").ICacheInstance>>;
-                    defaultOptions: any;
-                }>, {
-                    cacheFactoryTask: import(".").ITask<any, Promise<import(".").ICacheInstance>, any, any, import(".").TagType[], import(".").TaskMiddlewareAttachmentType[]>;
-                }, any, any, import(".").TagType[], import(".").ResourceMiddlewareAttachmentType[]>;
-            }>;
-            retry: import(".").ITaskMiddleware<import("./globals/middleware/retry.middleware").RetryMiddlewareConfig, void, void, any>;
-            timeout: import(".").ITaskMiddleware<import("./globals/middleware/timeout.middleware").TimeoutMiddlewareConfig, void, void, any>;
-        };
-        resource: {
-            retry: import(".").IResourceMiddleware<import("./globals/middleware/retry.middleware").RetryMiddlewareConfig, void, void, any>;
-            timeout: import(".").IResourceMiddleware<import("./globals/middleware/timeout.middleware").TimeoutMiddlewareConfig, void, void, any>;
-        };
-    };
-    tags: {
-        system: import(".").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        excludeFromGlobalHooks: import(".").ITag<{
-            metadata?: Record<string, any>;
-        }, void, void>;
-        debug: import(".").ITag<import(".").DebugFriendlyConfig, void, void>;
-        tunnel: import(".").ITag<void, void, import(".").TunnelRunner>;
-        tunnelPolicy: import(".").ITag<import("./globals/resources/tunnel/tunnel.policy.tag").TunnelTaskMiddlewarePolicyConfig, void, void>;
-    };
-    tunnels: Readonly<{
-        http: Readonly<{
-            createClient(cfg: import("./globals/tunnels").HttpCreateClientConfig): import("./http-fetch-tunnel.resource").ExposureFetchClient;
-        }>;
-    }>;
-    debug: {
-        levels: {
-            normal: import(".").DebugConfig;
-            verbose: import(".").DebugConfig;
-        };
-    };
-};
-export { globals };
-export { defineTask as task, defineResource as resource, defineEvent as event, defineTaskMiddleware as taskMiddleware, defineResourceMiddleware as resourceMiddleware, defineAsyncContext as asyncContext, defineTag as tag, defineOverride as override, defineHook as hook, run, createTestResource, };
-declare const createContext: typeof oldCreateContext;
-export { createContext };
-export declare const r: Readonly<{
-    resource: typeof import("./definers/builders/resource").resourceBuilder;
-    task: import("./definers/builders/task").TaskBuilderWithPhantom;
-    event: typeof import("./definers/builders/event").eventBuilder;
-    hook: typeof import("./definers/builders/hook").hookBuilder;
-    tag: typeof import("./definers/builders/tag").tagBuilder;
-    asyncContext: typeof import("./definers/builders/asyncContext").asyncContextBuilder;
-    error: typeof import("./definers/builders/error").errorBuilder;
-    middleware: Readonly<{
-        task: typeof import("./definers/builders/middleware").taskMiddlewareBuilder;
-        resource: typeof import("./definers/builders/middleware").resourceMiddlewareBuilder;
-    }>;
-}>;
-export * as definitions from "./defs";
-export * from "./models";
-export * from "./globals/types";
-export * as Errors from "./errors";
-export { PlatformAdapter, setPlatform } from "./platform";
-export { EJSON } from "@bluelibs/ejson";
-export * from "./http-client";
-export * from "./http-fetch-tunnel.resource";
-export type * from "./defs";

package/dist/models/DependencyProcessor.d.ts

@@ -1,48 +0,0 @@
-import { DependencyMapType, DependencyValuesType, ITask, IResource, IEvent } from "../defs";
-import { Store } from "./Store";
-import { ResourceStoreElementType } from "../types/storeTypes";
-import { EventManager } from "./EventManager";
-import { ResourceInitializer } from "./ResourceInitializer";
-import { TaskRunner } from "./TaskRunner";
-import { Logger } from "./Logger";
-/**
- * This class is responsible of setting up dependencies with their respective computedValues.
- * Note that all elements must have been previously registered otherwise errors will be thrown
- * when trying to depend on something not in the store.
- */
-export declare class DependencyProcessor {
-    protected readonly store: Store;
-    protected readonly eventManager: EventManager;
-    protected readonly taskRunner: TaskRunner;
-    protected readonly resourceInitializer: ResourceInitializer;
-    protected readonly logger: Logger;
-    constructor(store: Store, eventManager: EventManager, taskRunner: TaskRunner, logger: Logger);
-    /**
-     * This function is going to go through all the resources, tasks and middleware to compute their required dependencies.
-     */
-    computeAllDependencies(): Promise<void>;
-    private computeTaskDependencies;
-    initializeUninitializedResources(): Promise<void>;
-    /**
-     * Processes dependencies and hooks
-     * @param resource
-     */
-    protected processResourceDependencies<TD extends DependencyMapType>(resource: ResourceStoreElementType<any, any, TD>): Promise<void>;
-    private wrapResourceDependencies;
-    private makeTaskWithIntercept;
-    initializeRoot(): Promise<void>;
-    /**
-     * Processes all hooks, should run before emission of any event.
-     */
-    attachListeners(): void;
-    extractDependencies<T extends DependencyMapType>(map: T, source: string): Promise<DependencyValuesType<T>>;
-    extractDependency(object: any, source: string): Promise<any>;
-    /**
-     * Converts the event into a running functions with real inputs
-     * @param object
-     * @returns
-     */
-    extractEventDependency(object: IEvent<any>, source: string): (input: any) => Promise<void>;
-    extractTaskDependency(object: ITask<any, any, {}>): Promise<(input: unknown) => Promise<any>>;
-    extractResourceDependency(object: IResource<any, any, any>): Promise<any>;
-}