@stackone/transport 1.7.0 → 1.8.2

package/dist/index.d.ts

@@ -0,0 +1,753 @@
+import { ILogger } from "@stackone/logger";
+import * as redis from "redis";
+import { AxiosInstance, AxiosInterceptorOptions, AxiosResponse, CreateAxiosDefaults, InternalAxiosRequestConfig } from "axios";
+import { z } from "zod/v4";
+import https from "https";
+import { AgentOptions } from "node:http";
+
+//#region src/authorization/types.d.ts
+type BasicAuthorizationParams = {
+  type: 'basic';
+  username?: string;
+  password?: string;
+  encoding?: string;
+};
+type BearerAuthorizationParams = {
+  type: 'bearer';
+  token: string;
+  includeBearer?: boolean;
+};
+//#endregion
+//#region src/authorization/authorizationHeaders.d.ts
+declare const createAuthorizationHeaders: (authenticationParams: BasicAuthorizationParams | BearerAuthorizationParams) => {
+  authorization: string;
+};
+//#endregion
+//#region src/cacheClient/types.d.ts
+interface ICacheClient<ClientType = unknown> {
+  getData<T>(key: string): Promise<T | null>;
+  listData<T>({
+    partialKey,
+    limit,
+    cursor
+  }: {
+    partialKey: string;
+    limit?: number;
+    cursor?: string;
+  }): Promise<{
+    items: T[] | null;
+    cursor?: string;
+  }>;
+  setData<T>({
+    key,
+    value,
+    cacheTTL,
+    groupKey
+  }: {
+    key: string;
+    value: T;
+    cacheTTL: number;
+    groupKey?: string;
+  }): Promise<boolean>;
+  executeScript?<T>({
+    sha1,
+    keys,
+    args
+  }: {
+    sha1: string;
+    keys: string[];
+    args: string[];
+  }): Promise<T | null>;
+  loadScript?(script: string): Promise<string | null>;
+  increment?(key: string, cacheTTL: number): Promise<number | null>;
+  decrement?(key: string, cacheTTL: number): Promise<number | null>;
+  subscribe?<T extends boolean = false>(pattern: string, listener: PubSubListener<T>): Promise<boolean>;
+  unsubscribe?(pattern: string): Promise<boolean>;
+  publish?(channel: string, message: string): Promise<number | null>;
+  getClient?(): ClientType | null;
+  deleteData?(key: string): Promise<boolean>;
+}
+type PubSubListener<ReturnsBuffer extends boolean = false> = <T extends (ReturnsBuffer extends true ? Buffer : string)>(message: T, channel: T) => unknown;
+//#endregion
+//#region src/redisClient/index.d.ts
+type RedisClientType = redis.RedisClientType;
+interface RedisClientConfig {
+  getRedisClient?: typeof redis.createClient;
+  host?: string;
+  port?: number;
+  tls?: boolean;
+  reconnect?: boolean;
+  database?: number;
+}
+declare const buildRedisClientInstance: (config: RedisClientConfig, logger?: ILogger) => Promise<ICacheClient<RedisClientType> | undefined>;
+declare class RedisClient implements ICacheClient<RedisClientType> {
+  #private;
+  static build({
+    getRedisClient,
+    host,
+    port,
+    tls,
+    reconnect,
+    database
+  }: RedisClientConfig, logger?: ILogger): Promise<ICacheClient<RedisClientType> | null>;
+  getData<T>(key: string): Promise<T | null>;
+  setData<T>({
+    key,
+    value,
+    cacheTTL,
+    groupKey
+  }: {
+    key: string;
+    value: T;
+    cacheTTL: number;
+    groupKey?: string;
+  }): Promise<boolean>;
+  executeScript<T>({
+    sha1,
+    keys,
+    args
+  }: {
+    sha1: string;
+    keys: string[];
+    args: string[];
+  }): Promise<T | null>;
+  loadScript(script: string): Promise<string | null>;
+  increment(key: string, cacheTTL: number): Promise<number | null>;
+  decrement(key: string, cacheTTL: number): Promise<number | null>;
+  subscribe<T extends boolean>(pattern: string, listener: PubSubListener<T>): Promise<boolean>;
+  unsubscribe(pattern: string): Promise<boolean>;
+  publish(channel: string, message: string): Promise<number | null>;
+  getClient(): RedisClientType | null;
+  listData<T>({
+    partialKey,
+    limit,
+    cursor
+  }: {
+    partialKey: string;
+    limit: number;
+    cursor?: string;
+  }): Promise<{
+    items: T[] | null;
+    cursor?: string;
+  }>;
+  deleteData(key: string): Promise<boolean>;
+}
+//#endregion
+//#region src/scriptManager/types.d.ts
+type Scripts<T extends string> = Record<T, string>;
+type ScriptManagerOptions<T extends string> = {
+  redisClientConfig: RedisClientConfig;
+  logger?: ILogger;
+  scriptMap?: Map<T, string>;
+};
+//#endregion
+//#region src/scriptManager/index.d.ts
+declare class ScriptManager<T extends string> {
+  protected cacheClient: ICacheClient<RedisClientType> | null;
+  protected scriptMap: Map<string, string>;
+  protected logger?: ILogger;
+  protected scripts: Scripts<T>;
+  protected redisClientConfig: RedisClientConfig;
+  constructor(preLoadScripts: Scripts<T>);
+  protected initialize({
+    redisClientConfig,
+    logger,
+    scriptMap
+  }: ScriptManagerOptions<T>, ...args: unknown[]): Promise<void>;
+  protected additionalInitialization(..._args: unknown[]): Promise<void>;
+  protected loadScripts<U extends string>(scripts: Scripts<U>, scriptMap?: Map<U, string>): Promise<void>;
+  protected executeScript<X extends string, U>(method: X, keys: string[], args: string[]): Promise<U | null>;
+  protected isReady(): Promise<boolean>;
+}
+//#endregion
+//#region src/concurrencyManager/types.d.ts
+type ConcurrencySubPoolConfig = {
+  subPoolKey: string;
+  urlPattern: RegExp | string;
+  maxConcurrency: number;
+};
+type ConcurrencyConfig = {
+  mainMaxConcurrency: number;
+  subPools?: ConcurrencySubPoolConfig[];
+};
+type RequestMetadata = {
+  requestId: string;
+  targetConcurrencyKey: string;
+  leaseSubscription: boolean;
+  setRemovalSubscription: boolean;
+  queueKey: string;
+  joinCondition?: 'optimistic' | 'attempts' | 'failed';
+  failureReason?: string;
+};
+//#endregion
+//#region src/concurrencyManager/utils/index.d.ts
+declare enum ConcurrencyMethods {
+  tryConcurrency = "tryConcurrency",
+  removeFromSet = "removeFromSet",
+  publishNextItem = "publishNextItem",
+}
+//#endregion
+//#region src/concurrencyManager/index.d.ts
+declare class ConcurrencyManager extends ScriptManager<ConcurrencyMethods> {
+  private static instance;
+  private static asyncInstanceInit;
+  private static hasValidRedisConfig;
+  private static lastInitFailure;
+  private static RETRY_WINDOW_MS;
+  private static logger?;
+  private static initConfig;
+  private subscriptionManager;
+  private queueManager;
+  private generateUUID;
+  static getInstance(config?: RedisClientConfig, logger?: ILogger, scriptMap?: Map<ConcurrencyMethods, string>, generateUUID?: () => string): Promise<ConcurrencyManager>;
+  protected additionalInitialization(generateUUID?: () => string): Promise<void>;
+  private addTestSubscription;
+  private checkRedisEventsEmit;
+  isRedisConfigured(): Promise<boolean>;
+  private subscribeToLeaseExpiry;
+  private subscribeToSetRemoval;
+  registerRequest(requestKey: string, config: ConcurrencyConfig, requestId: string, requestUrl: string | undefined): Promise<RequestMetadata>;
+  releaseRequest(requestId: string, targetConcurrencyKey: string): Promise<boolean>;
+  private readyCheck;
+  static isReady(): Promise<boolean>;
+  static close(): void;
+}
+//#endregion
+//#region src/customErrors/schemas.d.ts
+declare const CUSTOM_ERROR_CONFIG_SCHEMA: z.ZodObject<{
+  receivedStatus: z.ZodNumber;
+  targetStatus: z.ZodNumber;
+  message: z.ZodOptional<z.ZodString>;
+  condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+//#region src/customErrors/types.d.ts
+type CustomErrorConfig = z.infer<typeof CUSTOM_ERROR_CONFIG_SCHEMA>;
+declare const HttpErrorMessages: Record<number, string>;
+//#endregion
+//#region src/httpClient/types.d.ts
+type HttpHeaders = {
+  [key: string]: string;
+};
+type HttpQueryParams = {
+  [key: string]: string;
+};
+declare const HttpMethods: readonly ["get", "post", "put", "delete", "patch"];
+type HttpMethod = (typeof HttpMethods)[number];
+type HttpResponse<T = any> = {
+  data: T;
+  status: number;
+  headers: HttpHeaders;
+  requestUrl: string;
+  responseType?: string;
+  responseTime?: Date;
+  message?: string;
+};
+type HttpParameters = {
+  query: HttpQueryParams;
+  body: Record<string, unknown>;
+  headers: HttpHeaders;
+};
+interface IHttpClient {
+  request<P, T>({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    responseType,
+    cacheTTL,
+    context,
+    payload,
+    httpsAgent
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+    httpsAgent?: https.Agent;
+  }): Promise<HttpResponse<T>>;
+  get<T>({
+    headers,
+    url,
+    queryParams,
+    maxRedirects,
+    cacheTTL,
+    context
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+  }): Promise<HttpResponse<T>>;
+  post<P, T>({
+    headers,
+    url,
+    maxRedirects,
+    cacheTTL,
+    context,
+    payload
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+  }): Promise<HttpResponse<T>>;
+}
+interface OperationSetting {
+  url?: string;
+  query?: Record<string, string>;
+  config?: Partial<APIConfig>;
+  custom_settings?: Record<string, unknown>;
+}
+type OperationSettings = Record<string, OperationSetting>;
+type AccountSettings = Record<string, string | number | boolean | object>;
+type HttpClientBehaviour = 'CONCURRENCY' | 'RETRY';
+type APIConfig = Record<string, unknown>;
+type RequestContext = {
+  accountSecureId?: string;
+  projectSecureId?: string;
+  organizationId?: number;
+  environment?: string;
+  authConfigKey?: string;
+  provider?: string;
+  service?: string;
+  resource?: string;
+  subResource?: string;
+  childResource?: string;
+  operation?: string;
+  action?: string;
+  mode?: string;
+  testerUniqueToken?: string;
+  externalKey?: string;
+  dataKey?: string;
+  isDataSync?: boolean;
+  operationSettings?: OperationSettings;
+  accountSettings?: AccountSettings;
+  behaviours?: HttpClientBehaviour[];
+};
+//#endregion
+//#region src/errors/httpResponseError.d.ts
+declare class HttpResponseError extends Error {
+  readonly response: HttpResponse;
+  constructor(response: HttpResponse, message?: string);
+  toString(): string;
+}
+//#endregion
+//#region src/lockManager/index.d.ts
+declare class LockManager {
+  private locks;
+  constructor();
+  withLock<T>(key: string, operation: () => Promise<T>): Promise<T>;
+  lock(key: string): Promise<void>;
+  unlock(key: string): void;
+  queueLength(key: string): number | undefined;
+  close(): void;
+}
+//#endregion
+//#region src/memoryStore/types.d.ts
+interface MemoryStoreConfig<T> {
+  instantiator?: string;
+  logger?: ILogger;
+  dataStore?: Map<string, T>;
+  lockManager?: LockManager;
+  expiryMap?: Map<string, number>;
+  evictionFrequency?: number;
+  staleDataThreshold?: number;
+  truncateThreshold?: number;
+  truncationPercentage?: number;
+  typeGuard?: (data: unknown) => data is T;
+  dispose?: (key: string, value: T) => Promise<void> | void;
+}
+type PruneCount = {
+  dataStoreSize: number;
+  prunedDataStoreSize: number;
+};
+//#endregion
+//#region src/eventClient/types.d.ts
+type PromiseExecutorMethods<T> = {
+  resolve?: (value: T) => void;
+  reject?: (reason: unknown) => void;
+};
+type EventClientConfig<T> = {
+  instantiator?: string;
+  defaultTimeoutMS?: number;
+  timeoutResolveValue?: T;
+};
+//#endregion
+//#region src/eventClient/index.d.ts
+declare class EventClient<T> {
+  private executorMethodStore;
+  private promiseStore;
+  private logger;
+  private eventClientConfig?;
+  private executorMethodStoreConfig?;
+  private pendingPromiseStoreConfig?;
+  constructor(eventClientConfig?: EventClientConfig<T>, executorMethodStoreConfig?: MemoryStoreConfig<PromiseExecutorMethods<T> | undefined>, pendingPromiseStoreConfig?: MemoryStoreConfig<Promise<T> | undefined>);
+  setPendingEvent(eventKey: string, timeoutInMS: number): Promise<void>;
+  waitForEvent(eventKey: string, timeoutInMS: number): Promise<T | null>;
+  getPendingEvent(eventKey: string): Promise<T | null>;
+  deleteEvent(eventKey: string): Promise<boolean>;
+  resolveEvent(eventKey: string, value: T): Promise<void>;
+  private defaultExecutorMethodDispose;
+  private defaultExecutorMethodTypeGuard;
+  private defaultPendingPromiseDispose;
+  private defaultPendingPromiseTypeGuard;
+}
+//#endregion
+//#region src/getTransportInstance/index.d.ts
+declare const getTransportInstance: (logger: ILogger, context?: RequestContext) => Promise<AxiosInstance>;
+//#endregion
+//#region src/httpClient/httpClient.d.ts
+declare class HttpClient implements IHttpClient {
+  #private;
+  constructor({
+    transportInstance
+  }?: {
+    transportInstance?: AxiosInstance;
+  });
+  request<P, T>({
+    headers,
+    url,
+    method,
+    queryParams,
+    maxRedirects,
+    responseType,
+    cacheTTL,
+    context,
+    payload,
+    httpsAgent
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    method?: HttpMethod;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+    httpsAgent?: https.Agent;
+  }): Promise<HttpResponse<T>>;
+  get<T>({
+    headers,
+    url,
+    queryParams,
+    maxRedirects,
+    cacheTTL,
+    context
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    queryParams?: HttpQueryParams;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+  }): Promise<HttpResponse<T>>;
+  post<P, T>({
+    headers,
+    url,
+    maxRedirects,
+    cacheTTL,
+    context,
+    payload
+  }: {
+    headers?: HttpHeaders;
+    url: string;
+    maxRedirects?: number;
+    cacheTTL?: number;
+    context?: unknown;
+    payload?: P;
+  }): Promise<HttpResponse<T>>;
+}
+//#endregion
+//#region src/httpClient/httpClientManager.d.ts
+declare const buildHttpClientInstance: () => IHttpClient;
+declare class HttpClientManager {
+  private static httpClientInstance;
+  static getInstance({
+    getHttpClient
+  }?: {
+    getHttpClient?: typeof buildHttpClientInstance;
+  }): Promise<IHttpClient>;
+  static resetInstance(): void;
+}
+//#endregion
+//#region src/rateLimitManager/types.d.ts
+type RateLimitSubPoolConfig = {
+  subPoolKey: string;
+  urlPattern: RegExp | string;
+  rateLimit: number;
+};
+type RetryUnit = 'seconds' | 'milliseconds' | 'date';
+type MappedRateLimitErrorConfig = {
+  errorStatus: number;
+  errorMessage: string | RegExp;
+  errorMessagePath?: string;
+  retryAfterPath?: string;
+  retryAfterUnit?: RetryUnit;
+  retryAfterValue?: number;
+};
+type RateLimitConfig = {
+  mainRatelimit: number;
+  subPools?: RateLimitSubPoolConfig[];
+  mappedRateLimitErrors?: MappedRateLimitErrorConfig[];
+};
+//#endregion
+//#region src/interceptors/types.d.ts
+type RequestInterceptor = (value: InternalAxiosRequestConfig<unknown>) => InternalAxiosRequestConfig<unknown> | Promise<InternalAxiosRequestConfig<unknown>>;
+type ResponseInterceptor = (value: AxiosResponse<unknown, unknown>) => AxiosResponse<unknown, unknown> | Promise<AxiosResponse<unknown, unknown>>;
+type ErrorInterceptor = (error: unknown) => unknown;
+type Interceptor = RequestInterceptor | ResponseInterceptor | ErrorInterceptor | null;
+interface InterceptorDependencies {
+  axiosInstance?: AxiosInstance;
+  logger?: ILogger;
+  context?: RequestContext;
+  requestConfig?: RequestConfig;
+  [key: string]: unknown;
+}
+type RequestConfig = {
+  rateLimits?: RateLimitConfig;
+  concurrency?: ConcurrencyConfig;
+};
+//#endregion
+//#region src/httpTransportFactory/types.d.ts
+type InterceptorDependencyInjector<T extends Interceptor> = (dependencies: InterceptorDependencies) => T;
+type RequestInterceptorConfig = {
+  onFulfilled: InterceptorDependencyInjector<RequestInterceptor> | RequestInterceptor | null;
+  onRejected: InterceptorDependencyInjector<ErrorInterceptor> | ErrorInterceptor | null;
+  options: AxiosInterceptorOptions | undefined;
+};
+type ResponseInterceptorConfig = {
+  onFulfilled: InterceptorDependencyInjector<ResponseInterceptor> | ResponseInterceptor | null;
+  onRejected: InterceptorDependencyInjector<ErrorInterceptor> | ErrorInterceptor | null;
+};
+type InterceptorConfigs = {
+  requestConfigs?: RequestInterceptorConfig[];
+  responseConfigs?: ResponseInterceptorConfig[];
+};
+type HttpTransportInstanceConfig = {
+  interceptors?: InterceptorConfigs;
+  instanceConfig?: CreateAxiosDefaults;
+  httpAgentConfig?: AgentOptions;
+  logger: ILogger;
+  context?: RequestContext;
+};
+//#endregion
+//#region src/httpTransportFactory/index.d.ts
+declare class HttpTransportFactory {
+  static createInstance({
+    interceptors,
+    instanceConfig,
+    httpAgentConfig,
+    logger,
+    context
+  }: HttpTransportInstanceConfig): AxiosInstance;
+  private static applyInterceptors;
+  private static resolveInterceptorInstance;
+}
+//#endregion
+//#region src/instanceManager/index.d.ts
+declare class InstanceManager {
+  private static instance;
+  private static logger;
+  private dataStore;
+  private constructor();
+  static getInstance(logger?: ILogger): InstanceManager;
+  private initialize;
+  get<T>(key: string): Promise<T | null>;
+  set<T>(key: string, value: T, cacheTTL?: number): Promise<boolean>;
+  private ensureReady;
+  isReady(): boolean;
+  close(): void;
+}
+//#endregion
+//#region src/memoryStore/index.d.ts
+declare class MemoryStore<T> implements ICacheClient {
+  private config;
+  private instantiator;
+  private dataStore;
+  private lockManager;
+  private expiryMap;
+  private evictionFrequency;
+  private staleDataThreshold;
+  private truncateThreshold;
+  private truncationPercentage;
+  private logger?;
+  private typeGuard?;
+  private dispose?;
+  private evictionInterval?;
+  private lastAccessedAt;
+  constructor(config?: MemoryStoreConfig<T>);
+  private initialize;
+  getData<U = T>(key: string): Promise<U | null>;
+  setData<U = T>({
+    key,
+    value,
+    cacheTTL
+  }: {
+    key: string;
+    value: U;
+    cacheTTL?: number;
+  }): Promise<boolean>;
+  private typeGuardBypass;
+  delete(key: string): Promise<boolean>;
+  pruneExpiredKeys(): Promise<PruneCount | undefined>;
+  private startEvictionTask;
+  private stopEvictionTask;
+  private updateLastAccessedAt;
+  isReady(): boolean;
+  close(): void;
+  listData<T>({
+    partialKey,
+    cursor,
+    limit
+  }: {
+    partialKey: string;
+    cursor?: string;
+    limit: number;
+  }): Promise<{
+    items: T[] | null;
+    cursor?: string;
+  }>;
+}
+//#endregion
+//#region src/parsers/types.d.ts
+declare const RequestParameterLocations: readonly ["query", "body", "headers"];
+type RequestParameterLocation = (typeof RequestParameterLocations)[number];
+type RequestParameter = {
+  name: string;
+  in: RequestParameterLocation;
+  value?: unknown;
+};
+//#endregion
+//#region src/parsers/requestParameters.d.ts
+declare const parseRequestParameters: (parameters: RequestParameter[]) => HttpParameters;
+//#endregion
+//#region src/queueManager/utils/enums.d.ts
+declare enum QueueMethods {
+  rPush = "rPush",
+  lPush = "lPush",
+  lPop = "lPop",
+  llen = "llen",
+}
+//#endregion
+//#region src/queueManager/types.d.ts
+type OnTurnFunction<T> = (queueName: string, value: string) => T | Promise<T>;
+//#endregion
+//#region src/queueManager/index.d.ts
+declare class QueueManager extends ScriptManager<QueueMethods> {
+  private static instance;
+  private static asyncInstanceInit;
+  private static logger?;
+  private static config?;
+  protected logger?: ILogger;
+  private subscriptionManager;
+  private eventClient;
+  static getInstance(config?: RedisClientConfig, logger?: ILogger, scriptMap?: Map<QueueMethods, string>): Promise<QueueManager>;
+  protected additionalInitialization(): Promise<void>;
+  joinAndWaitTurn<T>(queueName: string, value: string, hasPriority: boolean, onTurn: OnTurnFunction<T>, coldStartEnabled?: boolean): Promise<T | null>;
+  pop<T>(queueName: string): Promise<T | null>;
+  length(queueName: string): Promise<number | null>;
+  private readyCheck;
+  isReady(): Promise<boolean>;
+  close(): void;
+}
+//#endregion
+//#region src/rateLimitManager/constants.d.ts
+declare enum RateLimitMethods {
+  incr = "incr",
+}
+//#endregion
+//#region src/rateLimitManager/index.d.ts
+declare class RateLimitManager extends ScriptManager<RateLimitMethods> {
+  private static instance;
+  private static asyncInstanceInit;
+  private static logger?;
+  private static initConfig;
+  static getInstance(config?: RedisClientConfig, logger?: ILogger, scriptMap?: Map<RateLimitMethods, string>): Promise<RateLimitManager>;
+  getDynamicMaxWaitTime(ratelimitConfig: RateLimitConfig, concurrencyConfig: ConcurrencyConfig, requestUrl?: string, cutoffTime?: number, fudgeFactor?: number, ballparkResponseTime?: number): Promise<number>;
+  getWaitTime(requestKey: any, config: RateLimitConfig, requestUrl?: string): Promise<number | null>;
+  private readyCheck;
+  static isReady(): Promise<boolean>;
+  static close(): void;
+}
+//#endregion
+//#region src/requestClient/types.d.ts
+interface IRequestClient {
+  performRequest: ({
+    httpClient,
+    url,
+    method,
+    headers,
+    body,
+    customErrorConfigs
+  }: {
+    httpClient: IHttpClient;
+    url: string;
+    method: HttpMethod;
+    headers: HttpHeaders;
+    queryParams?: HttpQueryParams;
+    body: unknown;
+    customErrorConfigs?: CustomErrorConfig[];
+  }) => Promise<HttpResponse>;
+}
+type RequestClientType = 'rest' | 'soap';
+//#endregion
+//#region src/requestClient/requestClientFactory.d.ts
+declare class RequestClientFactory {
+  static build(type?: RequestClientType): IRequestClient;
+}
+//#endregion
+//#region src/redisClient/types.d.ts
+type GetRedisClient = typeof buildRedisClientInstance;
+//#endregion
+//#region src/subscriptionManager/types.d.ts
+type SubscriptionManagerOptions = {
+  config?: RedisClientConfig;
+  getCacheClient?: GetRedisClient;
+  logger?: ILogger;
+  instantiator?: string;
+  subscriptionTTL?: number;
+  staleSubscriptionsThreshold?: number;
+  truncateThreshold?: number;
+  truncationPercentage?: number;
+};
+//#endregion
+//#region src/subscriptionManager/index.d.ts
+declare class SubscriptionManager {
+  private options;
+  private subscriptionMap;
+  private subscriptionClient;
+  private logger?;
+  constructor(options: SubscriptionManagerOptions);
+  initialize(options?: SubscriptionManagerOptions): Promise<void>;
+  subscribe<T extends boolean = false>(key: string, listener: PubSubListener<T>): Promise<boolean>;
+  unsubscribe(key: string): Promise<boolean>;
+  isReady(): boolean;
+  close(): void;
+}
+//#endregion
+//#region src/validators/statusCodes.d.ts
+declare const isSuccessStatusCode: (status: number | undefined) => boolean;
+declare const isFailedStatusCode: (status: number | undefined) => boolean;
+declare const isInfoStatusCode: (status: number | undefined) => boolean;
+//#endregion
+//#region src/lockManager/types.d.ts
+type Lock = Promise<void>;
+type Unlock = () => void;
+type LockEntry = {
+  lock: Lock;
+  unlock: Unlock;
+};
+//#endregion
+export { CUSTOM_ERROR_CONFIG_SCHEMA, ConcurrencyManager, CustomErrorConfig, EventClient, HttpClient, HttpClientManager, HttpErrorMessages, HttpHeaders, HttpMethod, HttpMethods, HttpParameters, HttpQueryParams, HttpResponse, HttpResponseError, HttpTransportFactory, ICacheClient, IHttpClient, InstanceManager, Lock, LockEntry, LockManager, MemoryStore, MemoryStoreConfig, PruneCount, PubSubListener, QueueManager, RateLimitManager, RedisClient, RequestClientFactory, RequestParameter, RequestParameterLocations, ScriptManager, SubscriptionManager, Unlock, createAuthorizationHeaders, getTransportInstance, isFailedStatusCode, isInfoStatusCode, isSuccessStatusCode, parseRequestParameters };