Variable globalsConst

Type Declaration

• debug: { levels: { normal: DebugConfig; verbose: DebugConfig } }

• events: { ready: IEvent<void> }

  • Readonlyready: IEvent<void>

    Emitted when the system is fully initialized and ready for work.

• middleware: {
      requireContext: ITaskMiddleware<
          RequireContextMiddlewareConfig,
          void,
          void,
          any,
      >;
      resource: {
          retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
          timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;
      };
      task: {
          cache: ITaskMiddleware<
              CacheMiddlewareConfig,
              void,
              void,
              {
                  cache: IResource<
                      CacheResourceConfig,
                      Promise<
                          {
                              cacheFactoryTask: TaskDependencyWithIntercept<
                                  CacheFactoryOptions,
                                  Promise<(...)>,
                              >;
                              defaultOptions:
                                  | { max: ...; ttl: ...; ttlAutopurge: ... }
                                  | {
                                      allowStale?: ...;
                                      allowStaleOnFetchAbort?: ...;
                                      allowStaleOnFetchRejection?: ...;
                                      dispose?: ...;
                                      disposeAfter?: ...;
                                      fetchMethod?: ...;
                                      ignoreFetchAbort?: ...;
                                      max: ...;
                                      maxEntrySize?: ...;
                                      maxSize?: ...;
                                      memoMethod?: ...;
                                      noDeleteOnFetchRejection?: ...;
                                      noDeleteOnStaleGet?: ...;
                                      noDisposeOnSet?: ...;
                                      noUpdateTTL?: ...;
                                      onInsert?: ...;
                                      perf?: ...;
                                      sizeCalculation?: ...;
                                      ttl: ...;
                                      ttlAutopurge: ...;
                                      ttlResolution?: ...;
                                      updateAgeOnGet?: ...;
                                      updateAgeOnHas?: ...;
                                  }
                                  | {
                                      allowStale?: ...;
                                      allowStaleOnFetchAbort?: ...;
                                      allowStaleOnFetchRejection?: ...;
                                      dispose?: ...;
                                      disposeAfter?: ...;
                                      fetchMethod?: ...;
                                      ignoreFetchAbort?: ...;
                                      max: ...;
                                      maxEntrySize?: ...;
                                      maxSize?: ...;
                                      memoMethod?: ...;
                                      noDeleteOnFetchRejection?: ...;
                                      noDeleteOnStaleGet?: ...;
                                      noDisposeOnSet?: ...;
                                      noUpdateTTL?: ...;
                                      onInsert?: ...;
                                      perf?: ...;
                                      sizeCalculation?: ...;
                                      ttl: ...;
                                      ttlAutopurge: ...;
                                      ttlResolution?: ...;
                                      updateAgeOnGet?: ...;
                                      updateAgeOnHas?: ...;
                                  }
                                  | {
                                      allowStale?: ...;
                                      allowStaleOnFetchAbort?: ...;
                                      allowStaleOnFetchRejection?: ...;
                                      dispose?: ...;
                                      disposeAfter?: ...;
                                      fetchMethod?: ...;
                                      ignoreFetchAbort?: ...;
                                      max: ...;
                                      maxEntrySize?: ...;
                                      maxSize?: ...;
                                      memoMethod?: ...;
                                      noDeleteOnFetchRejection?: ...;
                                      noDeleteOnStaleGet?: ...;
                                      noDisposeOnSet?: ...;
                                      noUpdateTTL?: ...;
                                      onInsert?: ...;
                                      perf?: ...;
                                      sizeCalculation?: ...;
                                      ttl: ...;
                                      ttlAutopurge: ...;
                                      ttlResolution?: ...;
                                      updateAgeOnGet?: ...;
                                      updateAgeOnHas?: ...;
                                  };
                              map: Map<string, ICacheInstance>;
                              pendingCreates: Map<string, Promise<(...)>>;
                          },
                      >,
                      {
                          cacheFactoryTask: ITask<
                              CacheFactoryOptions,
                              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<
                          {
                              semaphores: Set<Semaphore>;
                              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<TemporalResourceState>,
                      {},
                      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<TemporalResourceState>,
                      {},
                      any,
                      any,
                      ITag<{ metadata?: Record<(...), (...)> }, void, void>[],
                      ResourceMiddlewareAttachmentType[],
                  >;
              },
          >;
          timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any> & {
              journalKeys: { abortController: JournalKey<AbortController> };
          };
      };
  }

• middlewares: {
      requireContext: ITaskMiddleware<
          RequireContextMiddlewareConfig,
          void,
          void,
          any,
      >;
      resource: {
          retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
          timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;
      };
      task: {
          cache: ITaskMiddleware<
              CacheMiddlewareConfig,
              void,
              void,
              {
                  cache: IResource<
                      CacheResourceConfig,
                      Promise<
                          {
                              cacheFactoryTask: TaskDependencyWithIntercept<
                                  CacheFactoryOptions,
                                  Promise<(...)>,
                              >;
                              defaultOptions:
                                  | { max: ...; ttl: ...; ttlAutopurge: ... }
                                  | {
                                      allowStale?: ...;
                                      allowStaleOnFetchAbort?: ...;
                                      allowStaleOnFetchRejection?: ...;
                                      dispose?: ...;
                                      disposeAfter?: ...;
                                      fetchMethod?: ...;
                                      ignoreFetchAbort?: ...;
                                      max: ...;
                                      maxEntrySize?: ...;
                                      maxSize?: ...;
                                      memoMethod?: ...;
                                      noDeleteOnFetchRejection?: ...;
                                      noDeleteOnStaleGet?: ...;
                                      noDisposeOnSet?: ...;
                                      noUpdateTTL?: ...;
                                      onInsert?: ...;
                                      perf?: ...;
                                      sizeCalculation?: ...;
                                      ttl: ...;
                                      ttlAutopurge: ...;
                                      ttlResolution?: ...;
                                      updateAgeOnGet?: ...;
                                      updateAgeOnHas?: ...;
                                  }
                                  | {
                                      allowStale?: ...;
                                      allowStaleOnFetchAbort?: ...;
                                      allowStaleOnFetchRejection?: ...;
                                      dispose?: ...;
                                      disposeAfter?: ...;
                                      fetchMethod?: ...;
                                      ignoreFetchAbort?: ...;
                                      max: ...;
                                      maxEntrySize?: ...;
                                      maxSize?: ...;
                                      memoMethod?: ...;
                                      noDeleteOnFetchRejection?: ...;
                                      noDeleteOnStaleGet?: ...;
                                      noDisposeOnSet?: ...;
                                      noUpdateTTL?: ...;
                                      onInsert?: ...;
                                      perf?: ...;
                                      sizeCalculation?: ...;
                                      ttl: ...;
                                      ttlAutopurge: ...;
                                      ttlResolution?: ...;
                                      updateAgeOnGet?: ...;
                                      updateAgeOnHas?: ...;
                                  }
                                  | {
                                      allowStale?: ...;
                                      allowStaleOnFetchAbort?: ...;
                                      allowStaleOnFetchRejection?: ...;
                                      dispose?: ...;
                                      disposeAfter?: ...;
                                      fetchMethod?: ...;
                                      ignoreFetchAbort?: ...;
                                      max: ...;
                                      maxEntrySize?: ...;
                                      maxSize?: ...;
                                      memoMethod?: ...;
                                      noDeleteOnFetchRejection?: ...;
                                      noDeleteOnStaleGet?: ...;
                                      noDisposeOnSet?: ...;
                                      noUpdateTTL?: ...;
                                      onInsert?: ...;
                                      perf?: ...;
                                      sizeCalculation?: ...;
                                      ttl: ...;
                                      ttlAutopurge: ...;
                                      ttlResolution?: ...;
                                      updateAgeOnGet?: ...;
                                      updateAgeOnHas?: ...;
                                  };
                              map: Map<string, ICacheInstance>;
                              pendingCreates: Map<string, Promise<(...)>>;
                          },
                      >,
                      {
                          cacheFactoryTask: ITask<
                              CacheFactoryOptions,
                              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<
                          {
                              semaphores: Set<Semaphore>;
                              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<TemporalResourceState>,
                      {},
                      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<TemporalResourceState>,
                      {},
                      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<
                      CacheFactoryOptions,
                      Promise<ICacheInstance>,
                  >;
                  defaultOptions:
                      | { max: number; ttl: number; ttlAutopurge: boolean }
                      | {
                          allowStale?: boolean;
                          allowStaleOnFetchAbort?: boolean;
                          allowStaleOnFetchRejection?: boolean;
                          dispose?: Disposer<string, {}>;
                          disposeAfter?: Disposer<string, {}>;
                          fetchMethod?: Fetcher<string, {}, unknown>;
                          ignoreFetchAbort?: boolean;
                          max: number;
                          maxEntrySize?: number;
                          maxSize?: number;
                          memoMethod?: Memoizer<string, {}, unknown>;
                          noDeleteOnFetchRejection?: boolean;
                          noDeleteOnStaleGet?: boolean;
                          noDisposeOnSet?: boolean;
                          noUpdateTTL?: boolean;
                          onInsert?: Inserter<string, {}>;
                          perf?: Perf;
                          sizeCalculation?: SizeCalculator<string, {}>;
                          ttl: number;
                          ttlAutopurge: boolean;
                          ttlResolution?: number;
                          updateAgeOnGet?: boolean;
                          updateAgeOnHas?: boolean;
                      }
                      | {
                          allowStale?: boolean;
                          allowStaleOnFetchAbort?: boolean;
                          allowStaleOnFetchRejection?: boolean;
                          dispose?: Disposer<string, {}>;
                          disposeAfter?: Disposer<string, {}>;
                          fetchMethod?: Fetcher<string, {}, unknown>;
                          ignoreFetchAbort?: boolean;
                          max: number;
                          maxEntrySize?: number;
                          maxSize?: number;
                          memoMethod?: Memoizer<string, {}, unknown>;
                          noDeleteOnFetchRejection?: boolean;
                          noDeleteOnStaleGet?: boolean;
                          noDisposeOnSet?: boolean;
                          noUpdateTTL?: boolean;
                          onInsert?: Inserter<string, {}>;
                          perf?: Perf;
                          sizeCalculation?: SizeCalculator<string, {}>;
                          ttl: number;
                          ttlAutopurge: boolean;
                          ttlResolution?: number;
                          updateAgeOnGet?: boolean;
                          updateAgeOnHas?: boolean;
                      }
                      | {
                          allowStale?: boolean;
                          allowStaleOnFetchAbort?: boolean;
                          allowStaleOnFetchRejection?: boolean;
                          dispose?: Disposer<string, {}>;
                          disposeAfter?: Disposer<string, {}>;
                          fetchMethod?: Fetcher<string, {}, unknown>;
                          ignoreFetchAbort?: boolean;
                          max: number;
                          maxEntrySize?: number;
                          maxSize?: number;
                          memoMethod?: Memoizer<string, {}, unknown>;
                          noDeleteOnFetchRejection?: boolean;
                          noDeleteOnStaleGet?: boolean;
                          noDisposeOnSet?: boolean;
                          noUpdateTTL?: boolean;
                          onInsert?: Inserter<string, {}>;
                          perf?: Perf;
                          sizeCalculation?: SizeCalculator<string, {}>;
                          ttl: number;
                          ttlAutopurge: boolean;
                          ttlResolution?: number;
                          updateAgeOnGet?: boolean;
                          updateAgeOnHas?: boolean;
                      };
                  map: Map<string, ICacheInstance>;
                  pendingCreates: Map<string, Promise<ICacheInstance>>;
              },
          >,
          {
              cacheFactoryTask: ITask<
                  CacheFactoryOptions,
                  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<
              {
                  semaphores: Set<Semaphore>;
                  semaphoresByConfig: WeakMap<ConcurrencyMiddlewareConfig, Semaphore>;
                  semaphoresByKey: Map<string, { limit: number; semaphore: Semaphore }>;
              },
          >,
          {},
          any,
          any,
          ITag<{ metadata?: Record<string, any> }, void, void>[],
          ResourceMiddlewareAttachmentType[],
      >;
      cron: IResource<
          void,
          Promise<CronResourceValue>,
          CronResourceDependencies,
          any,
          any,
          TagType[],
          ResourceMiddlewareAttachmentType[],
      >;
      debug: IResource<
          DebugFriendlyConfig,
          Promise<any>,
          {},
          any,
          { description: string; title: string },
          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>;
              },
          >,
          {},
          {
              cleanupTimers: Map<string, Timeout>;
              disposed: boolean;
              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[],
      >;
      runtime: IResource<
          void,
          Promise<RunResult<unknown>>,
          {},
          any,
          any,
          TagType[],
          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<TemporalResourceState>,
          {},
          any,
          any,
          ITag<{ metadata?: Record<string, any> }, void, void>[],
          ResourceMiddlewareAttachmentType[],
      >;
  }

• tags: GlobalTags

• tunnels: Readonly<
      {
          http: Readonly<
              { createClient(cfg: HttpCreateClientConfig): ExposureFetchClient },
          >;
      },
  >