Variable globalsConst

globals: {
    debug: {
        levels: {
            normal: DebugConfig;
            verbose: DebugConfig;
        };
    };
    events: {
        ready: IEvent<void>;
    };
    middleware: {
        requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;
        resource: {
            retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
            timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;
        };
        task: {
            cache: ITaskMiddleware<any, void, void, {
                cache: IResource<CacheResourceConfig, Promise<{
                    cacheFactoryTask: TaskDependencyWithIntercept<Options<(...), (...), (...)>, Promise<(...)>>;
                    defaultOptions: any;
                    map: Map<string, ICacheInstance>;
                }>, {
                    cacheFactoryTask: ITask<Options<any, any, any>, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
                }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
            }> & {
                journalKeys: {
                    hit: JournalKey<boolean>;
                };
            };
            circuitBreaker: ITaskMiddleware<CircuitBreakerMiddlewareConfig, void, void, {
                state: IResource<void, Promise<{
                    statusMap: Map<string, CircuitBreakerStatus>;
                }>, {}, any, any, ITag<{
                    metadata?: (...) | (...);
                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
            }> & {
                journalKeys: {
                    failures: JournalKey<number>;
                    state: JournalKey<CircuitBreakerState>;
                };
            };
            concurrency: ITaskMiddleware<ConcurrencyMiddlewareConfig, void, void, {
                state: IResource<void, Promise<{
                    semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
                    semaphoresByKey: Map<string, {
                        limit: number;
                        semaphore: Semaphore;
                    }>;
                }>, {}, any, any, ITag<{
                    metadata?: Record<(...), (...)>;
                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
            }>;
            debounce: ITaskMiddleware<TemporalMiddlewareConfig, void, void, {
                state: IResource<void, Promise<{
                    debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
                    throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
                }>, {}, any, any, ITag<{
                    metadata?: Record<(...), (...)>;
                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
            }>;
            fallback: ITaskMiddleware<FallbackMiddlewareConfig, void, void, {
                taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
            }> & {
                journalKeys: {
                    active: JournalKey<boolean>;
                    error: JournalKey<Error>;
                };
            };
            rateLimit: ITaskMiddleware<RateLimitMiddlewareConfig, void, void, {
                state: IResource<void, Promise<{
                    states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
                }>, {}, any, any, ITag<{
                    metadata?: (...) | (...);
                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
            }> & {
                journalKeys: {
                    limit: JournalKey<number>;
                    remaining: JournalKey<number>;
                    resetTime: JournalKey<number>;
                };
            };
            requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;
            retry: ITaskMiddleware<RetryMiddlewareConfig, void, void, any> & {
                journalKeys: {
                    attempt: JournalKey<number>;
                    lastError: JournalKey<Error>;
                };
            };
            throttle: ITaskMiddleware<TemporalMiddlewareConfig, void, void, {
                state: IResource<void, Promise<{
                    debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
                    throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
                }>, {}, any, any, ITag<{
                    metadata?: Record<(...), (...)>;
                }, void, void>[], ResourceMiddlewareAttachmentType[]>;
            }>;
            timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any> & {
                journalKeys: {
                    abortController: JournalKey<AbortController>;
                };
            };
        };
    };
    resources: {
        cache: IResource<CacheResourceConfig, Promise<{
            cacheFactoryTask: TaskDependencyWithIntercept<Options<any, any, any>, Promise<ICacheInstance>>;
            defaultOptions: any;
            map: Map<string, ICacheInstance>;
        }>, {
            cacheFactoryTask: ITask<Options<any, any, any>, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
        }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        circuitBreaker: IResource<void, Promise<{
            statusMap: Map<string, CircuitBreakerStatus>;
        }>, {}, any, any, ITag<{
            metadata?: Record<string, any>;
        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
        concurrency: IResource<void, Promise<{
            semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
            semaphoresByKey: Map<string, {
                limit: number;
                semaphore: Semaphore;
            }>;
        }>, {}, any, any, ITag<{
            metadata?: Record<string, any>;
        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
        eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        httpClientFactory: IResource<void, Promise<HttpClientFactory>, {
            serializer: IResource<void, Promise<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
            store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        }, any, {
            description: string;
            title: string;
        }, TagType[], ResourceMiddlewareAttachmentType[]>;
        logger: IResource<void, Promise<Logger>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        middlewareManager: IResource<void, Promise<MiddlewareManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        queue: IResource<void, Promise<{
            map: Map<string, Queue>;
            run: (<T>(id: string, task: ((signal: AbortSignal) => Promise<T>)) => Promise<T>);
        }>, {}, {
            map: Map<string, Queue>;
        }, {
            description: string;
            title: string;
        }, TagType[], ResourceMiddlewareAttachmentType[]>;
        rateLimit: IResource<void, Promise<{
            states: WeakMap<RateLimitMiddlewareConfig, RateLimitState>;
        }>, {}, any, any, ITag<{
            metadata?: Record<string, any>;
        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
        serializer: IResource<void, Promise<SerializerLike>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        temporal: IResource<void, Promise<{
            debounceStates: WeakMap<TemporalMiddlewareConfig, DebounceState>;
            throttleStates: WeakMap<TemporalMiddlewareConfig, ThrottleState>;
        }>, {}, any, any, ITag<{
            metadata?: Record<string, any>;
        }, void, void>[], ResourceMiddlewareAttachmentType[]>;
    };
    tags: {
        authValidator: ITag<void, void, void>;
        debug: ITag<DebugFriendlyConfig, void, void>;
        excludeFromGlobalHooks: ITag<{
            metadata?: Record<string, any>;
        }, void, void>;
        system: ITag<{
            metadata?: Record<string, any>;
        }, void, void>;
        tunnel: ITag<void, void, TunnelRunner>;
        tunnelPolicy: ITag<TunnelTaskMiddlewarePolicyConfig, void, void>;
    };
    tunnels: Readonly<{
        http: Readonly<{
            createClient(cfg: HttpCreateClientConfig): ExposureFetchClient;
        }>;
    }>;
} = ...

Type declaration

Settings

Member Visibility