perimeterx-js-core 0.25.0 → 0.26.0

package/lib/esm/risk_api/client/{PostRiskApiClientBase.js → abstract/RiskApiClientBase.js}

@@ -1,9 +1,9 @@
-import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../../http/index.js';
-import { EnforcerErrorName, getAuthorizationHeader, removeSensitiveHeaders } from '../../utils/index.js';
-import { createCommonActivityDetails, toHeaderEntryArray } from '../../activities/index.js';
-import { RISK_API_ENDPOINT } from '../constants.js';
-import { RiskApiCallResult, RiskStatus, S2SErrorReason } from '../model/index.js';
-export class PostRiskApiClientBase {
+import { AUTHORIZATION_HEADER_NAME, } from '../../../http/index.js';
+import { EnforcerErrorName, getAuthorizationHeader, removeSensitiveHeaders } from '../../../utils/index.js';
+import { toHeaderEntryArray } from '../../../activities/index.js';
+import { RISK_API_ENDPOINT } from '../../constants.js';
+import { RiskApiCallResult, RiskStatus, S2SErrorReason } from '../../model/index.js';
+export class RiskApiClientBase {
     config;
     httpClient;
     constructor(config, httpClient) {
@@ -20,8 +20,8 @@ export class PostRiskApiClientBase {
         let riskResponse;
         const riskApiData = { riskApiCallResult: RiskApiCallResult.NONE };
         try {
-            const riskActivity = this.createRiskActivity(context);
-            response = await this.sendRiskActivity(riskActivity, riskApiData, context);
+            const riskRequest = this.createRiskRequest(context);
+            response = await this.sendRiskActivity(riskRequest, riskApiData, context);
             if (response?.status !== 200) {
                 return await this.handleS2SError(riskApiData, context, response);
             }
@@ -41,50 +41,12 @@ export class PostRiskApiClientBase {
             return await this.handleS2SError(riskApiData, context, response, err);
         }
     }
-    /**
-     * Creates the RiskActivity payload
-     * @param context
-     * @returns RiskActivity
-     * @protected
-     */
-    createRiskActivity(context) {
-        const riskActivity = {
-            vid: context.vid,
-            client_uuid: context.uuid,
-            pxhd: context.pxhd?.value,
-            request: {
-                socket_ip: context.requestData.ip,
-                headers: this.formatRiskHeadersField(context.requestData.headers),
-                url: context.requestData.url.href,
-            },
-            additional: {
-                ...createCommonActivityDetails(this.config, context),
-                s2s_call_reason: context.riskApiData.s2sCallReason ?? 'unknown_reason',
-                risk_start_time: context.riskApiData.riskStartTime ?? Date.now(),
-            },
-        };
-        return this.finalizeRiskActivity(riskActivity);
-    }
-    /**
-     * Protected function in case expansions or alterations to the risk activity are needed for certain platforms.
-     * @param riskActivity
-     * @returns RiskActivity
-     * @protected
-     */
-    finalizeRiskActivity(riskActivity) {
-        return riskActivity;
-    }
     formatRiskHeadersField(headers) {
         const headersWithoutSensitive = removeSensitiveHeaders(headers, this.config.sensitiveHeaders);
         return toHeaderEntryArray(headersWithoutSensitive);
     }
-    async sendRiskActivity(riskActivity, riskApiData, context) {
-        const url = this.getRiskUrl();
-        const headers = this.getRiskHeaders();
-        const body = JSON.stringify(riskActivity);
-        const method = HttpMethod.POST;
-        const riskRequest = new OutgoingRequestImpl({ url, method, headers, body });
-        context.logger.debug(`sending risk api to ${url}`);
+    async sendRiskActivity(riskRequest, riskApiData, context) {
+        context.logger.debug(`sending risk api to ${riskRequest.url}`);
         const startTime = Date.now();
         const response = await this.httpClient.send(riskRequest, { timeoutMs: this.config.s2sTimeout });
         const endTime = Date.now();
@@ -97,7 +59,6 @@ export class PostRiskApiClientBase {
     }
     getRiskHeaders() {
         return {
-            [CONTENT_TYPE_HEADER_NAME]: [ContentType.APPLICATION_JSON],
             [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
         };
     }

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

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

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

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

package/lib/esm/risk_api/index.js

@@ -2,3 +2,4 @@ export * from './model/index.js';
 export * from './risk_response/index.js';
 export * from './client/index.js';
 export * from './constants.js';
+export * from './utils.js';

package/lib/esm/risk_api/model/GetRiskRequestHeaders.js

@@ -0,0 +1,182 @@
+export const RISK_ACTIVITY_FIELDS_TO_HEADER_NAMES = {
+    vid: {
+        header: 'x-px-vid',
+    },
+    client_uuid: {
+        header: 'x-px-client-uuid',
+    },
+    pxhd: {
+        header: 'x-px-pxhd',
+    },
+};
+export const RISK_ACTIVITY_REQUEST_FIELDS_TO_HEADER_NAMES = {
+    socket_ip: {
+        header: 'x-px-socket-ip',
+    },
+    url: {
+        header: 'x-px-url',
+    },
+};
+export const RISK_ACTIVITY_ADDITIONAL_FIELDS_TO_HEADER_NAMES = {
+    cpa: {
+        header: 'x-px-add-cpa',
+        convertToString: (value) => `${value}`,
+    },
+    enforcer_start_time: {
+        header: 'x-px-add-enforcer-start-time',
+        convertToString: (value) => `${value}`,
+    },
+    is_hype_sale: {
+        header: 'x-px-add-is-hype-sale',
+        convertToString: (value) => `${value}`,
+    },
+    px_cookie_hmac: {
+        header: 'x-px-add-cookie-hmac',
+    },
+    raw_url: {
+        header: 'x-px-add-raw-url',
+    },
+    tls_ja3_fingerprint: {
+        header: 'x-px-add-tls-ja3-fingerprint',
+    },
+    tls_preferred_ciphers: {
+        header: 'x-px-add-tls-preferred-ciphers',
+    },
+    used_cookie_secret: {
+        header: 'x-px-add-used-cookie-secret',
+    },
+    risk_start_time: {
+        header: 'x-px-add-risk-start-time',
+        convertToString: (value) => `${value}`,
+    },
+    app_user_id: {
+        header: 'x-px-add-app-user-id',
+    },
+    ci_version: {
+        header: 'x-px-add-ci-version',
+    },
+    cookie_origin: {
+        header: 'x-px-add-cookie-origin',
+    },
+    cross_tab_session: {
+        header: 'x-px-add-cross-tab-session',
+    },
+    custom_param1: {
+        header: 'x-px-custom-param1',
+    },
+    custom_param10: {
+        header: 'x-px-custom-param10',
+    },
+    custom_param2: {
+        header: 'x-px-custom-param2',
+    },
+    custom_param3: {
+        header: 'x-px-custom-param3',
+    },
+    custom_param4: {
+        header: 'x-px-custom-param4',
+    },
+    custom_param5: {
+        header: 'x-px-custom-param5',
+    },
+    custom_param6: {
+        header: 'x-px-custom-param6',
+    },
+    custom_param7: {
+        header: 'x-px-custom-param7',
+    },
+    custom_param8: {
+        header: 'x-px-custom-param8',
+    },
+    custom_param9: {
+        header: 'x-px-custom-param9',
+    },
+    enforcer_vid_source: {
+        header: 'x-px-add-enforcer-vid-source',
+    },
+    server_info_datacenter: {
+        header: 'x-px-add-server-info-datacenter',
+    },
+    server_info_region: {
+        header: 'x-px-add-server-info-region',
+    },
+    graphql_operations: {
+        header: 'x-px-add-graphql-operations',
+        convertToString: (value) => JSON.stringify(value),
+    },
+    http_method: {
+        header: 'x-px-add-http-method',
+    },
+    http_version: {
+        header: 'x-px-add-http-version',
+    },
+    jwt_additional_fields: {
+        header: 'x-px-add-jwt-additional-fields',
+        convertToString: (value) => JSON.stringify(value),
+    },
+    module_version: {
+        header: 'x-px-add-module-version',
+    },
+    original_token: {
+        header: 'x-px-add-original-token',
+    },
+    original_token_error: {
+        header: 'x-px-add-original-token-error',
+    },
+    original_uuid: {
+        header: 'x-px-add-original-uuid',
+    },
+    pass: {
+        header: 'x-px-add-pass',
+    },
+    px_cookie: {
+        header: 'x-px-add-px-cookie',
+    },
+    px_decoded_original_token: {
+        header: 'x-px-decoded-original-token',
+    },
+    px_orig_cookie: {
+        header: 'x-px-add-px-orig-cookie',
+    },
+    request_cookie_names: {
+        header: 'x-px-add-request-cookie-names',
+        convertToString: (value) => value.join(','),
+    },
+    request_id: {
+        header: 'x-px-add-request-id',
+    },
+    risk_mode: {
+        header: 'x-px-add-risk-mode',
+    },
+    sso_step: {
+        header: 'x-px-add-sso-step',
+    },
+    tls_cipher: {
+        header: 'x-px-add-tls-cipher',
+    },
+    tls_ciphers_sha: {
+        header: 'x-px-add-tls-ciphers-sha',
+    },
+    tls_extension_sha: {
+        header: 'x-px-add-tls-extension-sha',
+    },
+    tls_protocol: {
+        header: 'x-px-add-tls-protocol',
+    },
+    tls_server: {
+        header: 'x-px-add-tls-server',
+    },
+    user: {
+        header: 'x-px-add-user',
+    },
+    remote_config_id: {
+        header: 'x-px-add-remote-config-id',
+    },
+    remote_config_version: {
+        header: 'x-px-add-remote-config-version',
+        convertToString: (value) => `${value}`,
+    },
+    s2s_call_reason: {
+        header: 'x-px-add-s2s-call-reason',
+    },
+};

package/lib/esm/risk_api/model/GetRiskResponseHeaders.js

@@ -0,0 +1,13 @@
+export const GetRiskResponseHeaders = {
+    Action: 'x-px-action',
+    AdditionalRiskInfo: 'x-px-additional-risk-info',
+    CookieCfgBlockResult: 'x-px-cookie-cfg-block-result',
+    DataEnrichment: 'x-px-data-enrichment',
+    Drc: 'x-px-drc',
+    Message: 'x-px-message',
+    Pxhd: 'x-px-pxhd',
+    PxhdDomain: 'x-px-pxhddomain',
+    Status: 'x-px-status',
+    TelemetryRequested: 'x-px-telemetry-requested',
+    Uuid: 'x-px-uuid',
+};

package/lib/esm/risk_api/model/index.js

@@ -2,3 +2,5 @@ export * from './RiskActivity.js';
 export * from './RiskStatus.js';
 export * from './RiskApiCallResult.js';
 export * from './S2SErrorReason.js';
+export * from './GetRiskResponseHeaders.js';
+export * from './GetRiskRequestHeaders.js';

package/lib/esm/risk_api/risk_response/PostRiskResponseBase.js

@@ -0,0 +1,6 @@
+import { RiskResponseBase } from './RiskResponseBase.js';
+export class PostRiskResponseBase extends RiskResponseBase {
+    async parseRiskResponse(response) {
+        return response.json();
+    }
+}

package/lib/esm/risk_api/risk_response/RiskResponseBase.js

@@ -7,7 +7,11 @@ export class RiskResponseBase {
     }
     async validate() {
         try {
-            this.riskResponse = (await this.response.json());
+            const riskResponse = await this.parseRiskResponse(this.response);
+            if (!riskResponse) {
+                return false;
+            }
+            this.riskResponse = riskResponse;
             return this.status === RiskStatus.SUCCESS && this.validateRiskResponseScore();
         }
         catch (e) {

package/lib/esm/risk_api/risk_response/index.js

@@ -1,5 +1,6 @@
 export * from './IRiskResponse.js';
 export * from './RiskResponseBase.js';
+export * from './PostRiskResponseBase.js';
 export * from './CommonRiskResponsePayload.js';
 export * from './v2/index.js';
 export * from './v3/index.js';

package/lib/esm/risk_api/risk_response/serialize/SerializedRiskResponse.js

@@ -1,3 +1,4 @@
+import { EnforcerError } from '../../../utils/index.js';
 export class SerializedRiskResponse {
     action;
     additionalRiskInfo;
@@ -24,6 +25,9 @@ export class SerializedRiskResponse {
         this.uuid = riskResponseJson.uuid;
     }
     validate() {
-        return true;
+        throw new EnforcerError('SerializedRiskResponse.validate() should not be invoked');
+    }
+    toJSON() {
+        return this;
     }
 }

package/lib/esm/risk_api/risk_response/v2/GetRiskResponseV2.js

@@ -0,0 +1,52 @@
+import { RiskResponseBase } from '../RiskResponseBase.js';
+import { GetRiskResponseHeaders } from '../../model/index.js';
+export class GetRiskResponseV2 extends RiskResponseBase {
+    constructor(response) {
+        super(response);
+    }
+    parseRiskResponse(response) {
+        const riskStatus = this.getHeader(response, GetRiskResponseHeaders.Status);
+        if (!riskStatus) {
+            return null;
+        }
+        const status = parseInt(riskStatus);
+        const blockResult = this.getHeader(response, GetRiskResponseHeaders.CookieCfgBlockResult);
+        const additionalRiskInfo = this.getHeader(response, GetRiskResponseHeaders.AdditionalRiskInfo);
+        const dataEnrichment = this.getHeader(response, GetRiskResponseHeaders.DataEnrichment);
+        const drc = this.getHeader(response, GetRiskResponseHeaders.Drc);
+        const message = this.getHeader(response, GetRiskResponseHeaders.Message);
+        const pxhd = this.getHeader(response, GetRiskResponseHeaders.Pxhd);
+        const pxhdDomain = this.getHeader(response, GetRiskResponseHeaders.PxhdDomain);
+        const telemetryRequested = this.getHeader(response, GetRiskResponseHeaders.TelemetryRequested);
+        const uuid = this.getHeader(response, GetRiskResponseHeaders.Uuid);
+        const action = this.getHeader(response, GetRiskResponseHeaders.Action);
+        return {
+            status,
+            action,
+            uuid,
+            pxhd,
+            message,
+            data_enrichment: dataEnrichment ? JSON.parse(dataEnrichment) : undefined,
+            pxhdDomain,
+            additional_risk_info: additionalRiskInfo,
+            telemetry_requested: !!telemetryRequested,
+            drc: drc ? parseInt(drc) : undefined,
+            cookie_cfg_block_result: blockResult,
+        };
+    }
+    getHeader(response, header) {
+        return response.headers[header.toLowerCase()]?.[0];
+    }
+    // TODO: This is the same as in PostRiskResponseV2. We should deduplicate this.
+    get score() {
+        return typeof this.riskResponse?.cookie_cfg_block_result === 'undefined'
+            ? undefined
+            : this.riskResponse.cookie_cfg_block_result === '1'
+                ? 100
+                : 0;
+    }
+    validateRiskResponseScore() {
+        const blockResult = this.riskResponse?.cookie_cfg_block_result;
+        return typeof blockResult === 'string' && ['0', '1'].includes(blockResult);
+    }
+}

package/lib/esm/risk_api/risk_response/v2/{DefaultRiskResponseV2.js → PostRiskResponseV2.js}

@@ -1,5 +1,5 @@
-import { RiskResponseBase } from '../RiskResponseBase.js';
-export class DefaultRiskResponseV2 extends RiskResponseBase {
+import { PostRiskResponseBase } from '../PostRiskResponseBase.js';
+export class PostRiskResponseV2 extends PostRiskResponseBase {
     constructor(response) {
         super(response);
     }

package/lib/esm/risk_api/risk_response/v2/index.js

@@ -1,2 +1,3 @@
-export * from './DefaultRiskResponseV2.js';
+export * from './GetRiskResponseV2.js';
+export * from './PostRiskResponseV2.js';
 export * from './RiskResponseV2Payload.js';

package/lib/esm/risk_api/risk_response/v3/{DefaultRiskResponseV3.js → PostRiskResponseV3.js}

@@ -1,5 +1,5 @@
-import { RiskResponseBase } from '../RiskResponseBase.js';
-export class DefaultRiskResponseV3 extends RiskResponseBase {
+import { PostRiskResponseBase } from '../PostRiskResponseBase.js';
+export class PostRiskResponseV3 extends PostRiskResponseBase {
     constructor(response) {
         super(response);
     }

package/lib/esm/risk_api/risk_response/v3/index.js

@@ -1,2 +1,2 @@
-export * from './DefaultRiskResponseV3.js';
+export * from './PostRiskResponseV3.js';
 export * from './RiskResponseV3Payload.js';

package/lib/esm/risk_api/utils.js

@@ -0,0 +1,23 @@
+import { createCommonActivityDetails, toHeaderEntryArray } from '../activities/index.js';
+import { removeSensitiveHeaders } from '../utils/index.js';
+export const createRiskApiActivity = (config, context) => {
+    return {
+        vid: context.vid,
+        client_uuid: context.uuid,
+        pxhd: context.pxhd?.value,
+        request: {
+            socket_ip: context.requestData.ip,
+            headers: formatRiskHeadersField(context.requestData.headers, config),
+            url: context.requestData.url.href,
+        },
+        additional: {
+            ...createCommonActivityDetails(config, context),
+            s2s_call_reason: context.riskApiData.s2sCallReason ?? 'unknown_reason',
+            risk_start_time: context.riskApiData.riskStartTime ?? Date.now(),
+        },
+    };
+};
+export const formatRiskHeadersField = (headers, config) => {
+    const headersWithoutSensitive = removeSensitiveHeaders(headers, config.sensitiveHeaders);
+    return toHeaderEntryArray(headersWithoutSensitive);
+};

package/lib/esm/telemetry/DefaultTelemetry.js

@@ -1,6 +1,6 @@
 import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../http/index.js';
 import { ActivityType } from '../activities/index.js';
-import { getAuthorizationHeader, transferExistingProperties, DefaultTimestampHmacHeaderValidator, telemetryConfigReplacer, redactSensitiveFields, } from '../utils/index.js';
+import { getAuthorizationHeader, DefaultTimestampHmacHeaderValidator, telemetryConfigReplacer, redactSensitiveFields, } from '../utils/index.js';
 import { TELEMETRY_ENDPOINT, TELEMETRY_HEADER_NAME, TELEMETRY_UPDATE_REASON } from './constants.js';
 export class DefaultTelemetry {
     config;
@@ -49,7 +49,6 @@ export class DefaultTelemetry {
             [AUTHORIZATION_HEADER_NAME]: [getAuthorizationHeader(this.config.authToken)],
         };
         const activity = this.createTelemetryActivity(context);
-        context.logger.debug(`created telemetry activity config - ${JSON.stringify(activity.details.enforcer_configs, telemetryConfigReplacer)}`);
         return new OutgoingRequestImpl({
             url: url,
             method: method,
@@ -79,14 +78,18 @@ export class DefaultTelemetry {
                 enforcer_configs: telemetryConfig,
             },
         };
-        transferExistingProperties(context.serverData, activity.details, {
-            osName: 'os_name',
-            nodeName: 'node_name',
-        });
-        transferExistingProperties(this.config, activity.details, {
-            remoteConfigId: 'remote_config_id',
-            remoteConfigVersion: 'remote_config_version',
-        });
+        if (context.serverData.osName) {
+            activity.details.os_name = context.serverData.osName;
+        }
+        if (context.serverData.nodeName) {
+            activity.details.node_name = context.serverData.nodeName;
+        }
+        if (this.config.remoteConfigId) {
+            activity.details.remote_config_id = this.config.remoteConfigId;
+        }
+        if (this.config.remoteConfigVersion) {
+            activity.details.remote_config_version = this.config.remoteConfigVersion;
+        }
         return activity;
     }
 }

package/lib/esm/utils/constants.js

@@ -11,4 +11,4 @@ export const PUSH_DATA_FEATURE_HEADER_NAME = 'x-px-feature';
 export const EMAIL_ADDRESS_REGEX = /^[a-zA-Z0-9_+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$/;
 export const URL_REGEX = /^(https?:)\/\/(([^@\s:\/]+):?([^@\s\/]*)@)?(([^:\/?#]*)(?:\:([0-9]+))?)(\/?[^?#]*)(\?[^#]*|)(#.*|)$/;
 export const REGEX_STRUCTURE = /^\/(.+?)\/([gimsuyvd]*)$/;
-export const CORE_MODULE_VERSION = 'JS Core 0.25.0';
+export const CORE_MODULE_VERSION = 'JS Core 0.26.0';

package/lib/esm/utils/utils.js

@@ -85,22 +85,6 @@ export const isStringMatch = (str, pattern) => {
     }
     return false;
 };
-/**
- * @deprecated this method is not typesafe. Copy the fields manually instead,
- *             unsafe - ignores compilerOptions.strictNullChecks
- */
-export const transferExistingProperties = (fromObj, toObj, propertyMappings) => {
-    if (!toObj || !fromObj) {
-        return;
-    }
-    Object.entries(propertyMappings).forEach(([fromObjKey, toObjKey]) => {
-        if ((typeof fromObj[fromObjKey] !== 'string' && fromObj[fromObjKey] != null) ||
-            (typeof fromObj[fromObjKey] === 'string' && fromObj[fromObjKey] !== '')) {
-            // @ts-ignore
-            toObj[toObjKey] = fromObj[fromObjKey];
-        }
-    });
-};
 export const rejectOnTimeout = async (promise, ms) => {
     let id;
     const timeout = new Promise((_resolve, reject) => {

package/lib/types/action/Action.d.ts

@@ -1,6 +1,21 @@
+/**
+ * The action that should be taken by the enforcer.
+ */
 export declare enum Action {
+    /**
+     * Indicates that the request should be allowed to pass.
+     */
     PASS_REQUEST = "pass_request",
+    /**
+     * Indicates that there is not enough information to make a decision and a Risk API request should be made.
+     */
     TRIGGER_RISK_API = "trigger_risk_api",
+    /**
+     * Indicates that the request should be blocked, but no block response will be returned.
+     */
     SIMULATED_BLOCK = "simulated_block",
+    /**
+     * Indicates that the request should be blocked and a block response should be returned.
+     */
     BLOCK = "block"
 }

package/lib/types/action/ActionData.d.ts

@@ -1,4 +1,7 @@
 import { Action } from './Action';
+/**
+ * The action and reason provided by each product that influences the enforcer's behavior.
+ */
 export type ActionData = {
     /**
      * The recommended action that should be taken by the enforcer.

package/lib/types/action/ActionPriorityOrder.d.ts

@@ -1,2 +1,6 @@
 import { Action } from './Action';
+/**
+ * The priority order of actions that the enforcer should take. The array will be traversed in order,
+ * and the first action that matches a product recommendation will be taken.
+ */
 export declare const ACTION_PRIORITY_ORDER: Action[];

package/lib/types/action/Decision.d.ts

@@ -1,6 +1,15 @@
 import { Action } from './index';
 import { ProductName } from '../products';
+/**
+ * The decision made by the enforcer based on the action and reason provided by each product.
+ */
 export type Decision = {
+    /**
+     * The action that will be taken by the enforcer.
+     */
     action: Action;
+    /**
+     * A mapping of the product name to the reason for the action.
+     */
     reasons: Partial<Record<ProductName, string>>;
 };

package/lib/types/action/ProductAction.d.ts

@@ -1,5 +1,8 @@
 import { ActionData } from './ActionData';
 import { ProductName } from '../products';
+/**
+ * An object that includes the productName and its associated recommended action and reason.
+ */
 export type ProductAction = ActionData & {
     productName: ProductName;
 };

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

@@ -2,7 +2,27 @@ import { ProductName } from '../products';
 import { Decision } from './Decision';
 import { IContext } from '../context';
 import { ProductAction } from './ProductAction';
+/**
+ * Determines the final decision from the context.
+ * @param context - The request context.
+ * @returns Decision - The final action that should be taken and the associated products and reasons responsible for the decision.
+ */
 export declare const getDecisionFromContext: <Req, Res>(context: IContext<Req, Res>) => Decision;
+/**
+ * Determines all product recommended actions from the context.
+ * @param context - The request context.
+ * @returns ProductAction[] - An array of objects, representing the recommended action and reason of all relevant products.
+ */
 export declare const getProductActions: <Req, Res>(context: IContext<Req, Res>) => ProductAction[];
+/**
+ * Reduces a list of ProductActions to a single Decision, taking into consideration the ACTION_PRIORITY_ORDER.
+ * @param productActions - All possible actions from all products.
+ * @returns Decision - The final action that should be taken and the associated products and reasons responsible for the decision.
+ */
 export declare const getDecisionFromActions: (productActions: ProductAction[]) => Decision;
+/**
+ * Provided a mapping of product names to reasons, returns the reason associated with the highest priority product in the mapping.
+ * @param reasons - An object mapping any product names to their associated reasons.
+ * @returns string - The reason for the highest priority product, or 'unknown_reason' if none is found.
+ */
 export declare const getReasonForHighestPriorityProduct: (reasons: Partial<Record<ProductName, string>>) => string;