perimeterx-js-core 0.25.0 → 0.26.0

package/lib/types/activities/HttpActivityClient.d.ts

@@ -4,24 +4,80 @@ import { IHttpClient } from '../http';
 import { IActivityClient } from './IActivityClient';
 import { AsyncActivity } from './model';
 import { ILogger } from '../logger';
+/**
+ * The HttpActivityClient is responsible for sending async activities to the backend via HTTP.
+ */
 export declare class HttpActivityClient<Req, Res, Added, Removed> implements IActivityClient<Req, Res> {
     protected readonly config: IConfiguration<Req, Res, Added, Removed>;
     protected readonly httpClient: IHttpClient;
+    /**
+     * Creates an instance of HttpActivityClient.
+     * @param config
+     * @param httpClient
+     */
     constructor(config: IConfiguration<Req, Res, Added, Removed>, httpClient: IHttpClient);
+    /**
+     * Creates and sends all necessary async activities to the backend.
+     * @param context - The context containing the request (and possibly response).
+     * @returns {Promise<boolean>} - A boolean indicating if the activities were sent successfully.
+     */
     sendActivities(context: ReadonlyContext<Req, Res>): Promise<boolean>;
+    /**
+     * Creates all async activities (block, page_requested, additional_s2s) that should be sent based on the context.
+     * @param context - The context containing the request (and possibly response).
+     * @returns {AsyncActivity[]} - An array of async activities to be sent.
+     * @protected
+     */
     protected createActivities(context: ReadonlyContext<Req, Res>): AsyncActivity[];
+    /**
+     * Whether to create a block activity based on the context.
+     * @param context
+     * @protected
+     */
     protected shouldCreateBlockActivity(context: ReadonlyContext<Req, Res>): boolean;
+    /**
+     * Whether to create a page_requested activity based on the context.
+     * @param context
+     * @protected
+     */
     protected shouldCreatePageRequestedActivity(context: ReadonlyContext<Req, Res>): boolean;
+    /**
+     * Whether to create an additional_s2s activity based on the context.
+     * @param context
+     * @protected
+     */
     protected shouldCreateAdditionalS2SActivity(context: ReadonlyContext<Req, Res>): boolean;
+    /**
+     * Creates a block activity based on the context.
+     * @param context
+     * @protected
+     */
     protected createBlockActivity(context: ReadonlyContext<Req, Res>): AsyncActivity;
+    /**
+     * Creates a page_requested activity based on the context.
+     * @param context
+     * @protected
+     */
     protected createPageRequestedActivity(context: ReadonlyContext<Req, Res>): AsyncActivity;
+    /**
+     * Creates an additional_s2s activity based on the context.
+     * @param context
+     * @protected
+     */
     protected createAdditionalS2SActivity(context: ReadonlyContext<Req, Res>): AsyncActivity;
     /**
-     * Allows for expansions or alterations to the async activity if needed.
+     * Allows for expansions or alterations to an async activity if needed. This applies to all created async activities.
      * @param activity
      * @returns AsyncActivity
      * @protected
      */
     protected finalizeActivity(activity: AsyncActivity): AsyncActivity;
+    /**
+     * Sends the async activities to the backend.
+     * @param activities - The activities to be sent.
+     * @param logger - The logger instance for logging.
+     * @returns {Promise<boolean>} - A boolean indicating if the activities were sent successfully.
+     * @protected
+     */
     protected postActivities(activities: AsyncActivity[], logger: ILogger): Promise<boolean>;
 }

package/lib/types/activities/HttpBatchedActivityClient.d.ts

@@ -3,6 +3,13 @@ import { IConfiguration } from '../config';
 import { AsyncActivity } from './model';
 import { IHttpClient } from '../http';
 import { ILogger } from '../logger';
+/**
+ * The HttpBatchedActivityClient is responsible for sending async activities to the backend via HTTP in batches.
+ * It extends the HttpActivityClient class and adds functionality for batching activities.
+ *
+ * This class uses setTimeout and clearTimeout for managing the timeout for sending activities. It also exposes the stop()
+ * method to stop the timer and prevent further activity sending, which should be called on shutdown.
+ */
 export declare class HttpBatchedActivityClient<Req, Res, Added, Removed> extends HttpActivityClient<Req, Res, Added, Removed> {
     private readonly batchSize;
     private readonly timeoutMs;

package/lib/types/activities/IActivityClient.d.ts

@@ -1,9 +1,12 @@
 import { AsyncOrSync } from 'ts-essentials';
 import { ReadonlyContext } from '../context';
+/**
+ * Interface for an activity client that sends asynchronous activities to the HUMAN server.
+ */
 export interface IActivityClient<Req, Res> {
     /**
      * @param context - The request context.
-     * @returns Promise<boolean> - Whether sending the activities was successful or not.
+     * @returns AsyncOrSync<boolean> - Whether sending the activities was successful or not.
      */
     sendActivities(context: ReadonlyContext<Req, Res>): AsyncOrSync<boolean>;
 }

package/lib/types/activities/model/AsyncActivity.d.ts

@@ -1,6 +1,9 @@
 import { ActivityType } from '../ActivityType';
 import { AsyncActivityDetails } from './AsyncActivityDetails';
 import { HeaderEntry } from './HeaderEntry';
+/**
+ * The complete contents of an asynchronous activity payload.
+ */
 export type AsyncActivity = {
     type: ActivityType;
     timestamp: number;

package/lib/types/activities/model/AsyncActivityDetails.d.ts

@@ -2,6 +2,9 @@ import { BlockAction } from '../../blocker';
 import { CommonActivityDetails } from './CommonActivityDetails';
 import { RiskAdditionalData } from '../../risk_api';
 export type AsyncActivityDetails = ActivityTypeDetails & AsyncActivityCommonDetails & CommonActivityDetails;
+/**
+ * Activity details that should be included in all async activities.
+ */
 export type AsyncActivityCommonDetails = Partial<RiskAdditionalData> & {
     client_uuid?: string;
     risk_rtt?: number;
@@ -10,18 +13,27 @@ export type AsyncActivityCommonDetails = Partial<RiskAdditionalData> & {
     credentials_compromised?: boolean;
 };
 export type ActivityTypeDetails = PageRequestedActivityDetails | BlockActivityDetails | AdditionalS2SActivityDetails;
+/**
+ * Activity details that should be included in page_requested activities.
+ */
 export type PageRequestedActivityDetails = {
     pass_reason: string;
     error_message?: string;
     s2s_error_reason?: string;
     s2s_error_http_status?: number;
 };
+/**
+ * Activity details that should be included in block activities.
+ */
 export type BlockActivityDetails = {
     block_reason: string;
     block_action: BlockAction;
     block_score: number;
     simulated_block: boolean;
 };
+/**
+ * Activity details that should be included in additional_s2s activities.
+ */
 export type AdditionalS2SActivityDetails = {
     http_status_code: number;
     login_successful: boolean;

package/lib/types/activities/model/CommonActivityDetails.d.ts

@@ -4,6 +4,9 @@ import { GraphQLData } from '../../graphql';
 import { ModuleMode, VidSource } from '../../utils';
 import { CredentialIntelligenceVersion, SsoStep } from '../../products';
 import { CustomParameters } from '../../custom_parameters';
+/**
+ * Activity details that should be included in both synchronous and asynchronous activities.
+ */
 export type CommonActivityDetails = {
     request_id: string;
     module_version: string;

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

@@ -5,7 +5,21 @@ import { ProductData } from '../products';
 import { ActivityType } from './ActivityType';
 import { AdditionalS2SActivityDetails, AsyncActivity, AsyncActivityCommonDetails, AsyncActivityDetails, BlockActivityDetails, CommonActivityDetails, HeaderEntry, PageRequestedActivityDetails } from './model';
 import { CustomParameters } from '../custom_parameters';
+/**
+ * Creates an async activity object based on the provided parameters.
+ * @param activityType - The activity type to create.
+ * @param config - The enforcer configuration.
+ * @param context - The request context.
+ * @returns {AsyncActivity} - The complete async activity payload.
+ */
 export declare const createAsyncActivity: <Req, Res, Added, Removed>(activityType: ActivityType, config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => AsyncActivity;
+/**
+ * Creates activity details based on the provided parameters.
+ * @param activityType - The activity type to create.
+ * @param config - The enforcer configuration.
+ * @param context - The request context.
+ * @returns {AsyncActivityDetails} - The activity details.
+ */
 export declare const createActivityDetails: <Req, Res, Added, Removed>(activityType: ActivityType, config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => AsyncActivityDetails;
 export declare const createAsyncActivityCommonDetails: <Req, Res>(context: ReadonlyContext<Req, Res>) => AsyncActivityCommonDetails;
 export declare const createCommonActivityDetails: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => CommonActivityDetails;

package/lib/types/additional_activity_handler/AdditionalActivityHandlerUtils.d.ts

@@ -1,5 +1,11 @@
 import { ReadonlyContext } from '../context';
 import { IConfiguration } from '../config';
 export declare namespace AdditionalActivityHandlerUtils {
+    /**
+     * Invokes the additional activity handler if it is defined in the configuration.
+     * @param config - The enforcer configuration.
+     * @param context - The request context.
+     * @returns {Promise<void>} - A promise that resolves when the additional activity handler is complete.
+     */
     const invokeAdditionalActivityHandler: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>) => Promise<void>;
 }

package/lib/types/blocker/BlockerBase.d.ts

@@ -1,11 +1,32 @@
 import { ReadonlyContext } from '../context';
 import { IBlocker } from '../blocker';
 import { ContentType, IMinimalResponse, ReadonlyHeaders } from '../http';
+/**
+ * Base class for creating a block response.
+ */
 export declare abstract class BlockerBase<Req, Res> implements IBlocker<Req, Res> {
     protected readonly statusCode: number;
     protected readonly contentType: ContentType;
+    /**
+     * Creates a new instance of BlockerBase.
+     * @param contentType - The Content-Type header to be included in the HTTP block response.
+     * @param statusCode - The status code of the HTTP block response.
+     * @protected
+     */
     protected constructor(contentType: ContentType, statusCode?: number);
+    /**
+     * Creates the body of the block response.
+     * @param context - THe request context.
+     * @returns {string} - The HTTP body of the block response.
+     * @protected
+     * @abstract
+     */
     protected abstract createBlockBody(context: ReadonlyContext<Req, Res>): string;
+    /**
+     * Creates the complete HTTP block response based on the given context.
+     * @param context - The request context.
+     * @returns {IMinimalResponse} - The HTTP block response.
+     */
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
     protected createHeaders(): ReadonlyHeaders;
 }

package/lib/types/blocker/IBlocker.d.ts

@@ -1,5 +1,13 @@
 import { ReadonlyContext } from '../context';
 import { IMinimalResponse } from '../http';
+/**
+ * Interface for an entity that creates a block response.
+ */
 export interface IBlocker<Req, Res> {
+    /**
+     * Creates a block response based on the given context.
+     * @param context - The request context.
+     * @returns IMinimalResponse - The HTTP block response.
+     */
     createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
 }

package/lib/types/blocker/IConditionalBlocker.d.ts

@@ -1,7 +1,11 @@
 import { IBlocker } from './IBlocker';
 import { ReadonlyContext } from '../context';
+/**
+ * Interface for an entity that creates a block response based on a condition.
+ */
 export interface IConditionalBlocker<Req, Res> extends IBlocker<Req, Res> {
     /**
+     * Whether the blocker instance should create a block response or not.
      * @param context - The request context.
      * @returns boolean - Whether a block response should be created.
      */

package/lib/types/blocker/JsonBlockerBase.d.ts

@@ -1,8 +1,20 @@
 import { BlockerBase } from './BlockerBase';
 import { IConditionalBlocker } from './IConditionalBlocker';
 import { ReadonlyContext } from '../context';
+/**
+ * Base class for creating a block response with JSON payload.
+ *
+ * The generic argument JsonPayloadT is the specific structure of the JSON payload to be returned.
+ */
 export declare abstract class JsonBlockerBase<Req, Res, JsonPayloadT extends Record<string, any>> extends BlockerBase<Req, Res> implements IConditionalBlocker<Req, Res> {
     protected constructor();
+    /**
+     * Creates the JSON payload (JsonPayloadT) for the block response.
+     * @param context - The request context.
+     * @returns {JsonPayloadT} - The JSON payload to be included in the block response.
+     * @abstract
+     * @protected
+     */
     protected abstract createJsonPayload(context: ReadonlyContext<Req, Res>): JsonPayloadT;
     shouldBlock(context: ReadonlyContext<Req, Res>): boolean;
     protected createBlockBody(context: ReadonlyContext<Req, Res>): string;

package/lib/types/blocker/model/BlockData.d.ts

@@ -1,4 +1,7 @@
 import { BlockAction } from './BlockAction';
+/**
+ * The BlockData type represents the data needed to create a block response.
+ */
 export type BlockData = {
     appId: string;
     hostUrl: string;

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

@@ -2,5 +2,18 @@ import { IConfiguration } from '../config';
 import { ReadonlyContext } from '../context';
 import { IBase64Utils } from '../utils';
 import { BlockData } from './model';
+/**
+ * Renders the HTML template with the provided block data.
+ * @param htmlTemplate - The HTML template to be rendered. Placeholders are indicated with {{key_name}} where the key_name should be keyof BlockData.
+ * @param blockData - The block data to be used for rendering. The keys in the object should match the placeholders in the template.
+ * @returns {string} - The final HTML string. If no block data is provided, the original template is returned unchanged.
+ */
 export declare const renderHtml: (htmlTemplate: string, blockData?: BlockData) => string;
+/**
+ * Creates the block data object to be used when creating a block response.
+ * @param config - The enforcer configuration.
+ * @param context - The request context.
+ * @param base64Utils - The base64 utility functions.
+ * @returns {BlockData} - The block data object.
+ */
 export declare const createBlockData: <Req, Res, Added, Removed>(config: IConfiguration<Req, Res, Added, Removed>, context: ReadonlyContext<Req, Res>, base64Utils: IBase64Utils) => BlockData;

package/lib/types/config/ConfigurationBase.d.ts

@@ -11,6 +11,9 @@ import { ExtractGraphQLKeywordsFunction } from '../graphql';
 import { RemoteConfigData } from './remote_config';
 import { TokenVersion } from '../risk_token';
 import { CustomSnippetFunction } from '../snippet_injection';
+/**
+ * Base class for the enforcer configuration.
+ */
 export declare abstract class ConfigurationBase<Req, Res, Added, Removed extends string> implements IConfiguration<Req, Res, Added, Removed> {
     protected configParams: RequiredAllConfigurationParams<Req, Res, Added, Removed>;
     protected readonly staticConfigParams: StaticConfigurationParams<Req, Res, Added, Removed>;
@@ -18,7 +21,25 @@ export declare abstract class ConfigurationBase<Req, Res, Added, Removed extends
     protected readonly defaultConfigParams: RequiredAllConfigurationParams<Req, Res, Added, Removed>;
     protected readonly removedParams: Record<Removed, undefined>;
     private internalLogger;
+    /**
+     * Returns the module version of the enforcer.
+     *
+     * Examples:
+     *  - Akamai EdgeWorker 1.2.3
+     *  - AWS Lambda@Edge 4.5.6
+     *  - Cloudflare Worker 7.8.9
+     *
+     * Note: The JS Core version will be added automatically.
+     * @protected
+     */
     protected abstract getModuleVersion(): string;
+    /**
+     * Creates an instance of the configuration base class.
+     * @param params - The configuration parameters as provided by the customer.
+     * @param defaultParams - Default parameters for added configurations or any default core configurations that should be overridden.
+     * @param removedParams - A map of all removed (unsupported) configuration parameters set to undefined. This parameter can be generated automatically by your IDE.
+     * @protected
+     */
     protected constructor(params: StaticConfigurationParams<Req, Res, Added, Removed>, defaultParams: Required<Added> & Partial<CoreConfigurationParams<Req, Res, Added, Removed>>, removedParams: Record<Removed, undefined>);
     protected createActiveConfiguration(params: AllConfigurationParams<Req, Res, Added, Removed>, defaultParams: RequiredAllConfigurationParams<Req, Res, Added, Removed>): RequiredAllConfigurationParams<Req, Res, Added, Removed>;
     protected throwIfMissingRequiredField(params: AllConfigurationParams<Req, Res, Added, Removed>): void;
@@ -120,4 +141,5 @@ export declare abstract class ConfigurationBase<Req, Res, Added, Removed extends
     get snippetInjectionEnabled(): boolean;
     get createCustomSnippet(): CustomSnippetFunction<Req, Res, Added, Removed> | null;
     get enableBlockedUrlOnCaptchaBlockPage(): boolean;
+    get isPostEnforceEnabled(): boolean;
 }

package/lib/types/config/IConfiguration.d.ts

@@ -384,6 +384,10 @@ export interface IConfiguration<Req, Res, Added, Removed> {
      * Whether to include the request url in captcha block page
      */
     readonly enableBlockedUrlOnCaptchaBlockPage: boolean;
+    /**
+     * Whether the enforcer has access to the HTTP response, which is required for the postEnforce function call
+     */
+    readonly isPostEnforceEnabled: boolean;
     /**
      * The version of the token the enforcer is able to parse.
      */

package/lib/types/config/params/CoreConfigurationParams.d.ts

@@ -8,6 +8,9 @@ import { CustomBlockResponseHeadersHandler, CustomPreflightHandler } from '../..
 import { CustomRequestFunction } from '../CustomRequestFunction';
 import { TokenVersion } from '../../risk_token';
 import { CustomSnippetFunction } from '../../snippet_injection';
+/**
+ * The configuration parameters that can be set only via the static configuration..
+ */
 export type StaticConfigurationParamsOnly = {
     px_app_id: string;
     px_cookie_secret: string | string[];
@@ -16,6 +19,9 @@ export type StaticConfigurationParamsOnly = {
     px_remote_config_auth_token?: string;
     px_remote_config_id?: string;
 };
+/**
+ * The configuration parameters that can be set only via the remote configuration.
+ */
 export type RemoteConfigurationParamsOnly = {
     px_remote_config_enabled?: boolean;
     px_remote_config_version?: number;
@@ -25,20 +31,32 @@ export type RemoteConfigurationParamsOnly = {
     px_filter_by_route_regex?: string[];
     px_graphql_routes_regex?: string[];
 };
+/**
+ * The configuration parameters relevant to the batched activities feature.
+ */
 export type BatchedActivitiesConfigParamsOnly = {
     px_max_activity_batch_size?: number;
     px_batch_activities_timeout_ms?: number;
 };
+/**
+ * The configuration parameters relevant to supporting Token (Cookie) V3.
+ */
 export type TokenV3ConfigurationParamsOnly = {
     px_token_version?: `${TokenVersion}`;
     px_blocking_score?: number;
     px_risk_cookie_min_iterations?: number;
     px_risk_cookie_max_iterations?: number;
 };
+/**
+ * The configuration parameters relevant to the snippet injection feature.
+ */
 export type SnippetInjectionParamsOnly<Req, Res, Added, Removed> = {
     px_snippet_injection_enabled?: boolean;
     px_create_custom_snippet?: CustomSnippetFunction<Req, Res, Added, Removed> | null;
 };
+/**
+ * The configuration parameters that can be set via either the static or remote configuration.
+ */
 export type CommonConfigurationParams<Req, Res, Added, Removed> = TokenV3ConfigurationParamsOnly & BatchedActivitiesConfigParamsOnly & SnippetInjectionParamsOnly<Req, Res, Added, Removed> & {
     px_s2s_timeout?: number;
     px_backend_url?: string;
@@ -112,4 +130,7 @@ export type CommonConfigurationParams<Req, Res, Added, Removed> = TokenV3Configu
     px_custom_is_filtered_request?: CustomRequestFunction<Req> | null;
     px_extract_graphql_keywords?: ExtractGraphQLKeywordsFunction | null;
 };
+/**
+ * All configuration parameters supported by JS Core.
+ */
 export type CoreConfigurationParams<Req, Res, Added, Removed> = StaticConfigurationParamsOnly & RemoteConfigurationParamsOnly & CommonConfigurationParams<Req, Res, Added, Removed>;

package/lib/types/config/params/RemoteConfigurationParams.d.ts

@@ -1,2 +1,5 @@
 import { CoreConfigurationParams, StaticConfigurationParamsOnly } from './CoreConfigurationParams';
+/**
+ * All configurations that can be set via the remote configurations, taking into account any added or removed configurations.
+ */
 export type RemoteConfigurationParams<Req, Res, Added, Removed> = Omit<CoreConfigurationParams<Req, Res, Added, Removed>, keyof StaticConfigurationParamsOnly>;

package/lib/types/config/params/StaticConfigurationParams.d.ts

@@ -1,3 +1,6 @@
 import { RemoteConfigurationParamsOnly } from './CoreConfigurationParams';
 import { CreateHumanSecurityConfigurationParams } from './AllConfigurationParams';
+/**
+ * All configurations that can be set via the static configurations, taking into account any added or removed configurations.
+ */
 export type StaticConfigurationParams<Req, Res, Added = {}, Removed = never> = Omit<CreateHumanSecurityConfigurationParams<Req, Res, Added, Removed>, keyof RemoteConfigurationParamsOnly>;

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

@@ -13,6 +13,10 @@ type RequestDataJson<Req> = Omit<RequestData<Req>, 'url' | 'request'> & {
     url: string;
     request: undefined;
 };
+/**
+ * A JSON representation of the request context data. Used when the context must be serialized to JSON in order to
+ * preserve it between the `enforce()` and `postEnforce()` calls.
+ */
 export type ContextJson<Req = unknown, Res = unknown> = {
     readonly requestId: string;
     readonly isMobile: boolean;

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

@@ -17,6 +17,10 @@ export type DefaultContextOptions = {
     requestIdGenerator: IRequestIdGenerator;
     urlUtils: IUrlUtils;
 };
+/**
+ * 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> {
     readonly requestId: string;
     readonly tokenOrigin: TokenOrigin;

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

@@ -12,6 +12,11 @@ import { CustomParameters } from '../custom_parameters';
 import { GraphQLData } from '../graphql';
 import { IContext, RemoteConfigUpdateData, RequestData, RiskApiData, ServerData, TlsData, TokenData } from './interfaces';
 import { ContextJson } from './ContextJson';
+/**
+ * Implements the `IContext` interface based an already serialized `ContextJson`. This class does not extract data from the
+ * 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> {
     readonly isMobile: boolean;
     readonly remoteConfigUpdateData: RemoteConfigUpdateData;

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

@@ -1,4 +1,7 @@
 import { IS_HYPESALE_PARAM_NAME } from '../products';
+/**
+ * Custom parameters defined by the user and included on all HUMAN backend requests.
+ */
 export type CustomParameters = {
     custom_param1?: any;
     custom_param2?: any;

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

@@ -2,16 +2,20 @@ import { AsyncOrSync } from 'ts-essentials';
 import { IConfiguration, IRemoteConfigManager } from '../config';
 import { IContext } from '../context';
 import { IMinimalResponse, IOutgoingResponse } from '../http';
-import { IPhase } from '../phase';
+import { IFlow } from '../flow';
 import { IActivityClient } from '../activities';
-import { IEnforcer } from './IEnforcer';
 import { EnforcerOptions } from './EnforcerOptions';
-export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[], PostEnforceArgs extends any[], Added, Removed> implements IEnforcer<EnforceArgs, PostEnforceArgs, Promise<null | Res>, Promise<void>> {
+import { IEnforcer } from './IEnforcer';
+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>;
-    protected readonly filterFlow: IPhase<Req, Res>;
-    protected readonly enforceFlow: IPhase<Req, Res>;
-    protected readonly postEnforceFlow: IPhase<Req, Res>;
-    protected readonly endEnforcerFlow: IPhase<Req, Res>;
+    protected readonly filterFlow: IFlow<Req, Res>;
+    protected readonly enforceFlow: IFlow<Req, Res>;
+    protected readonly postEnforceFlow: IFlow<Req, Res> | null;
+    protected readonly endEnforcerFlow: IFlow<Req, Res>;
     protected readonly activityClient: IActivityClient<Req, Res>;
     protected readonly remoteConfigManager: IRemoteConfigManager<Req, Res> | null;
     /**
@@ -58,10 +62,42 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @protected
      */
     protected constructor(config: IConfiguration<Req, Res, Added, Removed>, options: EnforcerOptions<Req, Res, Added, Removed>);
-    protected createFilterFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IPhase<Req, Res>;
-    protected createPostEnforceFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IPhase<Req, Res>;
-    protected createEnforceFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IPhase<Req, Res>;
-    protected createEndEnforcerFlow(config: IConfiguration<Req, Res, Added, Removed>, initializationBlock: Required<EnforcerOptions<Req, Res, Added, Removed>>): IPhase<Req, Res>;
+    /**
+     * 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.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @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>;
+    /**
+     * 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.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @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;
+    /**
+     * 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.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @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>;
+    /**
+     * 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.
+     * @param config - The configuration object.
+     * @param initializationBlock - All entities necessary for the enforcer to function.
+     * @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>;
     /**
      * The central function that triggers enforcement on the incoming request.
      * @param args - The EnforceArgs required to enforce the incoming request.
@@ -82,5 +118,5 @@ export declare abstract class EnforcerBase<Req, Res, EnforceArgs extends any[],
      * @returns Promise<void> - The response parameter will be modified as needed
      */
     postEnforce(...args: PostEnforceArgs): Promise<void>;
-    sendAdditionalS2SActivity(...args: PostEnforceArgs): Promise<void>;
+    protected sendAdditionalS2SActivity(...args: PostEnforceArgs): Promise<void>;
 }

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

@@ -1,4 +1,3 @@
-export interface IEnforcer<EnforceArgs extends any[], PostEnforceArgs extends any[], EnforceResult, PostEnforceResult> {
+export interface IEnforcer<EnforceArgs extends any[], EnforceResult> {
     enforce(...args: EnforceArgs): EnforceResult;
-    postEnforce(...args: PostEnforceArgs): PostEnforceResult;
 }

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

@@ -0,0 +1,3 @@
+export interface IPostEnforcer<PostEnforceArgs extends any[], PostEnforceResult> {
+    postEnforce(...args: PostEnforceArgs): PostEnforceResult;
+}

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

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

package/lib/types/first_party/IFirstParty.d.ts

@@ -4,7 +4,7 @@ import { FirstPartyData } from './FirstPartyData';
 export interface IFirstParty<Req, Res> {
     /**
      * @param context - The request context
-     * @returns Promise<FirstPartyData | null> - If the request is not a first party request, it will return null.
+     * @returns {AsyncOrSync<FirstPartyData|null>} - If the request is a first party request, it will return a FirstPartyData object. Otherwise, it will return null.
      */
     handleFirstPartyRequest(context: ReadonlyContext<Req, Res>): AsyncOrSync<FirstPartyData | null>;
 }

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

@@ -0,0 +1,8 @@
+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 {};

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

@@ -0,0 +1,8 @@
+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 {};