perimeterx-js-core 0.31.0 → 0.32.1

package/lib/types/context/DefaultContext.d.ts

@@ -21,7 +21,7 @@ export type DefaultContextOptions = {
  * The default implementation of the request context which uses the incoming HTTP request and enforcer configuration
  * to populate the context with relevant data.
  */
-export declare class DefaultContext<Req, Res, Added, Removed> implements IContext<Req, Res> {
+export declare class DefaultContext<Req, Res, Supported extends string, Added> implements IContext<Req, Res> {
     readonly requestId: string;
     readonly tokenOrigin: TokenOrigin;
     readonly remoteConfigUpdateData: RemoteConfigUpdateData;
@@ -49,19 +49,19 @@ export declare class DefaultContext<Req, Res, Added, Removed> implements IContex
     usedCookieSecret?: string;
     shouldSendTelemetry: boolean;
     protected _shouldSendLogs: boolean;
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly urlUtils: IUrlUtils;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, request: IIncomingRequest<Req>, options: DefaultContextOptions);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, request: IIncomingRequest<Req>, options: DefaultContextOptions);
     get shouldSendLogs(): boolean;
     set shouldSendLogs(shouldSendLogs: boolean);
     get isMobile(): boolean;
-    protected createContextLogger(config: IConfiguration<Req, Res, Added, Removed>, shouldSaveLogs: boolean): ILogger;
-    protected createRequestData(config: IConfiguration<Req, Res, Added, Removed>, request: IIncomingRequest<Req>, cookieParser?: ICookieParser): RequestData<Req>;
+    protected createContextLogger(config: IConfiguration<Req, Res, Supported, Added>, shouldSaveLogs: boolean): ILogger;
+    protected createRequestData(config: IConfiguration<Req, Res, Supported, Added>, request: IIncomingRequest<Req>, cookieParser?: ICookieParser): RequestData<Req>;
     protected normalizeUrl(rawUrl: string): IUrl;
-    protected extractUserAgentFromHeader(config: IConfiguration<Req, Res, Added, Removed>, headers: ReadonlyHeaders): string;
-    protected extractIpFromHeader(config: IConfiguration<Req, Res, Added, Removed>, headers: ReadonlyHeaders): string | null;
+    protected extractUserAgentFromHeader(config: IConfiguration<Req, Res, Supported, Added>, headers: ReadonlyHeaders): string;
+    protected extractIpFromHeader(config: IConfiguration<Req, Res, Supported, Added>, headers: ReadonlyHeaders): string | null;
     protected getTokenOrigin(request: IIncomingRequest<Req>): TokenOrigin;
     protected setCookiesOnContext(): void;
-    protected isHeaderBasedLoggerRequest(config: IConfiguration<Req, Res, Added, Removed>, request: IIncomingRequest<Req>): boolean;
+    protected isHeaderBasedLoggerRequest(config: IConfiguration<Req, Res, Supported, Added>, request: IIncomingRequest<Req>): boolean;
     toJSON(): ContextJson<Req, Res>;
 }

package/lib/types/context/SerializedContext.d.ts

@@ -17,7 +17,7 @@ import { ContextJson } from './ContextJson';
  * incoming request, but rather uses already-extracted data from the `ContextJson` (likely returned from the `DefaultContext.toJSON()`
  * function) and fills in the gaps using the other parameters.
  */
-export declare class SerializedContext<Req, Res, Added, Removed> implements IContext<Req, Res> {
+export declare class SerializedContext<Req, Res, Supported extends string, Added> implements IContext<Req, Res> {
     readonly isMobile: boolean;
     readonly remoteConfigUpdateData: RemoteConfigUpdateData;
     readonly logger: ILogger;
@@ -44,9 +44,9 @@ export declare class SerializedContext<Req, Res, Added, Removed> implements ICon
     tokenOrigin: TokenOrigin;
     uuid?: string;
     shouldSendTelemetry: boolean;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, contextJson: ContextJson<Req, Res>, request: IIncomingRequest<Req>, urlUtils: IUrlUtils);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, contextJson: ContextJson<Req, Res>, request: IIncomingRequest<Req>, urlUtils: IUrlUtils);
     protected createRequestData({ requestData }: ContextJson<Req, Res>, request: IIncomingRequest<Req>, urlUtils: IUrlUtils): RequestData<Req>;
-    protected createTokenData({ tokenData }: ContextJson<Req, Res>, config: IConfiguration<Req, Res, Added, Removed>): TokenData<Req, Res>;
+    protected createTokenData({ tokenData }: ContextJson<Req, Res>, config: IConfiguration<Req, Res, Supported, Added>): TokenData<Req, Res>;
     protected createRiskApiData({ riskApiData }: ContextJson<Req, Res>): RiskApiData;
-    protected createLogger(config: IConfiguration<Req, Res, Added, Removed>, shouldSendLogs: boolean, logs?: LogRecord[]): ILogger;
+    protected createLogger(config: IConfiguration<Req, Res, Supported, Added>, shouldSendLogs: boolean, logs?: LogRecord[]): ILogger;
 }

package/lib/types/cors/DefaultCors.d.ts

@@ -2,11 +2,11 @@ import { ICors } from './ICors';
 import { IConfiguration } from '../config';
 import { ReadonlyContext } from '../context';
 import { ReadonlyHeaders, IMinimalResponse } from '../http';
-export declare class DefaultCors<Req, Res, Added, Removed> implements ICors<Req, Res> {
+export declare class DefaultCors<Req, Res, Supported extends string, Added> implements ICors<Req, Res> {
     private readonly customBlockResponseHeaders;
     private readonly customPreflightHandler;
     private readonly logger;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>);
     isPreflightRequest(context: ReadonlyContext<Req, Res>): boolean;
     runPreflightCustomHandler(context: ReadonlyContext<Req, Res>): Promise<IMinimalResponse | null>;
     isCorsRequest(context: ReadonlyContext<Req, Res>): boolean;

package/lib/types/custom_parameters/CustomParametersFunction.d.ts

@@ -1,4 +1,4 @@
 import { CustomParameters, ResponseCustomParameters } from './CustomParameters';
 import { ActiveConfigurationParams } from '../config';
-export type CustomParametersFunction<Req, Res, Added, Removed> = (config: ActiveConfigurationParams<Req, Res, Added, Removed>, request: Req) => CustomParameters | Promise<CustomParameters>;
-export type ResponseCustomParametersFunction<Req, Res, Added, Removed> = (config: ActiveConfigurationParams<Req, Res, Added, Removed>, response: Res) => ResponseCustomParameters | Promise<ResponseCustomParameters>;
+export type CustomParametersFunction<Req, Res, Supported extends string, Added> = (config: ActiveConfigurationParams<Req, Res, Supported, Added>, request: Req) => CustomParameters | Promise<CustomParameters>;
+export type ResponseCustomParametersFunction<Req, Res, Supported extends string, Added> = (config: ActiveConfigurationParams<Req, Res, Supported, Added>, response: Res) => ResponseCustomParameters | Promise<ResponseCustomParameters>;

package/lib/types/custom_parameters/CustomParametersUtils.d.ts

@@ -2,8 +2,8 @@ import { IConfiguration } from '../config';
 import { ReadonlyContext } from '../context';
 import { CustomParameters, ResponseCustomParameters } from './CustomParameters';
 export declare namespace CustomParametersUtils {
-    const createCustomParameters: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => Promise<CustomParameters | null>;
-    const createResponseCustomParameters: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => Promise<ResponseCustomParameters | null>;
+    const createCustomParameters: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, context: ReadonlyContext<Req, Res>) => Promise<CustomParameters | null>;
+    const createResponseCustomParameters: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, context: ReadonlyContext<Req, Res>) => Promise<ResponseCustomParameters | null>;
     const normalizeCustomParams: (customParameters: Record<string, any>) => CustomParameters | null;
     const normalizeResponseCustomParams: (customParameters: Record<string, any>) => ResponseCustomParameters | null;
 }

package/lib/types/enforcer/EnforcerBase.d.ts

@@ -1,5 +1,5 @@
 import { AsyncOrSync } from 'ts-essentials';
-import { IConfiguration, IRemoteConfigManager } from '../config';
+import { IConfiguration, IRemoteConfigManager, CoreConfigurationParamsKeys } from '../config';
 import { IContext } from '../context';
 import { IMinimalResponse, IOutgoingResponse } from '../http';
 import { IFlow } from '../flow';
@@ -10,8 +10,8 @@ import { IPostEnforcer } from './IPostEnforcer';
 /**
  * The base class for fundamental enforcer logic.
  */
-export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[], PostEnforceArgs extends any[], Added, Removed> implements IEnforcer<EnforceArgs, Promise<Res | null>>, IPostEnforcer<PostEnforceArgs, Promise<void>> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[], PostEnforceArgs extends any[], Supported extends CoreConfigurationParamsKeys, Added> implements IEnforcer<EnforceArgs, Promise<Res | null>>, IPostEnforcer<PostEnforceArgs, Promise<void>> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly filterFlow: IFlow<Req, Res>;
     protected readonly enforceFlow: IFlow<Req, Res>;
     protected readonly postEnforceFlow: IFlow<Req, Res> | null;
@@ -61,7 +61,7 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @param options - An EnforcerOptions object that allows for overriding any functional building blocks in the enforcer.
      * @protected
      */
-    protected constructor(config: IConfiguration<Req, Res, Added, Removed>, options: EnforcerOptions<Req, Res, Added, Removed>);
+    protected constructor(config: IConfiguration<Req, Res, Supported, Added>, options: EnforcerOptions<Req, Res, Supported, Added>);
     /**
      * Creates the filter flow for the enforcer. The filter flow is responsible for filtering out requests that should not undergo the usual enforcement flow.
      * For example, first party, filtered, CORS preflight, and telemetry requests are filtered out.
@@ -70,7 +70,7 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @protected
      * @returns - The filter flow for the enforcer.
      */
-    protected createFilterFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IFlow<Req, Res>;
+    protected createFilterFlow(config: IConfiguration<Req, Res, Supported, Added>, initializationBlock: Required<EnforcerOptions<Req, Res, Supported, Added>>): IFlow<Req, Res>;
     /**
      * Creates the post enforce flow for the enforcer. The post enforce flow is responsible for any logic that requires the origin response in the case of passed requests.
      * For example, enriching the context with response data (status, login successful information) and modifying the origin response (snippet injection, PXHD) are part of the post enforce flow.
@@ -79,7 +79,7 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @protected
      * @returns - The post enforce flow for the enforcer or null if post enforce is not enabled.
      */
-    protected createPostEnforceFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IFlow<Req, Res> | null;
+    protected createPostEnforceFlow(config: IConfiguration<Req, Res, Supported, Added>, initializationBlock: Required<EnforcerOptions<Req, Res, Supported, Added>>): IFlow<Req, Res> | null;
     /**
      * Creates the enforce flow for the enforcer. The enforce flow is responsible for the core functionality of HUMAN enforcement.
      * For example, parsing HUMAN cookies, performing Risk API, invoking the additional activity handler, and returning a block response are part of the enforce flow.
@@ -88,7 +88,7 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @protected
      * @returns - The enforce flow for the enforcer.
      */
-    protected createEnforceFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IFlow<Req, Res>;
+    protected createEnforceFlow(config: IConfiguration<Req, Res, Supported, Added>, initializationBlock: Required<EnforcerOptions<Req, Res, Supported, Added>>): IFlow<Req, Res>;
     /**
      * Creates the end enforce flow for the enforcer. The end enforce flow is responsible for all actions that must be done after every incoming request.
      * For example, sending the async activities, sending the telemetry activity, or updating the remote config, sending and clearing the enforcer logs, are parts of the end enforce flow.
@@ -97,7 +97,7 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @protected
      * @returns - The end enforce flow for the enforcer.
      */
-    protected createEndEnforcerFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IFlow<Req, Res>;
+    protected createEndEnforcerFlow(config: IConfiguration<Req, Res, Supported, Added>, initializationBlock: Required<EnforcerOptions<Req, Res, Supported, Added>>): IFlow<Req, Res>;
     /**
      * The central function that triggers enforcement on the incoming request.
      * @param args - The EnforceArgs required to enforce the incoming request.

package/lib/types/enforcer/EnforcerOptions.d.ts

@@ -11,7 +11,7 @@ import { IGraphQLParser } from '../graphql';
 import { ILogServiceClient } from '../logger';
 import { IRemoteConfigStorageClient, IRemoteConfigServiceClient, IRemoteConfigManager, IRemoteConfigUpdateParser } from '../config';
 import { ISnippetInjector, ISnippetRetriever } from '../snippet_injection';
-export type EnforcerOptions<Req, Res, Added, Removed> = {
+export type EnforcerOptions<Req, Res, Supported extends string, Added> = {
     httpClient: IHttpClient;
     base64Utils: IBase64Utils;
     hmacUtils: IHmacUtils;
@@ -30,8 +30,8 @@ export type EnforcerOptions<Req, Res, Added, Removed> = {
     logServiceClient?: ILogServiceClient<Req, Res> | null;
     remoteConfigManager?: IRemoteConfigManager<Req, Res> | null;
     remoteConfigUpdateParser?: IRemoteConfigUpdateParser<Req, Res> | null;
-    remoteConfigStorageClient?: IRemoteConfigStorageClient<Req, Res, Added, Removed> | null;
-    remoteConfigServiceClient?: IRemoteConfigServiceClient<Req, Res, Added, Removed> | null;
+    remoteConfigStorageClient?: IRemoteConfigStorageClient<Req, Res, Supported, Added> | null;
+    remoteConfigServiceClient?: IRemoteConfigServiceClient<Req, Res, Supported, Added> | null;
     snippetRetriever?: ISnippetRetriever<Req, Res> | null;
     snippetInjector?: ISnippetInjector<Res> | null;
 };

package/lib/types/enforcer/utils.d.ts

@@ -1,12 +1,12 @@
-import { IConfiguration, IRemoteConfigManager, IRemoteConfigServiceClient, IRemoteConfigStorageClient, IRemoteConfigUpdateParser } from '../config';
+import { IConfiguration, IRemoteConfigManager, IRemoteConfigServiceClient, IRemoteConfigStorageClient, IRemoteConfigUpdateParser, CoreConfigurationParamsKeys } from '../config';
 import { EnforcerOptions } from './EnforcerOptions';
 import { Products } from '../products';
 import { IBase64Utils, IHashUtils, IIpRangeChecker, IUrlUtils } from '../utils';
-export declare const createEnforcerInitializationBlock: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, options: EnforcerOptions<Req, Res, Added, Removed>) => Required<EnforcerOptions<Req, Res, Added, Removed>>;
-export declare const createEnforcerProducts: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, products: Products<Req, Res> | undefined, base64Utils: IBase64Utils, hashUtils: IHashUtils, urlUtils: IUrlUtils, ipRangeChecker: IIpRangeChecker) => Products<Req, Res>;
-export declare const createRemoteConfigClients: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, options: EnforcerOptions<Req, Res, Added, Removed>) => {
-    remoteConfigServiceClient: IRemoteConfigServiceClient<Req, Res, Added, Removed> | null;
+export declare const createEnforcerInitializationBlock: <Req, Res, Supported extends CoreConfigurationParamsKeys, Added>(config: IConfiguration<Req, Res, Supported, Added>, options: EnforcerOptions<Req, Res, Supported, Added>) => Required<EnforcerOptions<Req, Res, Supported, Added>>;
+export declare const createEnforcerProducts: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, products: Products<Req, Res> | undefined, base64Utils: IBase64Utils, hashUtils: IHashUtils, urlUtils: IUrlUtils, ipRangeChecker: IIpRangeChecker) => Products<Req, Res>;
+export declare const createRemoteConfigClients: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, options: EnforcerOptions<Req, Res, Supported, Added>) => {
+    remoteConfigServiceClient: IRemoteConfigServiceClient<Req, Res, Supported, Added> | null;
     remoteConfigManager: IRemoteConfigManager<Req, Res> | null;
     remoteConfigUpdateParser: IRemoteConfigUpdateParser<Req, Res> | null;
-    remoteConfigStorageClient: IRemoteConfigStorageClient<Req, Res, Added, Removed> | null;
+    remoteConfigStorageClient: IRemoteConfigStorageClient<Req, Res, Supported, Added> | null;
 };

package/lib/types/flow/EndEnforcerFlow.d.ts

@@ -2,7 +2,7 @@ import { IConfiguration } from '../config';
 import { EnforcerOptions } from '../enforcer';
 import { Flow } from './Flow';
 type RequiredEndEnforcerFlowOptions = 'activityClient' | 'logServiceClient' | 'telemetry' | 'remoteConfigManager';
-export declare class EndEnforcerFlow<Req, Res, Added, Removed> extends Flow<Req, Res> {
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, { logServiceClient, telemetry, remoteConfigManager, activityClient, }: Pick<Required<EnforcerOptions<Req, Res, Added, Removed>>, RequiredEndEnforcerFlowOptions>);
+export declare class EndEnforcerFlow<Req, Res, Supported extends string, Added> extends Flow<Req, Res> {
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, { logServiceClient, telemetry, remoteConfigManager, activityClient, }: Pick<Required<EnforcerOptions<Req, Res, Supported, Added>>, RequiredEndEnforcerFlowOptions>);
 }
 export {};

package/lib/types/flow/EnforceFlow.d.ts

@@ -2,7 +2,7 @@ import { IConfiguration } from '../config';
 import { EnforcerOptions } from '../enforcer';
 import { Flow } from './Flow';
 type RequiredEnforceFlowOptions = 'dataEnrichment' | 'tokenParser' | 'riskApiClient' | 'cors' | 'products' | 'graphQLParser';
-export declare class EnforceFlow<Req, Res, Added, Removed> extends Flow<Req, Res> {
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, { dataEnrichment, tokenParser, riskApiClient, cors, products, graphQLParser, }: Pick<Required<EnforcerOptions<Req, Res, Added, Removed>>, RequiredEnforceFlowOptions>);
+export declare class EnforceFlow<Req, Res, Supported extends string, Added> extends Flow<Req, Res> {
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, { dataEnrichment, tokenParser, riskApiClient, cors, products, graphQLParser, }: Pick<Required<EnforcerOptions<Req, Res, Supported, Added>>, RequiredEnforceFlowOptions>);
 }
 export {};

package/lib/types/flow/FilterFlow.d.ts

@@ -4,8 +4,8 @@ import { Products } from '../products';
 import { IFirstParty } from '../first_party';
 import { IFilter } from '../filter';
 import { Flow } from './Flow';
-export declare class FilterFlow<Req, Res, Added, Removed> extends Flow<Req, Res> {
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, { httpClient, products, cors, telemetry, remoteConfigUpdateParser, }: Required<EnforcerOptions<Req, Res, Added, Removed>>);
+export declare class FilterFlow<Req, Res, Supported extends string, Added> extends Flow<Req, Res> {
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, { httpClient, products, cors, telemetry, remoteConfigUpdateParser, }: Required<EnforcerOptions<Req, Res, Supported, Added>>);
     protected static getFirstPartyProducts<Req, Res>(products: Products<Req, Res>): IFirstParty<Req, Res>[];
     protected static getFilterProducts<Req, Res>(products: Products<Req, Res>): IFilter<Req, Res>[];
 }

package/lib/types/flow/PostEnforceFlow.d.ts

@@ -1,6 +1,6 @@
 import { IConfiguration } from '../config';
 import { EnforcerOptions } from '../enforcer';
 import { Flow } from './Flow';
-export declare class PostEnforceFlow<Req, Res, Added, Removed> extends Flow<Req, Res> {
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, { products, snippetRetriever, snippetInjector, }: Pick<Required<EnforcerOptions<Req, Res, Added, Removed>>, 'products' | 'snippetRetriever' | 'snippetInjector'>);
+export declare class PostEnforceFlow<Req, Res, Supported extends string, Added> extends Flow<Req, Res> {
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, { products, snippetRetriever, snippetInjector, }: Pick<Required<EnforcerOptions<Req, Res, Supported, Added>>, 'products' | 'snippetRetriever' | 'snippetInjector'>);
 }

package/lib/types/graphql/DefaultGraphQLParser.d.ts

@@ -4,11 +4,11 @@ import { IIncomingRequest } from '../http';
 import { IGraphQLParser } from './IGraphQLParser';
 import { GraphQLData, GraphQLOperation, GraphQLOperationType } from './model';
 import { ExtractGraphQLKeywordsFunction } from './ExtractGraphQLKeywordsFunction';
-export declare class DefaultGraphQLParser<Req, Res, Added, Removed> implements IGraphQLParser<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class DefaultGraphQLParser<Req, Res, Supported extends string, Added> implements IGraphQLParser<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly maxCharactersInGraphqlKeyword: number;
     protected readonly maxGraphqlKeywordCount: number;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>);
     isGraphQLRequest({ requestData }: ReadonlyContext<Req, Res>): boolean;
     parseGraphQLRequest(context: ReadonlyContext<Req, Res>): Promise<GraphQLData[] | null>;
     protected getGraphQLOperationsFromBody(request: IIncomingRequest<Req>, context: ReadonlyContext<Req, Res>): Promise<Array<GraphQLOperation> | null>;

package/lib/types/logger/HttpLogServiceClient.d.ts

@@ -3,10 +3,10 @@ import { ReadonlyContext } from '../context';
 import { IConfiguration } from '../config';
 import { IHttpClient } from '../http';
 import { ILogServiceClient } from './ILogServiceClient';
-export declare class HttpLogServiceClient<Req, Res, Added, Removed> implements ILogServiceClient<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class HttpLogServiceClient<Req, Res, Supported extends string, Added> implements ILogServiceClient<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly httpClient: IHttpClient;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, httpClient: IHttpClient);
     sendLogs(context: ReadonlyContext<Req, Res>): Promise<void>;
     protected getLogMetadata(context: ReadonlyContext<Req, Res>): LogMetadata;
     protected enrichLogRecord(log: LogRecord, logMetadata: LogMetadata): EnrichedLogRecord;

package/lib/types/monitored_request/MonitoredRequestUtils.d.ts

@@ -3,10 +3,10 @@ import { ReadonlyContext } from '../context';
 import { IIncomingRequest } from '../http';
 import { IUrl } from '../utils';
 export declare namespace MonitoredRequestUtils {
-    const isMonitoredRequest: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => Promise<boolean>;
+    const isMonitoredRequest: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, context: ReadonlyContext<Req, Res>) => Promise<boolean>;
     const isMonitoredRoute: (url: IUrl, isMonitoredRoute: Array<string | RegExp>) => boolean;
     const isEnforcedRoute: (url: IUrl, enforcedRoutes: Array<string | RegExp>) => boolean;
-    const invokeCustomIsEnforcedRequest: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => Promise<boolean>;
-    const invokeCustomIsMonitoredRequest: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => Promise<boolean>;
+    const invokeCustomIsEnforcedRequest: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, context: ReadonlyContext<Req, Res>) => Promise<boolean>;
+    const invokeCustomIsMonitoredRequest: <Req, Res, Supported extends string, Added>(config: IConfiguration<Req, Res, Supported, Added>, context: ReadonlyContext<Req, Res>) => Promise<boolean>;
     const isAllowedToBypassMonitor: <Req>(bypassMonitorHeader: string, request: IIncomingRequest<Req>) => boolean;
 }

package/lib/types/phase/impl/AdditionalActivityHandlerPhase.d.ts

@@ -5,8 +5,8 @@ import { PhaseResult } from '../PhaseResult';
 /**
  * The `AdditionalActivityHandlerPhase` invokes the additional activity handler defined in the configuration.
  */
-export declare class AdditionalActivityHandlerPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected config: IConfiguration<Req, Res, Added, Removed>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>);
+export declare class AdditionalActivityHandlerPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected config: IConfiguration<Req, Res, Supported, Added>;
+    constructor(config: IConfiguration<Req, Res, Supported, Added>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/CreateBlockResponsePhase.d.ts

@@ -10,11 +10,11 @@ import { PhaseResult } from '../PhaseResult';
  * `CreateBlockResponsePhase` is a phase that creates a block response for the product that recommended a block action.
  * If multiple products recommended block, it will return the block response for the highest priority product.
  */
-export declare class CreateBlockResponsePhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class CreateBlockResponsePhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly blockers: Partial<Record<ProductName, IConditionalBlocker<Req, Res>>>;
     protected readonly cors?: ICors<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, blockers: Partial<Record<ProductName, IConditionalBlocker<Req, Res>>>, cors?: ICors<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, blockers: Partial<Record<ProductName, IConditionalBlocker<Req, Res>>>, cors?: ICors<Req, Res>);
     /**
      * A static method that identifies those products that can block incoming requests and returns a map of the product name to the product instance.
      * @param products - All supported products.

package/lib/types/phase/impl/EnrichContextFromRequestPhase.d.ts

@@ -14,12 +14,12 @@ import { DecideActionPhase } from './DecideActionPhase';
  *
  * Note: This phase should come after the `ParseTokenPhase`, since the Bot Defender product uses the parsed token to determine its recommended action.
  */
-export declare class EnrichContextFromRequestPhase<Req, Res, Added, Removed> extends DecideActionPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class EnrichContextFromRequestPhase<Req, Res, Supported extends string, Added> extends DecideActionPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly products: Products<Req, Res>;
     protected readonly dataEnrichment: IDataEnrichment<Req, Res>;
     protected readonly graphQLParser: IGraphQLParser<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, products: Products<Req, Res>, dataEnrichment: IDataEnrichment<Req, Res>, graphQLParser: IGraphQLParser<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, products: Products<Req, Res>, dataEnrichment: IDataEnrichment<Req, Res>, graphQLParser: IGraphQLParser<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected addPxdeToContext(context: IContext<Req, Res>): Promise<void>;
     protected addGraphQLDataToContext(context: IContext<Req, Res>): Promise<void>;

package/lib/types/phase/impl/EnrichContextFromResponsePhase.d.ts

@@ -7,10 +7,10 @@ import { IConfiguration } from '../../config';
  * `EnrichContextFromResponsePhase` enriches the context with response data. Each product's `enrichContextFromResponse`
  * method is called since every product may use the response data differently.
  */
-export declare class EnrichContextFromResponsePhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class EnrichContextFromResponsePhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly products: Products<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, products: Products<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, products: Products<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected addProductDataToContext(context: IContext<Req, Res>): Promise<void>;
     protected addResponseCustomParametersToContext(context: IContext<Req, Res>): Promise<void>;

package/lib/types/phase/impl/FirstPartyPhase.d.ts

@@ -9,11 +9,11 @@ import { IConfiguration } from '../../config';
  * it will create the `FirstPartyData`, send the request to the configured endpoint using the provided HTTP client, and return
  * a done status with the response. If an error occurs, it will return the default response.
  */
-export declare class FirstPartyPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class FirstPartyPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly httpClient: IHttpClient;
     protected readonly firstParties: IFirstParty<Req, Res>[];
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient, firstParties: IFirstParty<Req, Res>[]);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, httpClient: IHttpClient, firstParties: IFirstParty<Req, Res>[]);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected sendFirstPartyRequest({ request, defaultResponse }: FirstPartyData, context: IContext<Req, Res>): Promise<IMinimalResponse>;
 }

package/lib/types/phase/impl/ModifyOutgoingResponsePhase.d.ts

@@ -9,12 +9,12 @@ import { ISnippetInjector, ISnippetRetriever } from '../../snippet_injection';
  * to the end user. This phase invokes each product's `modifyOutgoingResponse` method, as well as adding the PXHD cookie.
  * If snippet injection is supported and enabled, it also occurs in this phase.
  */
-export declare class ModifyOutgoingResponsePhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class ModifyOutgoingResponsePhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly products: IProduct<any, Req, Res>[];
     protected readonly snippetRetriever?: ISnippetRetriever<Req, Res> | null;
     protected readonly snippetInjector?: ISnippetInjector<Res> | null;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, products: IProduct<any, Req, Res>[], snippetRetriever?: ISnippetRetriever<Req, Res> | null, snippetInjector?: ISnippetInjector<Res> | null);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, products: IProduct<any, Req, Res>[], snippetRetriever?: ISnippetRetriever<Req, Res> | null, snippetInjector?: ISnippetInjector<Res> | null);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected handleSnippetInjection(context: IContext<Req, Res>): Promise<void>;
 }

package/lib/types/phase/impl/PreflightPhase.d.ts

@@ -7,10 +7,10 @@ import { IConfiguration } from '../../config';
  * The `PreflightPhase` class is responsible for handling preflight requests in CORS (Cross-Origin Resource Sharing).
  * This includes filtering preflight requests or invoking the preflight custom handler if configured.
  */
-export declare class PreflightPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+export declare class PreflightPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
     protected readonly corsSupportEnabled: boolean;
     protected readonly filterPreflightRequestsEnabled: boolean;
     protected readonly cors: ICors<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, cors: ICors<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, cors: ICors<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendAsyncActivitiesPhase.d.ts

@@ -6,9 +6,9 @@ import { IPhase } from '../IPhase';
 /**
  * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
  */
-export declare class SendAsyncActivitiesPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class SendAsyncActivitiesPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly activityClient: IActivityClient<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, activityClient: IActivityClient<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, activityClient: IActivityClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendLogsPhase.d.ts

@@ -6,9 +6,9 @@ import { ILogServiceClient } from '../../logger';
 /**
  * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
  */
-export declare class SendLogsPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
+export declare class SendLogsPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
     private readonly config;
     private readonly logServiceClient;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, logServiceClient: ILogServiceClient<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, logServiceClient: ILogServiceClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/phase/impl/SendTelemetryActivityPhase.d.ts

@@ -6,10 +6,10 @@ import { IConfiguration } from '../../config';
 /**
  * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
  */
-export declare class SendTelemetryActivityPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class SendTelemetryActivityPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly telemetry: ITelemetry<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, telemetry: ITelemetry<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, telemetry: ITelemetry<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected sendTelemetry(context: IContext<Req, Res>): Promise<void>;
 }

package/lib/types/phase/impl/UpdateRemoteConfigPhase.d.ts

@@ -5,9 +5,9 @@ import { PhaseResult } from '../PhaseResult';
 /**
  * The `UpdateRemoteConfigPhase` class is responsible for updating the remote configuration if necessary.
  */
-export declare class UpdateRemoteConfigPhase<Req, Res, Added, Removed> implements IPhase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class UpdateRemoteConfigPhase<Req, Res, Supported extends string, Added> implements IPhase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly remoteConfigManager: IRemoteConfigManager<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, remoteConfigManager: IRemoteConfigManager<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, remoteConfigManager: IRemoteConfigManager<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

package/lib/types/products/account_defender/AccountDefender.d.ts

@@ -7,10 +7,10 @@ import { JwtData } from './JwtData';
 export type AccountDefenderOptions = {
     base64Utils: IBase64Utils;
 };
-export declare class AccountDefender<Req, Res, Added, Removed> implements IAccountDefender<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class AccountDefender<Req, Res, Supported extends string, Added> implements IAccountDefender<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly base64Utils: IBase64Utils;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, options: AccountDefenderOptions);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, options: AccountDefenderOptions);
     enrichContextFromRequest(context: ReadonlyContext<Req, Res>): Promise<AccountDefenderData>;
     enrichContextFromRiskApi(_context: ReadonlyContext<Req, Res>): Promise<AccountDefenderData | null>;
     enrichContextFromResponse(_context: ReadonlyContext<Req, Res>): Promise<AccountDefenderData | null>;

package/lib/types/products/bot_defender/BotDefender.d.ts

@@ -28,12 +28,12 @@ export type BotDefenderOptions<Req, Res> = {
     firstParty: IFirstParty<Req, Res>;
     urlUtils?: never;
 });
-export declare class BotDefender<Req, Res, Added, Removed> implements IBotDefender<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class BotDefender<Req, Res, Supported extends string, Added> implements IBotDefender<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly firstParty: IFirstParty<Req, Res>;
     protected readonly filter: IFilter<Req, Res>;
     protected readonly blocker: IConditionalBlocker<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, options: BotDefenderOptions<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, options: BotDefenderOptions<Req, Res>);
     handleFirstPartyRequest(context: ReadonlyContext<Req, Res>): Promise<FirstPartyData | null>;
     shouldFilter(context: ReadonlyContext<Req, Res>): Promise<boolean>;
     enrichContextFromRequest(context: ReadonlyContext<Req, Res>): Promise<BotDefenderData>;

package/lib/types/products/bot_defender/block/DefaultBotDefenderBlocker.d.ts

@@ -8,10 +8,10 @@ export type DefaultBotDefenderBlockerConstructorOptions<Req, Res> = {
 } | {
     captchaBlocker: IBlocker<Req, Res>;
 };
-export declare class DefaultBotDefenderBlocker<Req, Res, Added, Removed> implements IConditionalBlocker<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class DefaultBotDefenderBlocker<Req, Res, Supported extends string, Added> implements IConditionalBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly captchaBlocker: IBlocker<Req, Res>;
-    constructor(config: IConfiguration<Req, Res, Added, Removed>, options: DefaultBotDefenderBlockerConstructorOptions<Req, Res>);
+    constructor(config: IConfiguration<Req, Res, Supported, Added>, options: DefaultBotDefenderBlockerConstructorOptions<Req, Res>);
     shouldBlock({ action, reasons }: ReadonlyContext<Req, Res>): boolean;
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
     protected createRateLimitResponse(): IMinimalResponse;

package/lib/types/products/bot_defender/block/captcha/CaptchaBlocker.d.ts

@@ -5,24 +5,24 @@ import { IMinimalResponse } from '../../../../http';
 import { JsonCaptchaBlockerConstructorOptions } from './JsonCaptchaBlocker';
 import { MobileCaptchaBlockerConstructorOptions } from './MobileCaptchaBlocker';
 import { HtmlCaptchaBlockerConstructorOptions } from './HtmlCaptchaBlocker';
-type JsonBlockerOptions<Req, Res, Added, Removed> = {
+type JsonBlockerOptions<Req, Res, Supported extends string, Added> = {
     jsonCaptchaBlocker: IConditionalBlocker<Req, Res>;
-} | JsonCaptchaBlockerConstructorOptions<Req, Res, Added, Removed>;
-type MobileCaptchaBlockerOptions<Req, Res, Added, Removed> = {
+} | JsonCaptchaBlockerConstructorOptions<Req, Res, Supported, Added>;
+type MobileCaptchaBlockerOptions<Req, Res, Supported extends string, Added> = {
     mobileCaptchaBlocker: IConditionalBlocker<Req, Res>;
-} | MobileCaptchaBlockerConstructorOptions<Req, Res, Added, Removed>;
-type HtmlCaptchaBlockerOptions<Req, Res, Added, Removed> = {
+} | MobileCaptchaBlockerConstructorOptions<Req, Res, Supported, Added>;
+type HtmlCaptchaBlockerOptions<Req, Res, Supported extends string, Added> = {
     htmlCaptchaBlocker: IBlocker<Req, Res>;
-} | HtmlCaptchaBlockerConstructorOptions<Req, Res, Added, Removed>;
-export type CaptchaBlockerConstructorOptions<Req, Res, Added, Removed> = {
-    config: IConfiguration<Req, Res, Added, Removed>;
-} & JsonBlockerOptions<Req, Res, Added, Removed> & MobileCaptchaBlockerOptions<Req, Res, Added, Removed> & HtmlCaptchaBlockerOptions<Req, Res, Added, Removed>;
-export declare class CaptchaBlocker<Req, Res, Added, Removed> implements IBlocker<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+} | HtmlCaptchaBlockerConstructorOptions<Req, Res, Supported, Added>;
+export type CaptchaBlockerConstructorOptions<Req, Res, Supported extends string, Added> = {
+    config: IConfiguration<Req, Res, Supported, Added>;
+} & JsonBlockerOptions<Req, Res, Supported, Added> & MobileCaptchaBlockerOptions<Req, Res, Supported, Added> & HtmlCaptchaBlockerOptions<Req, Res, Supported, Added>;
+export declare class CaptchaBlocker<Req, Res, Supported extends string, Added> implements IBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly jsonCaptchaBlocker: IConditionalBlocker<Req, Res>;
     protected readonly mobileCaptchaBlocker: IConditionalBlocker<Req, Res>;
     protected readonly htmlCaptchaBlocker: IBlocker<Req, Res>;
-    constructor(options: CaptchaBlockerConstructorOptions<Req, Res, Added, Removed>);
+    constructor(options: CaptchaBlockerConstructorOptions<Req, Res, Supported, Added>);
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
 }
 export {};

package/lib/types/products/bot_defender/block/captcha/HtmlCaptchaBlocker.d.ts

@@ -2,15 +2,15 @@ import { IConfiguration } from '../../../../config';
 import { ReadonlyContext } from '../../../../context';
 import { IBase64Utils } from '../../../../utils';
 import { BlockerBase } from '../../../../blocker';
-export type HtmlCaptchaBlockerConstructorOptions<Req, Res, Added, Removed> = {
-    config: IConfiguration<Req, Res, Added, Removed>;
+export type HtmlCaptchaBlockerConstructorOptions<Req, Res, Supported extends string, Added> = {
+    config: IConfiguration<Req, Res, Supported, Added>;
     base64Utils: IBase64Utils;
     captchaTemplate?: string;
 };
-export declare class HtmlCaptchaBlocker<Req, Res, Added, Removed> extends BlockerBase<Req, Res> {
-    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+export declare class HtmlCaptchaBlocker<Req, Res, Supported extends string, Added> extends BlockerBase<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Supported, Added>;
     protected readonly base64Utils: IBase64Utils;
     protected readonly captchaTemplate: string;
-    constructor(options: HtmlCaptchaBlockerConstructorOptions<Req, Res, Added, Removed>);
+    constructor(options: HtmlCaptchaBlockerConstructorOptions<Req, Res, Supported, Added>);
     protected createBlockBody(context: ReadonlyContext<Req, Res>): string;
 }