perimeterx-js-core 0.25.0 → 0.26.0

package/lib/types/{phase/flow → flow}/FilterFlow.d.ts

@@ -1,10 +1,10 @@
-import { IConfiguration } from '../../config';
-import { EnforcerOptions } from '../../enforcer';
-import { Products } from '../../products';
-import { IFirstParty } from '../../first_party';
-import { IFilter } from '../../filter';
-import { CompositePhase } from '../impl';
-export declare class FilterFlow<Req, Res, Added, Removed> extends CompositePhase<Req, Res> {
+import { IConfiguration } from '../config';
+import { EnforcerOptions } from '../enforcer';
+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>>);
     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/Flow.d.ts

@@ -0,0 +1,13 @@
+import { IContext } from '../context';
+import { IPhase, PhaseResult } from '../phase';
+import { IFlow, InsertPhaseOptions } from './IFlow';
+export declare class Flow<Req, Res> implements IFlow<Req, Res> {
+    readonly phases: IPhase<Req, Res>[];
+    constructor(phases: IPhase<Req, Res>[]);
+    insert(phase: IPhase<Req, Res>, options?: InsertPhaseOptions): void;
+    remove(name: string): void;
+    replace(name: string, phase: IPhase<Req, Res>): void;
+    move(name: string, to: InsertPhaseOptions): void;
+    protected getIndexOfPhase(name: string): number;
+    execute(context: IContext<Req, Res>): Promise<PhaseResult>;
+}

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

@@ -0,0 +1,57 @@
+import { IPhase } from '../phase';
+export type InsertPhaseOptions = {
+    /**
+     * The name of the phase before which the new phase will be inserted. For example, if
+     * this value is set to Phase1, the phase that is inserted into the flow will be
+     * inserted immediately preceding Phase1.
+     */
+    before?: string;
+    /**
+     * The name of the phase after which the new phase will be inserted. For example, if
+     * this value is set to Phase1, the phase that is inserted into the flow will be
+     * inserted immediately following Phase1.
+     */
+    after?: never;
+} | {
+    /**
+     * The name of the phase before which the new phase will be inserted. For example, if
+     * this value is set to Phase1, the phase that is inserted into the flow will be
+     * inserted immediately preceding Phase1.
+     */
+    before?: never;
+    /**
+     * The name of the phase after which the new phase will be inserted. For example, if
+     * this value is set to Phase1, the phase that is inserted into the flow will be
+     * inserted immediately following Phase1.
+     */
+    after?: string;
+};
+/**
+ * The IFlow interface represents a flow of phases that can be executed in a specific order.
+ */
+export interface IFlow<Req, Res> extends IPhase<Req, Res> {
+    /**
+     * Replaces the named phase in the flow with the provided phase. If the named phase is not found, nothing happens.
+     * @param name - The name of the phase to replace. A phase with this name should exist in the flow already.
+     * @param phase - The phase that should replace the named phase.
+     */
+    replace(name: string, phase: IPhase<Req, Res>): void;
+    /**
+     * Removes the named phase from the flow. If the named phase is not found, does nothing.
+     * @param name - The name of the phase to remove. A phase with this name should exist in the flow already.
+     */
+    remove(name: string): void;
+    /**
+     * Inserts the provided phase into the flow at the specified position. If no position is specified,
+     * the phase will be added to the very end of the flow.
+     * @param phase - The phase to insert into the flow.
+     * @param options - The options for inserting the phase. If no options are provided, the phase will be added to the end of the flow.
+     */
+    insert(phase: IPhase<Req, Res>, options?: InsertPhaseOptions): void;
+    /**
+     * Moves the named phase to the specified position in the flow. If the named phase is not found, nothing happens.
+     * @param name - The name of the phase to move. A phase with this name should exist in the flow already.
+     * @param to - The options for moving the phase. The phase will be moved to the specified position in the flow.
+     */
+    move(name: string, to: InsertPhaseOptions): void;
+}

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

@@ -0,0 +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'>);
+}

package/lib/types/{phase/flow → flow}/index.d.ts

@@ -2,3 +2,5 @@ export * from './FilterFlow';
 export * from './EnforceFlow';
 export * from './PostEnforceFlow';
 export * from './EndEnforcerFlow';
+export * from './IFlow';
+export * from './Flow';

package/lib/types/index.d.ts

@@ -9,6 +9,7 @@ export * from './sensitive_request';
 export * from './monitored_request';
 export * from './snippet_injection';
 export * from './cors';
+export * from './flow';
 export * from './enforcer';
 export * from './filter';
 export * from './first_party';

package/lib/types/phase/IPhase.d.ts

@@ -1,6 +1,15 @@
 import { AsyncOrSync } from 'ts-essentials';
 import { IContext } from '../context';
 import { PhaseResult } from './PhaseResult';
+/**
+ * A self-contained unit of logic that can be invoked as part of the overall enforcer logic.
+ */
 export interface IPhase<Req, Res> {
+    /**
+     * Executes the logic of the phase with the provided context.
+     * @param context - The context that contains all the necessary information about the incoming request and HUMAN-related metadata.
+     * The context is mutable, meaning that phases may change the context as they see fit.
+     * @returns AsyncOrSync<PhaseResult> - The result of the phase execution.
+     */
     execute(context: IContext<Req, Res>): AsyncOrSync<PhaseResult>;
 }

package/lib/types/phase/PhaseResult.d.ts

@@ -1,5 +1,16 @@
 import { IMinimalResponse } from '../http';
+/**
+ * The result of a phase execution in the flow, indicating whether to continue to the next phase or to stop the flow,
+ * and optionally providing an HTTP response to return.
+ */
 export type PhaseResult = {
+    /**
+     * Whether the flow should exit immediately after this phase. If true, no further phases should be executed
+     * within the flow. If false, the next phase should be executed.
+     */
     done: boolean;
+    /**
+     * An interface representing the HTTP response to return from the enforcer, if any.
+     */
     response?: IMinimalResponse;
 };

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

@@ -2,6 +2,9 @@ import { IPhase } from '../IPhase';
 import { IConfiguration } from '../../config';
 import { IContext } from '../../context';
 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>);

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

@@ -1,6 +1,9 @@
 import { IContext } from '../../context';
 import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
+/**
+ * The `ClearLogsPhase` class deletes the context logs to free up memory.
+ */
 export declare class ClearLogsPhase<Req, Res> implements IPhase<Req, Res> {
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

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

@@ -1,8 +1,17 @@
 import { IPhase } from '../IPhase';
 import { IContext } from '../../context';
 import { PhaseResult } from '../PhaseResult';
+/**
+ * The `CompositePhase` class executes a series of phases in sequence.
+ * It will stop executing phases as soon as one of them returns a result with `done: true`.
+ * It will return the result of the last phase executed or `{ done: false }`.
+ */
 export declare class CompositePhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly phases: IPhase<Req, Res>[];
+    /**
+     * Creates a new CompositePhase instance.
+     * @param phases - An array of phases to be executed in sequence.
+     */
     constructor(phases: IPhase<Req, Res>[]);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
 }

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

@@ -3,14 +3,24 @@ import { IContext, ReadonlyContext } from '../../context';
 import { IMinimalResponse } from '../../http';
 import { IConditionalBlocker } from '../../blocker';
 import { ICors } from '../../cors';
-import { ProductName } from '../../products';
+import { ProductName, Products } from '../../products';
 import { IPhase } from '../IPhase';
 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>;
     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>);
+    /**
+     * 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.
+     * @returns A mapping of those products that implement the `IConditionalBlocker` interface.
+     */
+    static getBlockers<Req, Res>(products: Products<Req, Res>): Partial<Record<ProductName, IConditionalBlocker<Req, Res>>>;
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;
     protected createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse | null;
     protected addHeadersToResponse(response: IMinimalResponse, context: ReadonlyContext<Req, Res>): Promise<IMinimalResponse>;

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

@@ -1,8 +1,19 @@
 import { IContext } from '../../context';
 import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
+/**
+ * `DecideActionPhase` is an abstract class that provides the protected function `updateContextDecision`.
+ * Phases that extend this class can use the `updateContextDecision` method to update the `context.action` and
+ * `context.reasons` properties based on the product data in the context. Calling this function essentially
+ * recalculates what action the enforcer should take and why.
+ */
 export declare abstract class DecideActionPhase<Req, Res> implements IPhase<Req, Res> {
     abstract execute(context: IContext<Req, Res>): Promise<PhaseResult>;
+    /**
+     * Updates the `action`, `reasons`, and `blockAction` properties based on the product data in the context.
+     * @param context - The request context.
+     * @protected
+     */
     protected updateContextDecision(context: IContext<Req, Res>): Promise<void>;
     protected modifyBlockActionIfNeeded(context: IContext<Req, Res>): void;
 }

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

@@ -5,6 +5,15 @@ import { PhaseResult } from '../PhaseResult';
 import { IDataEnrichment } from '../../pxde';
 import { IGraphQLParser } from '../../graphql';
 import { DecideActionPhase } from './DecideActionPhase';
+/**
+ * `EnrichContextFromRequestPhase` adds data to the context from the request. This includes parsing the data enrichment cookie,
+ * adding GraphQL data, custom parameters, and enriching the context with any product-specific data by calling each product's
+ * `enrichContextFromRequest` method. (As an example, this is where the Credential Intelligence product enriches the context by
+ * extracting login credentials and adding them to the product data of the request.) It then updates the context's final action
+ * and reasons based on the enriched data.
+ *
+ * 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>;
     protected readonly products: Products<Req, Res>;

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

@@ -3,6 +3,10 @@ import { Products } from '../../products';
 import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 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>;
     protected readonly products: Products<Req, Res>;

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

@@ -2,6 +2,10 @@ import { IContext } from '../../context';
 import { IFilter } from '../../filter';
 import { PhaseResult } from '../PhaseResult';
 import { IPhase } from '../IPhase';
+/**
+ * The `FilterPhase` class checks if the provided filters indicate that the incoming HTTP request should be filtered from the flow.
+ * If any filter returns `true` for `shouldFilter`, the phase will stop further processing and return a `done` status.
+ */
 export declare class FilterPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly filters: IFilter<Req, Res>[];
     constructor(filters: IFilter<Req, Res>[]);

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

@@ -4,6 +4,11 @@ import { IHttpClient, IMinimalResponse } from '../../http';
 import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IConfiguration } from '../../config';
+/**
+ * The `FirstPartyPhase` class is responsible for handling first-party requests. If a first-party request is detected,
+ * 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>;
     protected readonly httpClient: IHttpClient;

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

@@ -2,6 +2,11 @@ import { IContext } from '../../context';
 import { PhaseResult } from '../PhaseResult';
 import { IPhase } from '../IPhase';
 import { IRemoteConfigUpdateParser } from '../../config';
+/**
+ * The `IdentifyRemoteConfigNotifyRequestPhase` class is responsible for identifying incoming remote config update requests.
+ * It checks if the request is a remote config update request and, if so, parses the request and updates the context accordingly.
+ * Note that the remote config is not updated during this phase; that occurs in the `UpdateRemoteConfigPhase`.
+ */
 export declare class IdentifyRemoteConfigNotifyRequestPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly remoteConfigUpdateParser: IRemoteConfigUpdateParser<Req, Res>;
     constructor(remoteConfigUpdateParser: IRemoteConfigUpdateParser<Req, Res>);

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

@@ -2,6 +2,11 @@ import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IContext } from '../../context';
 import { ITelemetry } from '../../telemetry';
+/**
+ * The `IdentifyTelemetryRequestPhase` class is responsible for identifying incoming telemetry requests.
+ * It checks if the request is a telemetry request and, if so, parses the request and updates the context accordingly.
+ * Note that the telemetry activity is not sent during this phase; that occurs in the `SendTelemetryActivityPhase`.
+ */
 export declare class IdentifyTelemetryRequestPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly telemetry: ITelemetry<Req, Res>;
     constructor(telemetry: ITelemetry<Req, Res>);

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

@@ -2,6 +2,11 @@ import { IContext } from '../../context';
 import { IProduct } from '../../products';
 import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
+/**
+ * The `ModifyIncomingRequestPhase` class is responsible for modifying the incoming HTTP request prior to forwarding the
+ * request to the origin server or cache. This phase invokes each product's `modifyIncomingRequest` method. (As an example,
+ * this is where the Credential Intelligence product adds the compromised credentials header to the request if needed.)
+ */
 export declare class ModifyIncomingRequestPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly products: IProduct<any, Req, Res>[];
     constructor(products: IProduct<any, Req, Res>[]);

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

@@ -4,6 +4,11 @@ import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IConfiguration } from '../../config';
 import { ISnippetInjector, ISnippetRetriever } from '../../snippet_injection';
+/**
+ * The `ModifyOutgoingResponsePhase` class is responsible for modifying the outgoing HTTP response prior to returning it
+ * 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>;
     protected readonly products: IProduct<any, Req, Res>[];

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

@@ -2,6 +2,9 @@ import { IPhase } from '../IPhase';
 import { ITokenParser } from '../../risk_token';
 import { PhaseResult } from '../PhaseResult';
 import { IContext, TokenData } from '../../context';
+/**
+ * The `ParseTokenPhase` class is responsible for parsing the risk token from the incoming request and updating the context.
+ */
 export declare class ParseTokenPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly tokenParser: ITokenParser<Req, Res>;
     constructor(tokenParser: ITokenParser<Req, Res>);

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

@@ -3,6 +3,10 @@ import { IContext } from '../../context';
 import { PhaseResult } from '../PhaseResult';
 import { ICors } from '../../cors';
 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> {
     protected readonly corsSupportEnabled: boolean;
     protected readonly filterPreflightRequestsEnabled: boolean;

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

@@ -3,6 +3,11 @@ import { IRiskApiClient } from '../../risk_api';
 import { Products } from '../../products';
 import { PhaseResult } from '../PhaseResult';
 import { DecideActionPhase } from './DecideActionPhase';
+/**
+ * The `RiskApiPhase` class is responsible for making the synchronous Risk API request when necessary. If a Risk API call
+ * is made, it will also update the context with the Risk API response, product data (invoking each product's
+ * `enrichContextFromRiskApi` method), and update the context decision.
+ */
 export declare class RiskApiPhase<Req, Res> extends DecideActionPhase<Req, Res> {
     protected readonly products: Products<Req, Res>;
     protected readonly riskApiClient: IRiskApiClient<Req, Res>;

package/lib/types/phase/impl/{SendAsyncActivitiesOnResponsePhase.d.ts → SendAsyncActivitiesPhase.d.ts}

@@ -1,8 +1,11 @@
 import { IContext } from '../../context';
 import { IActivityClient } from '../../activities';
-import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
-export declare class SendAsyncActivitiesOnResponsePhase<Req, Res> implements IPhase<Req, Res> {
+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> implements IPhase<Req, Res> {
     protected readonly activityClient: IActivityClient<Req, Res>;
     constructor(activityClient: IActivityClient<Req, Res>);
     execute(context: IContext<Req, Res>): Promise<PhaseResult>;

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

@@ -3,6 +3,9 @@ import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IConfiguration } from '../../config';
 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> {
     private readonly logServiceClient;
     constructor(_config: IConfiguration<Req, Res, Added, Removed>, logServiceClient: ILogServiceClient<Req, Res>);

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

@@ -2,6 +2,9 @@ import { IPhase } from '../IPhase';
 import { PhaseResult } from '../PhaseResult';
 import { IContext } from '../../context';
 import { ITelemetry } from '../../telemetry';
+/**
+ * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
+ */
 export declare class SendTelemetryActivityPhase<Req, Res> implements IPhase<Req, Res> {
     protected readonly telemetry: ITelemetry<Req, Res>;
     constructor(telemetry: ITelemetry<Req, Res>);

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

@@ -2,6 +2,9 @@ import { IConfiguration, IRemoteConfigManager } from '../../config';
 import { IContext } from '../../context';
 import { IPhase } from '../IPhase';
 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>;
     protected readonly remoteConfigManager: IRemoteConfigManager<Req, Res>;

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

@@ -9,8 +9,7 @@ export * from './CreateBlockResponsePhase';
 export * from './ModifyIncomingRequestPhase';
 export * from './EnrichContextFromResponsePhase';
 export * from './ModifyOutgoingResponsePhase';
-export * from './SendAsyncActivitiesOnRequestPhase';
-export * from './SendAsyncActivitiesOnResponsePhase';
+export * from './SendAsyncActivitiesPhase';
 export * from './AdditionalActivityHandlerPhase';
 export * from './CompositePhase';
 export * from './SendLogsPhase';

package/lib/types/phase/index.d.ts

@@ -1,4 +1,3 @@
 export * from './IPhase';
 export * from './PhaseResult';
 export * from './impl';
-export * from './flow';

package/lib/types/products/credential_intelligence/endpoint/CredentialEndpointConfiguration.d.ts

@@ -43,7 +43,7 @@ export type CredentialEndpointConfiguration<Req, Res> = {
     /**
      * The method by which the module will determine whether the login request was successful.
      */
-    login_successful_reporting_method?: 'status' | 'header' | 'body' | 'custom' | LoginSuccessfulReportingMethod;
+    login_successful_reporting_method?: `${LoginSuccessfulReportingMethod}`;
     /**
      * An array of HTTP statuses signifying a successful login. All other status codes
      * will be treated as unsuccessful login attempts.

package/lib/types/products/credential_intelligence/endpoint/login_successful/BodyLoginSuccessfulParser.d.ts

@@ -2,6 +2,6 @@ import { IOutgoingResponse } from '../../../../http';
 import { ILoginSuccessfulParser } from './ILoginSuccessfulParser';
 export declare class BodyLoginSuccessfulParser<Res> implements ILoginSuccessfulParser<Res> {
     protected readonly bodyRegex: RegExp;
-    constructor(regex: RegExp | string);
+    constructor(regex: RegExp);
     isLoginSuccessful(response: IOutgoingResponse<Res>): Promise<boolean>;
 }

package/lib/types/products/interfaces/IProduct.d.ts

@@ -2,10 +2,38 @@ import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../../context';
 import { ProductName } from '../utils';
 import { ProductDataType } from './ProductDataType';
+/**
+ * A product interface that allows for enriching the request context and modifying the HTTP request and response.
+ */
 export interface IProduct<Name extends ProductName, Req, Res> {
+    /**
+     * Enriches the context with product-specific data from the incoming request prior to performing a Risk API request.
+     * @param context - The request context.
+     * @returns {AsyncOrSync<ProductDataType<Name> | null>} - The relevant product data or null if no data is available.
+     */
     enrichContextFromRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<ProductDataType<Name> | null>;
+    /**
+     * Enriches the context with product-specific data from the Risk API response.
+     * @param context - The request context.
+     * @returns {AsyncOrSync<Partial<ProductDataType<Name>> | null>} - The relevant product data or null if no data is available.
+     */
     enrichContextFromRiskApi(context: ReadonlyContext<Req, Res>): AsyncOrSync<Partial<ProductDataType<Name>> | null>;
+    /**
+     * Modifies the incoming HTTP request as needed for the product.
+     * @param context - The request context.
+     * @returns {AsyncOrSync<void>} - A promise that resolves when the modification is complete.
+     */
     modifyIncomingRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<void>;
+    /**
+     * Enriches the context with product-specific data from the HTTP response.
+     * @param context - The request context.
+     * @returns {AsyncOrSync<Partial<ProductDataType<Name>> | null>} - The relevant product data or null if no data is available.
+     */
     enrichContextFromResponse(context: ReadonlyContext<Req, Res>): AsyncOrSync<Partial<ProductDataType<Name>> | null>;
+    /**
+     * Modifies the outgoing HTTP response as needed for the product.
+     * @param context - The request context.
+     * @returns {AsyncOrSync<void>} - A promise that resolves when the modification is complete.
+     */
     modifyOutgoingResponse(context: ReadonlyContext<Req, Res>): AsyncOrSync<void>;
 }

package/lib/types/products/interfaces/ProductDataType.d.ts

@@ -2,5 +2,5 @@ import { ProductName } from '../utils';
 import { BotDefenderData } from '../bot_defender';
 import { CredentialIntelligenceData } from '../credential_intelligence';
 import { AccountDefenderData } from '../account_defender';
-import { HypeSaleChallengeData } from '../hype_sale_challenge/model/HypeSaleChallengeData';
+import { HypeSaleChallengeData } from '../hype_sale_challenge';
 export type ProductDataType<Name extends ProductName> = Name extends ProductName.BOT_DEFENDER ? BotDefenderData : Name extends ProductName.CREDENTIAL_INTELLIGENCE ? CredentialIntelligenceData : Name extends ProductName.ACCOUNT_DEFENDER ? AccountDefenderData : Name extends ProductName.HYPE_SALE_CHALLENGE ? HypeSaleChallengeData : never;

package/lib/types/risk_api/client/GetRiskApiClientV2.d.ts

@@ -0,0 +1,15 @@
+import { RiskApiClientBase } from './abstract';
+import { IConfiguration } from '../../config';
+import { IHttpClient, IIncomingResponse, OutgoingRequestImpl, ReadonlyHeaders } from '../../http';
+import { ReadonlyContext } from '../../context';
+import { IRiskResponse } from '../risk_response';
+import { RiskActivity } from '../model';
+export declare class GetRiskApiClientV2<Req, Res, Added, Removed> extends RiskApiClientBase<Req, Res, Added, Removed> {
+    constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient);
+    protected createRiskRequest(context: ReadonlyContext<Req, Res>): OutgoingRequestImpl;
+    protected getRiskActivityHeaders(context: ReadonlyContext<Req, Res>): ReadonlyHeaders;
+    protected getRequestHeadersForRisk(context: ReadonlyContext<Req, Res>): Record<string, string[]>;
+    protected riskActivityToHeaders(riskActivity: RiskActivity): Record<string, string[]>;
+    private addHeadersFromObject;
+    protected createRiskResponse(response: IIncomingResponse): IRiskResponse;
+}

package/lib/types/risk_api/client/PostRiskApiClientV2.d.ts

@@ -1,7 +1,7 @@
 import { IConfiguration } from '../../config';
 import { IHttpClient, IIncomingResponse } from '../../http';
 import { IRiskResponse } from '../risk_response';
-import { PostRiskApiClientBase } from './PostRiskApiClientBase';
+import { PostRiskApiClientBase } from './abstract';
 export declare class PostRiskApiClientV2<Req, Res, Added, Removed> extends PostRiskApiClientBase<Req, Res, Added, Removed> {
     constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient);
     protected createRiskResponse(response: IIncomingResponse): IRiskResponse;

package/lib/types/risk_api/client/PostRiskApiClientV3.d.ts

@@ -1,7 +1,7 @@
-import { PostRiskApiClientBase } from './PostRiskApiClientBase';
+import { IConfiguration } from '../../config';
 import { IHttpClient, IIncomingResponse } from '../../http';
 import { IRiskResponse } from '../risk_response';
-import { IConfiguration } from '../../config';
+import { PostRiskApiClientBase } from './abstract';
 export declare class PostRiskApiClientV3<Req, Res, Added, Removed> extends PostRiskApiClientBase<Req, Res, Added, Removed> {
     constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient);
     protected createRiskResponse(response: IIncomingResponse): IRiskResponse;

package/lib/types/risk_api/client/{IRiskApiClient.d.ts → abstract/IRiskApiClient.d.ts}

@@ -1,5 +1,5 @@
 import { AsyncOrSync } from 'ts-essentials';
-import { ReadonlyContext, RiskApiData } from '../../context';
+import { ReadonlyContext, RiskApiData } from '../../../context';
 export interface IRiskApiClient<Req, Res> {
     executeRiskApi(context: ReadonlyContext<Req, Res>): AsyncOrSync<RiskApiData>;
 }

package/lib/types/risk_api/client/abstract/PostRiskApiClientBase.d.ts

@@ -0,0 +1,8 @@
+import { RiskApiClientBase } from './RiskApiClientBase';
+import { OutgoingRequestImpl } from '../../../http';
+import { ReadonlyContext } from '../../../context';
+import { ReadonlyHeaders } from '../../../http';
+export declare abstract class PostRiskApiClientBase<Req, Res, Added, Removed> extends RiskApiClientBase<Req, Res, Added, Removed> {
+    protected createRiskRequest(context: ReadonlyContext<Req, Res>): OutgoingRequestImpl;
+    protected getRiskHeaders(): ReadonlyHeaders;
+}

package/lib/types/risk_api/client/abstract/RiskApiClientBase.d.ts

@@ -0,0 +1,26 @@
+import { ReadonlyContext, RiskApiData } from '../../../context';
+import { IConfiguration } from '../../../config';
+import { IHttpClient, IIncomingResponse, OutgoingRequestImpl, ReadonlyHeaders } from '../../../http';
+import { HeaderEntry } from '../../../activities';
+import { IRiskResponse } from '../../risk_response';
+import { IRiskApiClient } from './IRiskApiClient';
+export declare abstract class RiskApiClientBase<Req, Res, Added, Removed> implements IRiskApiClient<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res, Added, Removed>;
+    protected readonly httpClient: IHttpClient;
+    protected constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient);
+    protected abstract createRiskRequest(context: ReadonlyContext<Req, Res>): OutgoingRequestImpl;
+    protected abstract createRiskResponse(response: IIncomingResponse): IRiskResponse;
+    /**
+     * Builds the Risk API activity, sends the request, and returns RiskApiData with the response.
+     * @param context
+     * @returns Promise<RiskApiData>
+     */
+    executeRiskApi(context: ReadonlyContext<Req, Res>): Promise<RiskApiData>;
+    protected formatRiskHeadersField(headers: ReadonlyHeaders): HeaderEntry[];
+    protected sendRiskActivity(riskRequest: OutgoingRequestImpl, riskApiData: RiskApiData, context: ReadonlyContext<Req, Res>): Promise<IIncomingResponse>;
+    protected getRiskUrl(): string;
+    protected getRiskHeaders(): ReadonlyHeaders;
+    protected handleS2STimeout(riskApiData: RiskApiData): RiskApiData;
+    protected handleS2SError(riskApiData: RiskApiData, context: ReadonlyContext<Req, Res>, response?: IIncomingResponse, error?: unknown): Promise<RiskApiData>;
+}
+export declare const isEnforcerTimeoutError: (err: unknown) => boolean;

package/lib/types/risk_api/client/abstract/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PostRiskApiClientBase';
+export * from './RiskApiClientBase';
+export * from './IRiskApiClient';

package/lib/types/risk_api/client/index.d.ts

@@ -1,4 +1,4 @@
-export * from './IRiskApiClient';
-export * from './PostRiskApiClientBase';
 export * from './PostRiskApiClientV2';
 export * from './PostRiskApiClientV3';
+export * from './abstract';
+export * from './GetRiskApiClientV2';