perimeterx-js-core 0.25.0 → 0.26.0

package/lib/esm/enforcer/index.js

@@ -1,4 +1,5 @@
 export * from './IEnforcer.js';
+export * from './IPostEnforcer.js';
 export * from './EnforcerBase.js';
 export * from './EnforcerOptions.js';
 export * from './utils.js';

package/lib/esm/flow/EndEnforcerFlow.js

@@ -0,0 +1,18 @@
+import { ClearLogsPhase, SendLogsPhase, SendTelemetryActivityPhase, UpdateRemoteConfigPhase, SendAsyncActivitiesPhase, } from '../phase/index.js';
+import { Flow } from './Flow.js';
+export class EndEnforcerFlow extends Flow {
+    constructor(config, { logServiceClient, telemetry, remoteConfigManager, activityClient, }) {
+        const phases = [
+            new SendAsyncActivitiesPhase(activityClient),
+            new SendTelemetryActivityPhase(telemetry),
+        ];
+        if (remoteConfigManager) {
+            phases.push(new UpdateRemoteConfigPhase(config, remoteConfigManager));
+        }
+        if (logServiceClient) {
+            phases.push(new SendLogsPhase(config, logServiceClient));
+        }
+        phases.push(new ClearLogsPhase());
+        super(phases);
+    }
+}

package/lib/esm/flow/EnforceFlow.js

@@ -0,0 +1,14 @@
+import { AdditionalActivityHandlerPhase, CreateBlockResponsePhase, EnrichContextFromRequestPhase, ModifyIncomingRequestPhase, ParseTokenPhase, RiskApiPhase, } from '../phase/index.js';
+import { Flow } from './Flow.js';
+export class EnforceFlow extends Flow {
+    constructor(config, { dataEnrichment, tokenParser, riskApiClient, cors, products, graphQLParser, }) {
+        super([
+            new ParseTokenPhase(tokenParser),
+            new EnrichContextFromRequestPhase(config, products, dataEnrichment, graphQLParser),
+            new RiskApiPhase(products, riskApiClient),
+            new AdditionalActivityHandlerPhase(config),
+            new CreateBlockResponsePhase(config, CreateBlockResponsePhase.getBlockers(products), cors),
+            new ModifyIncomingRequestPhase(Object.values(products)),
+        ]);
+    }
+}

package/lib/esm/{phase/flow → flow}/FilterFlow.js

@@ -1,7 +1,8 @@
-import { ProductName } from '../../products/index.js';
-import { isNullOrUndefined } from '../../utils/index.js';
-import { CompositePhase, FilterPhase, FirstPartyPhase, PreflightPhase, IdentifyTelemetryRequestPhase, IdentifyRemoteConfigNotifyRequestPhase, } from '../impl/index.js';
-export class FilterFlow extends CompositePhase {
+import { ProductName } from '../products/index.js';
+import { isNullOrUndefined } from '../utils/index.js';
+import { FilterPhase, FirstPartyPhase, PreflightPhase, IdentifyTelemetryRequestPhase, IdentifyRemoteConfigNotifyRequestPhase, } from '../phase/index.js';
+import { Flow } from './Flow.js';
+export class FilterFlow extends Flow {
     constructor(config, { httpClient, products, cors, telemetry, remoteConfigUpdateParser, }) {
         const phases = [];
         const firstPartyProducts = FilterFlow.getFirstPartyProducts(products);

package/lib/esm/flow/Flow.js

@@ -0,0 +1,56 @@
+import { CompositePhase } from '../phase/index.js';
+export class Flow {
+    phases;
+    constructor(phases) {
+        this.phases = phases;
+    }
+    insert(phase, options) {
+        if (!options) {
+            this.phases.push(phase);
+            return;
+        }
+        if (options.before) {
+            const index = this.getIndexOfPhase(options.before);
+            if (index === -1) {
+                return;
+            }
+            this.phases.splice(index, 0, phase);
+        }
+        if (options.after) {
+            const index = this.getIndexOfPhase(options.after);
+            if (index === -1) {
+                return;
+            }
+            this.phases.splice(index + 1, 0, phase);
+        }
+    }
+    remove(name) {
+        const index = this.getIndexOfPhase(name);
+        if (index === -1) {
+            return;
+        }
+        this.phases.splice(index, 1);
+    }
+    replace(name, phase) {
+        const index = this.getIndexOfPhase(name);
+        if (index === -1) {
+            return;
+        }
+        this.phases.splice(index, 1, phase);
+    }
+    move(name, to) {
+        const index = this.getIndexOfPhase(name);
+        if (index === -1) {
+            return;
+        }
+        const phase = this.phases[index];
+        this.phases.splice(index, 1);
+        this.insert(phase, to);
+    }
+    getIndexOfPhase(name) {
+        return this.phases.findIndex((existingPhase) => existingPhase.constructor.name === name);
+    }
+    execute(context) {
+        return new CompositePhase(this.phases).execute(context);
+    }
+}

package/lib/esm/flow/IFlow.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/flow/PostEnforceFlow.js

@@ -0,0 +1,10 @@
+import { EnrichContextFromResponsePhase, ModifyOutgoingResponsePhase } from '../phase/index.js';
+import { Flow } from './Flow.js';
+export class PostEnforceFlow extends Flow {
+    constructor(config, { products, snippetRetriever, snippetInjector, }) {
+        super([
+            new EnrichContextFromResponsePhase(config, products),
+            new ModifyOutgoingResponsePhase(config, Object.values(products), snippetRetriever, snippetInjector),
+        ]);
+    }
+}

package/lib/esm/{phase/flow → flow}/index.js

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

package/lib/esm/index.js

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

package/lib/esm/phase/impl/AdditionalActivityHandlerPhase.js

@@ -1,4 +1,7 @@
 import { AdditionalActivityHandlerUtils } from '../../additional_activity_handler/index.js';
+/**
+ * The `AdditionalActivityHandlerPhase` invokes the additional activity handler defined in the configuration.
+ */
 export class AdditionalActivityHandlerPhase {
     config;
     constructor(config) {

package/lib/esm/phase/impl/ClearLogsPhase.js

@@ -1,3 +1,6 @@
+/**
+ * The `ClearLogsPhase` class deletes the context logs to free up memory.
+ */
 export class ClearLogsPhase {
     async execute(context) {
         context.logger.clearLogs();

package/lib/esm/phase/impl/CompositePhase.js

@@ -1,5 +1,14 @@
+/**
+ * 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 class CompositePhase {
     phases;
+    /**
+     * Creates a new CompositePhase instance.
+     * @param phases - An array of phases to be executed in sequence.
+     */
     constructor(phases) {
         this.phases = phases;
     }

package/lib/esm/phase/impl/CreateBlockResponsePhase.js

@@ -1,7 +1,11 @@
 import { MinimalResponseUtils } from '../../http/index.js';
 import { PXHDSource, PXHDUtils } from '../../pxhd/index.js';
 import { Action } from '../../action/index.js';
-import { PRODUCT_PRIORITY_ORDER } from '../../products/index.js';
+import { PRODUCT_PRIORITY_ORDER, ProductName } from '../../products/index.js';
+/**
+ * `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 class CreateBlockResponsePhase {
     config;
     blockers;
@@ -13,6 +17,17 @@ export class CreateBlockResponsePhase {
             this.cors = cors;
         }
     }
+    /**
+     * 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(products) {
+        return {
+            [ProductName.BOT_DEFENDER]: products[ProductName.BOT_DEFENDER],
+            [ProductName.HYPE_SALE_CHALLENGE]: products[ProductName.HYPE_SALE_CHALLENGE],
+        };
+    }
     async execute(context) {
         if (context.action !== Action.BLOCK) {
             return { done: false };

package/lib/esm/phase/impl/DecideActionPhase.js

@@ -1,7 +1,18 @@
 import { LoggerSeverity } from '../../logger/index.js';
 import { Action, getDecisionFromContext } from '../../action/index.js';
 import { BlockAction } from '../../blocker/index.js';
+/**
+ * `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 class DecideActionPhase {
+    /**
+     * Updates the `action`, `reasons`, and `blockAction` properties based on the product data in the context.
+     * @param context - The request context.
+     * @protected
+     */
     async updateContextDecision(context) {
         const { action, reasons } = getDecisionFromContext(context);
         if (context.logger.getLoggerSeverity() === LoggerSeverity.DEBUG) {

package/lib/esm/phase/impl/EnrichContextFromRequestPhase.js

@@ -1,5 +1,14 @@
 import { CustomParametersUtils } from '../../custom_parameters/index.js';
 import { DecideActionPhase } from './DecideActionPhase.js';
+/**
+ * `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 class EnrichContextFromRequestPhase extends DecideActionPhase {
     config;
     products;

package/lib/esm/phase/impl/EnrichContextFromResponsePhase.js

@@ -1,4 +1,8 @@
 import { isNullOrUndefined } from '../../utils/index.js';
+/**
+ * `EnrichContextFromResponsePhase` enriches the context with response data. Each product's `enrichContextFromResponse`
+ * method is called since every product may use the response data differently.
+ */
 export class EnrichContextFromResponsePhase {
     config;
     products;

package/lib/esm/phase/impl/FilterPhase.js

@@ -1,3 +1,7 @@
+/**
+ * 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 class FilterPhase {
     filters;
     constructor(filters) {

package/lib/esm/phase/impl/FirstPartyPhase.js

@@ -1,4 +1,9 @@
 import { MinimalResponseUtils } from '../../http/index.js';
+/**
+ * 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 class FirstPartyPhase {
     config;
     httpClient;

package/lib/esm/phase/impl/IdentifyRemoteConfigNotifyRequestPhase.js

@@ -1,4 +1,9 @@
 import { MinimalResponseImpl } from '../../http/index.js';
+/**
+ * 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 class IdentifyRemoteConfigNotifyRequestPhase {
     remoteConfigUpdateParser;
     constructor(remoteConfigUpdateParser) {

package/lib/esm/phase/impl/IdentifyTelemetryRequestPhase.js

@@ -1,3 +1,8 @@
+/**
+ * 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 class IdentifyTelemetryRequestPhase {
     telemetry;
     constructor(telemetry) {

package/lib/esm/phase/impl/ModifyIncomingRequestPhase.js

@@ -1,3 +1,8 @@
+/**
+ * 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 class ModifyIncomingRequestPhase {
     products;
     constructor(products) {

package/lib/esm/phase/impl/ModifyOutgoingResponsePhase.js

@@ -1,5 +1,10 @@
 import { PXHDSource, PXHDUtils } from '../../pxhd/index.js';
 import { CONTENT_TYPE_HEADER_NAME, ContentType } from '../../http/index.js';
+/**
+ * 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 class ModifyOutgoingResponsePhase {
     config;
     products;

package/lib/esm/phase/impl/ParseTokenPhase.js

@@ -1,5 +1,8 @@
 import { TokenParseResult } from '../../risk_token/index.js';
-import { transferExistingProperties, VidSource } from '../../utils/index.js';
+import { VidSource } from '../../utils/index.js';
+/**
+ * The `ParseTokenPhase` class is responsible for parsing the risk token from the incoming request and updating the context.
+ */
 export class ParseTokenPhase {
     tokenParser;
     constructor(tokenParser) {
@@ -12,14 +15,18 @@ export class ParseTokenPhase {
     }
     addTokenDataToContext(context, tokenData) {
         Object.assign(context.tokenData, tokenData);
-        if (tokenData.tokenParseResult === TokenParseResult.SUCCESSFUL) {
-            transferExistingProperties(tokenData.token, context, {
-                vid: 'vid',
-                uuid: 'uuid',
-                score: 'score',
-                action: 'blockAction',
-            });
+        if (tokenData.tokenParseResult === TokenParseResult.SUCCESSFUL && tokenData.token) {
+            if (tokenData.token.score != null) {
+                context.score = tokenData.token.score;
+            }
+            if (tokenData.token.action) {
+                context.blockAction = tokenData.token.action;
+            }
+            if (tokenData.token.uuid) {
+                context.uuid = tokenData.token.uuid;
+            }
             if (tokenData.token.vid) {
+                context.vid = tokenData.token.vid;
                 context.vidSource = VidSource.RISK_COOKIE;
             }
         }

package/lib/esm/phase/impl/PreflightPhase.js

@@ -1,3 +1,7 @@
+/**
+ * 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 class PreflightPhase {
     corsSupportEnabled;
     filterPreflightRequestsEnabled;

package/lib/esm/phase/impl/RiskApiPhase.js

@@ -1,7 +1,12 @@
 import { Action, getReasonForHighestPriorityProduct } from '../../action/index.js';
-import { isNullOrUndefined, transferExistingProperties } from '../../utils/index.js';
+import { isNullOrUndefined } from '../../utils/index.js';
 import { PXHDSource } from '../../pxhd/index.js';
 import { DecideActionPhase } from './DecideActionPhase.js';
+/**
+ * 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 class RiskApiPhase extends DecideActionPhase {
     products;
     riskApiClient;
@@ -36,14 +41,20 @@ export class RiskApiPhase extends DecideActionPhase {
         if (!riskResponse) {
             return;
         }
-        transferExistingProperties(riskResponse, context, {
-            score: 'score',
-            uuid: 'uuid',
-            action: 'blockAction',
-            dataEnrichment: 'pxde',
-            telemetryRequested: 'shouldSendTelemetry',
-        });
+        if (riskResponse.score != null) {
+            context.score = riskResponse.score;
+        }
+        if (riskResponse.action) {
+            context.blockAction = riskResponse.action;
+        }
+        if (riskResponse.uuid) {
+            context.uuid = riskResponse.uuid;
+        }
+        if (riskResponse.telemetryRequested) {
+            context.shouldSendTelemetry = true;
+        }
         if (riskResponse.dataEnrichment) {
+            context.pxde = riskResponse.dataEnrichment;
             context.pxdeVerified = true;
         }
         if (riskResponse.pxhd) {

package/lib/esm/phase/impl/SendAsyncActivitiesPhase.js

@@ -0,0 +1,16 @@
+import { Action } from '../../action/index.js';
+/**
+ * The `SendAsyncActivitiesPhase` class is responsible for sending all necessary asynchronous activities based on the context.
+ */
+export class SendAsyncActivitiesPhase {
+    activityClient;
+    constructor(activityClient) {
+        this.activityClient = activityClient;
+    }
+    async execute(context) {
+        if ([Action.PASS_REQUEST, Action.BLOCK, Action.SIMULATED_BLOCK].includes(context.action)) {
+            await this.activityClient.sendActivities(context);
+        }
+        return { done: false };
+    }
+}

package/lib/esm/phase/impl/SendLogsPhase.js

@@ -1,3 +1,6 @@
+/**
+ * The `SendLogsPhase` class is responsible for sending logs to the HUMAN logging service.
+ */
 export class SendLogsPhase {
     logServiceClient;
     constructor(_config, logServiceClient) {

package/lib/esm/phase/impl/SendTelemetryActivityPhase.js

@@ -1,3 +1,6 @@
+/**
+ * The `SendTelemetryActivityPhase` class is responsible for sending the telemetry activity if necessary.
+ */
 export class SendTelemetryActivityPhase {
     telemetry;
     constructor(telemetry) {

package/lib/esm/phase/impl/UpdateRemoteConfigPhase.js

@@ -1,3 +1,6 @@
+/**
+ * The `UpdateRemoteConfigPhase` class is responsible for updating the remote configuration if necessary.
+ */
 export class UpdateRemoteConfigPhase {
     config;
     remoteConfigManager;

package/lib/esm/phase/impl/index.js

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

package/lib/esm/phase/index.js

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

package/lib/esm/products/credential_intelligence/endpoint/login_successful/BodyLoginSuccessfulParser.js

@@ -1,7 +1,7 @@
 export class BodyLoginSuccessfulParser {
     bodyRegex;
     constructor(regex) {
-        this.bodyRegex = new RegExp(regex);
+        this.bodyRegex = regex;
     }
     async isLoginSuccessful(response) {
         return !!(await response.text()).match(this.bodyRegex);

package/lib/esm/products/credential_intelligence/endpoint/login_successful/LoginSuccessfulParserFactory.js

@@ -3,7 +3,7 @@ import { BodyLoginSuccessfulParser } from './BodyLoginSuccessfulParser.js';
 import { CustomLoginSuccessfulParser } from './CustomLoginSuccessfulParser.js';
 import { HeaderLoginSuccessfulParser } from './HeaderLoginSuccessfulParser.js';
 import { StatusLoginSuccessfulParser } from './StatusLoginSuccessfulParser.js';
-import { EnforcerConfigurationError } from '../../../../utils/index.js';
+import { convertRegexStringToRegex, EnforcerConfigurationError } from '../../../../utils/index.js';
 export class LoginSuccessfulParserFactory {
     static create(config, endpointConfig) {
         const { ciDefaultLoginSuccessfulReportingMethod, ciDefaultLoginSuccessfulBodyRegex, ciDefaultLoginSuccessfulStatus, ciDefaultLoginSuccessfulCustomCallback, ciDefaultLoginSuccessfulHeaderName, ciDefaultLoginSuccessfulHeaderValue, } = config;
@@ -13,7 +13,10 @@ export class LoginSuccessfulParserFactory {
             LoginSuccessfulReportingMethod.STATUS;
         switch (reportingMethod) {
             case LoginSuccessfulReportingMethod.BODY:
-                return new BodyLoginSuccessfulParser(login_successful_body_regex ?? ciDefaultLoginSuccessfulBodyRegex);
+                const bodyRegex = login_successful_body_regex ?? ciDefaultLoginSuccessfulBodyRegex;
+                return new BodyLoginSuccessfulParser(typeof bodyRegex === 'string'
+                    ? (convertRegexStringToRegex(bodyRegex) ?? new RegExp(bodyRegex))
+                    : bodyRegex);
             case LoginSuccessfulReportingMethod.CUSTOM:
                 const callback = login_successful_callback ?? ciDefaultLoginSuccessfulCustomCallback;
                 if (!callback) {

package/lib/esm/products/credential_intelligence/endpoint/matcher/CredentialIntelligenceEndpointMatcherFactory.js

@@ -1,3 +1,4 @@
+import { convertRegexStringToRegex } from '../../../../utils/index.js';
 import { ExactPathEndpointMatcher } from './ExactPathEndpointMatcher.js';
 import { RegexPathEndpointMatcher } from './RegexPathEndpointMatcher.js';
 import { PathType } from './PathType.js';
@@ -5,7 +6,7 @@ export class CredentialIntelligenceEndpointMatcherFactory {
     static create({ path_type, path, method, }) {
         switch (path_type) {
             case PathType.REGEX:
-                return new RegexPathEndpointMatcher(new RegExp(path), method.toUpperCase());
+                return new RegexPathEndpointMatcher(convertRegexStringToRegex(path) ?? new RegExp(path), method.toUpperCase());
             case PathType.EXACT:
             default:
                 return new ExactPathEndpointMatcher(path, method.toUpperCase());

package/lib/esm/risk_api/client/GetRiskApiClientV2.js

@@ -0,0 +1,57 @@
+import { RiskApiClientBase } from './abstract/index.js';
+import { AUTHORIZATION_HEADER_NAME, CONTENT_LENGTH_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, HttpMethod, OutgoingRequestImpl, } from '../../http/index.js';
+import { GetRiskResponseV2 } from '../risk_response/index.js';
+import { RISK_ACTIVITY_ADDITIONAL_FIELDS_TO_HEADER_NAMES, RISK_ACTIVITY_FIELDS_TO_HEADER_NAMES, RISK_ACTIVITY_REQUEST_FIELDS_TO_HEADER_NAMES, } from '../model/index.js';
+import { createRiskApiActivity } from '../utils.js';
+export class GetRiskApiClientV2 extends RiskApiClientBase {
+    constructor(config, httpClient) {
+        super(config, httpClient);
+    }
+    createRiskRequest(context) {
+        return new OutgoingRequestImpl({
+            method: HttpMethod.GET,
+            url: this.getRiskUrl(),
+            headers: this.getRiskActivityHeaders(context),
+        });
+    }
+    getRiskActivityHeaders(context) {
+        const riskHeaders = this.getRiskHeaders();
+        const requestHeaders = this.getRequestHeadersForRisk(context);
+        const riskActivityHeaders = this.riskActivityToHeaders(createRiskApiActivity(this.config, context));
+        return Object.assign(requestHeaders, riskActivityHeaders, riskHeaders);
+    }
+    getRequestHeadersForRisk(context) {
+        const HEADERS_TO_DELETE = [CONTENT_LENGTH_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, AUTHORIZATION_HEADER_NAME];
+        const headers = {};
+        Object.entries(context.requestData.headers).forEach(([key, value]) => {
+            if (!HEADERS_TO_DELETE.includes(key.toLowerCase())) {
+                headers[key] = value.concat();
+            }
+        });
+        return headers;
+    }
+    riskActivityToHeaders(riskActivity) {
+        const headers = {};
+        this.addHeadersFromObject(headers, riskActivity, RISK_ACTIVITY_FIELDS_TO_HEADER_NAMES);
+        this.addHeadersFromObject(headers, riskActivity.request, RISK_ACTIVITY_REQUEST_FIELDS_TO_HEADER_NAMES);
+        this.addHeadersFromObject(headers, riskActivity.additional, RISK_ACTIVITY_ADDITIONAL_FIELDS_TO_HEADER_NAMES);
+        return headers;
+    }
+    addHeadersFromObject(headers, object, headerNamesMap) {
+        Object.entries(object).forEach(([key, value]) => {
+            const headerConversionObject = headerNamesMap[key];
+            if (headerConversionObject && value != null) {
+                const { header, convertToString } = headerConversionObject;
+                const strValue = convertToString
+                    ? convertToString(value)
+                    : typeof value === 'string'
+                        ? value
+                        : `${value}`;
+                headers[header] = [strValue];
+            }
+        });
+    }
+    createRiskResponse(response) {
+        return new GetRiskResponseV2(response);
+    }
+}

package/lib/esm/risk_api/client/PostRiskApiClientV2.js

@@ -1,10 +1,10 @@
-import { DefaultRiskResponseV2 } from '../risk_response/index.js';
-import { PostRiskApiClientBase } from './PostRiskApiClientBase.js';
+import { PostRiskResponseV2 } from '../risk_response/index.js';
+import { PostRiskApiClientBase } from './abstract/index.js';
 export class PostRiskApiClientV2 extends PostRiskApiClientBase {
     constructor(config, httpClient) {
         super(config, httpClient);
     }
     createRiskResponse(response) {
-        return new DefaultRiskResponseV2(response);
+        return new PostRiskResponseV2(response);
     }
 }

package/lib/esm/risk_api/client/PostRiskApiClientV3.js

@@ -1,10 +1,10 @@
-import { PostRiskApiClientBase } from './PostRiskApiClientBase.js';
-import { DefaultRiskResponseV3 } from '../risk_response/index.js';
+import { PostRiskResponseV3 } from '../risk_response/index.js';
+import { PostRiskApiClientBase } from './abstract/index.js';
 export class PostRiskApiClientV3 extends PostRiskApiClientBase {
     constructor(config, httpClient) {
         super(config, httpClient);
     }
     createRiskResponse(response) {
-        return new DefaultRiskResponseV3(response);
+        return new PostRiskResponseV3(response);
     }
 }

package/lib/esm/risk_api/client/abstract/IRiskApiClient.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/risk_api/client/abstract/PostRiskApiClientBase.js

@@ -0,0 +1,18 @@
+import { RiskApiClientBase } from './RiskApiClientBase.js';
+import { HttpMethod, OutgoingRequestImpl } from '../../../http/index.js';
+import { createRiskApiActivity } from '../../utils.js';
+import { CONTENT_TYPE_HEADER_NAME, ContentType } from '../../../http/index.js';
+export class PostRiskApiClientBase extends RiskApiClientBase {
+    createRiskRequest(context) {
+        const url = this.getRiskUrl();
+        const headers = this.getRiskHeaders();
+        const body = JSON.stringify(createRiskApiActivity(this.config, context));
+        const method = HttpMethod.POST;
+        return new OutgoingRequestImpl({ url, method, headers, body });
+    }
+    getRiskHeaders() {
+        return Object.assign({
+            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
+        }, super.getRiskHeaders());
+    }
+}