perimeterx-js-core 0.5.0 → 0.6.0

package/lib/context/DefaultContext.d.ts

@@ -0,0 +1,46 @@
+import { IConfiguration } from '../config';
+import { BlockAction } from '../blocker';
+import { CustomParameters } from '../custom_parameters';
+import { PXDE } from '../pxde';
+import { PXHD } from '../pxhd';
+import { TokenOrigin } from '../risk_token';
+import { IIncomingRequest, IOutgoingResponse, ReadonlyHeaders } from '../http';
+import { ICookieParser, IRequestIdGenerator, VidSource } from '../utils';
+import { IContext, RequestData, RiskApiData, ServerData, TlsData, TokenData } from './interfaces';
+import { ProductData, ProductName } from '../products';
+import { Action } from '../action';
+export declare type DefaultContextOptions = {
+    cookieParser?: ICookieParser;
+    requestIdGenerator: IRequestIdGenerator;
+};
+export declare class DefaultContext<Req, Res> implements IContext<Req, Res> {
+    readonly requestId: string;
+    readonly tokenOrigin: TokenOrigin;
+    readonly requestData: RequestData<Req>;
+    readonly tokenData: TokenData<Req, Res>;
+    readonly riskApiData: RiskApiData;
+    readonly tlsData: TlsData;
+    readonly serverData: ServerData;
+    readonly productData: ProductData;
+    uuid: string;
+    vid?: string;
+    vidSource?: VidSource;
+    action: Action;
+    reasons?: Partial<Record<ProductName, string>>;
+    score?: number;
+    blockAction?: BlockAction;
+    pxhd?: PXHD;
+    pxde?: PXDE;
+    pxdeVerified?: boolean;
+    customParameters?: CustomParameters;
+    response?: IOutgoingResponse<Res>;
+    protected readonly config: IConfiguration<Req, Res>;
+    constructor(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, options: DefaultContextOptions);
+    get isMobile(): boolean;
+    protected createRequestData(config: IConfiguration<Req, Res>, request: IIncomingRequest<Req>, cookieParser?: ICookieParser): RequestData<Req>;
+    protected static getCookies(cookieParser: ICookieParser, ...cookieHeaderValues: string[]): Record<string, string>;
+    protected extractUserAgentFromHeader(config: IConfiguration<Req, Res>, headers: ReadonlyHeaders): string;
+    protected extractIpFromHeader(config: IConfiguration<Req, Res>, headers: ReadonlyHeaders): string;
+    protected getTokenOrigin(request: IIncomingRequest<Req>): TokenOrigin;
+    protected setCookiesOnContext(): void;
+}

package/lib/context/DefaultContext.js

@@ -0,0 +1,82 @@
+import { BlockAction } from '../blocker';
+import { PXHDSource } from '../pxhd';
+import { TokenOrigin, TokenParseResult } from '../risk_token';
+import { RiskApiCallResult } from '../risk_api';
+import { COOKIE_HEADER_NAME, toReadonlyHeaders, USER_AGENT_HEADER_NAME, } from '../http';
+import { StringSplitCookieParser, getDecodedUrl, PXHD_COOKIE_NAME, PXVID_COOKIE_NAME, X_PX_AUTHORIZATION_HEADER_NAME, } from '../utils';
+export class DefaultContext {
+    constructor(config, request, options) {
+        this.config = config;
+        this.tokenData = {
+            tokenParseResult: TokenParseResult.NONE,
+        };
+        this.riskApiData = {
+            riskApiCallResult: RiskApiCallResult.NONE,
+        };
+        this.tlsData = {};
+        this.serverData = {};
+        this.productData = {};
+        this.requestId = options.requestIdGenerator.generateRequestId();
+        this.blockAction = BlockAction.CAPTCHA;
+        this.pxdeVerified = false;
+        this.requestData = this.createRequestData(config, request, options.cookieParser);
+        this.tokenOrigin = this.getTokenOrigin(request);
+        if (!this.isMobile) {
+            this.setCookiesOnContext();
+        }
+    }
+    get isMobile() {
+        return this.tokenOrigin === TokenOrigin.HEADER;
+    }
+    createRequestData(config, request, cookieParser = new StringSplitCookieParser()) {
+        const url = getDecodedUrl(request.url);
+        const method = request.method;
+        const headers = request.headers;
+        const cookies = DefaultContext.getCookies(cookieParser, request.headers.get(COOKIE_HEADER_NAME), request.headers.get(config.customCookieHeader));
+        const requestCookieNames = Object.keys(cookies);
+        const readOnlyHeaders = toReadonlyHeaders(headers);
+        const userAgent = this.extractUserAgentFromHeader(config, readOnlyHeaders);
+        const ip = this.extractIpFromHeader(config, readOnlyHeaders) || request.clientIP;
+        return { url, method, headers: readOnlyHeaders, cookies, ip, userAgent, requestCookieNames, request };
+    }
+    static getCookies(cookieParser, ...cookieHeaderValues) {
+        const cookies = {};
+        cookieHeaderValues.forEach((value) => {
+            Object.assign(cookies, value ? cookieParser.parseCookies(value) : null);
+        });
+        return cookies;
+    }
+    extractUserAgentFromHeader(config, headers) {
+        var _a;
+        let userAgent = ((_a = headers[USER_AGENT_HEADER_NAME]) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        if (userAgent.length > config.userAgentMaxLength) {
+            userAgent = userAgent.substring(0, config.userAgentMaxLength);
+        }
+        return userAgent;
+    }
+    extractIpFromHeader(config, headers) {
+        let ip;
+        config.ipHeaders.some((ipHeader) => {
+            var _a;
+            const headerValue = (_a = headers[ipHeader]) === null || _a === void 0 ? void 0 : _a[0];
+            if (headerValue) {
+                ip = headerValue;
+                return true;
+            }
+        });
+        return ip;
+    }
+    getTokenOrigin(request) {
+        return request.headers.get(X_PX_AUTHORIZATION_HEADER_NAME) ? TokenOrigin.HEADER : TokenOrigin.COOKIE;
+    }
+    setCookiesOnContext() {
+        this.vid = this.requestData.cookies[PXVID_COOKIE_NAME] || '';
+        const pxhdCookie = this.requestData.cookies[PXHD_COOKIE_NAME] || '';
+        if (pxhdCookie) {
+            this.pxhd = {
+                value: pxhdCookie,
+                source: PXHDSource.COOKIE,
+            };
+        }
+    }
+}

package/lib/context/index.d.ts

@@ -1,4 +1,2 @@
-export * from './IContext';
-export * from './ContextBase';
-export * from './DefaultTokenV2Context';
-export * from './DefaultTokenV3Context';
+export * from './interfaces';
+export * from './DefaultContext';

package/lib/context/index.js

@@ -1,20 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./IContext"), exports);
-__exportStar(require("./ContextBase"), exports);
-__exportStar(require("./DefaultTokenV2Context"), exports);
-__exportStar(require("./DefaultTokenV3Context"), exports);
+export * from './interfaces';
+export * from './DefaultContext';

package/lib/context/interfaces/IContext.d.ts

@@ -0,0 +1,111 @@
+import { VidSource } from '../../utils';
+import { BlockAction } from '../../blocker';
+import { CustomParameters } from '../../custom_parameters';
+import { PXDE } from '../../pxde';
+import { TokenOrigin } from '../../risk_token';
+import { RequestData } from './RequestData';
+import { RiskApiData } from './RiskApiData';
+import { TlsData } from './TlsData';
+import { ServerData } from './ServerData';
+import { TokenData } from './TokenData';
+import { ProductData, ProductName } from '../../products';
+import { Action } from '../../action';
+import { IOutgoingResponse } from '../../http';
+import { GraphQLData } from '../../graphql';
+import { PXHD } from '../../pxhd';
+export interface IContext<Req, Res> {
+    /**
+     * A UUID generated in the enforcer unique to each HTTP request.
+     */
+    readonly requestId: string;
+    /**
+     * Whether the request is from a mobile device.
+     */
+    readonly isMobile: boolean;
+    /**
+     * An object containing details about the original HTTP request.
+     */
+    readonly requestData: RequestData<Req>;
+    /**
+     * An object containing details about the token.
+     */
+    readonly tokenData: TokenData<Req, Res>;
+    /**
+     * An object containing details about the risk API data.
+     */
+    readonly riskApiData: RiskApiData;
+    /**
+     * An object containing details about the TLS metadata of the HTTP request.
+     */
+    readonly tlsData: TlsData;
+    /**
+     * An object containing details about the server on which the enforcer is running.
+     */
+    readonly serverData: ServerData;
+    /**
+     * An object containing data related to specific products.
+     */
+    readonly productData: ProductData;
+    /**
+     * The client UUID.
+     */
+    uuid: string;
+    /**
+     * The visitor ID, unique to the end-user.
+     */
+    vid?: string;
+    /**
+     * A string representing where the visitor ID was obtained.
+     */
+    vidSource?: VidSource;
+    /**
+     * The origin of the risk token, indicating whether the request originates from
+     * a web browser ('cookie') or from the mobile SDK ('header').
+     */
+    tokenOrigin: TokenOrigin;
+    /**
+     * The risk score retrieved from either the risk cookie or risk API request. This should be a value
+     * between 0 and 100 (inclusive), with 100 representing a bot.
+     */
+    score?: number;
+    /**
+     * The action to be taken by the enforcer.
+     */
+    action: Action;
+    /**
+     * The products that suggested the decided action and their corresponding reasons for doing so.
+     */
+    reasons?: Partial<Record<ProductName, string>>;
+    /**
+     * The type of block page to present in case of a block.
+     */
+    blockAction?: BlockAction;
+    /**
+     * The PXHD (PerimeterX Hashed Data) cookie value, if it exists on the request.
+     */
+    pxhd?: PXHD;
+    /**
+     * The PXDE (PerimeterX Data Enrichment) object, if it was parsed from
+     * the PXDE cookie or received on the risk response.
+     */
+    pxde?: PXDE;
+    /**
+     * Whether the HMAC on the PXDE cookie has been validated. If the PXDE object
+     * was received on the risk response, this value will be true.
+     */
+    pxdeVerified?: boolean;
+    /**
+     * An object with 10 custom parameters that the customer can set and define. These
+     * custom parameters will be added to the activities sent to the collector.
+     */
+    customParameters?: CustomParameters;
+    /**
+     * An array of objects with information about the different GraphQL operations
+     * parsed from the request.
+     */
+    graphqlData?: GraphQLData[];
+    /**
+     * The response from the origin server.
+     */
+    response?: IOutgoingResponse<Res>;
+}

package/lib/context/interfaces/IContext.js

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

package/lib/context/interfaces/MobileData.d.ts

@@ -0,0 +1,23 @@
+import { IToken, MobileError, TokenParseResult } from '../../risk_token';
+export declare type MobileData<Req, Res> = {
+    /**
+     * The mobile error sent on the X-PX-Authorization header for mobile requests.
+     */
+    mobileError?: MobileError;
+    /**
+     * An interface representing the original token sent on the X-PX-Original-Token header for mobile requests.
+     */
+    originalToken?: IToken<Req, Res>;
+    /**
+     * The bypass reason from the X-PX-Bypass-Reason header for mobile requests.
+     */
+    bypassReason?: string;
+    /**
+     * The result of parsing the original token.
+     */
+    originalTokenParseResult?: TokenParseResult;
+    /**
+     * The JSON string of the original token if one was sent on the mobile request.
+     */
+    decodedOriginalToken?: string;
+};

package/lib/context/interfaces/MobileData.js

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

package/lib/context/interfaces/ReadonlyContext.d.ts

@@ -0,0 +1,3 @@
+import { DeepReadonly } from 'ts-essentials';
+import { IContext } from './IContext';
+export declare type ReadonlyContext<Req, Res> = DeepReadonly<IContext<Req, Res>>;

package/lib/context/interfaces/ReadonlyContext.js

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

package/lib/context/interfaces/RequestData.d.ts

@@ -0,0 +1,41 @@
+import { HttpMethod, IIncomingRequest, IURL, ReadonlyHeaders } from '../../http';
+export declare type RequestData<Req> = {
+    /**
+     * The request URL.
+     */
+    url: IURL;
+    /**
+     * The request method, capitalized.
+     */
+    method: HttpMethod;
+    /**
+     * An object representing the request headers. The keys are the header names (all lowercase) and the values
+     * are arrays of strings, with each string representing one value associated with the header name.
+     */
+    headers: ReadonlyHeaders;
+    /**
+     * An object representing the request cookies. The keys are the cookie
+     * names and the values are the cookie values.
+     */
+    cookies: Record<string, string>;
+    /**
+     * An array of the cookie names present on the request.
+     */
+    requestCookieNames: string[];
+    /**
+     * The user agent header on the request.
+     */
+    userAgent: string;
+    /**
+     * The IP of the request.
+     */
+    ip: string;
+    /**
+     * An interface representing the original HTTP request.
+     */
+    request: IIncomingRequest<Req>;
+    /**
+     * The HTTP version used for the request (e.g., 0.9, 1.0, 1.1, 2.0).
+     */
+    httpVersion?: string;
+};

package/lib/context/interfaces/RequestData.js

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

package/lib/context/interfaces/RiskApiData.d.ts

@@ -0,0 +1,27 @@
+import { IRiskResponse, S2SErrorReason, RiskApiCallResult } from '../../risk_api';
+export declare type RiskApiData = {
+    /**
+     * The result of the risk API call.
+     */
+    riskApiCallResult: RiskApiCallResult;
+    /**
+     * An interface representing the risk API response.
+     */
+    riskResponse?: IRiskResponse;
+    /**
+     * The risk API round trip time in milliseconds.
+     */
+    riskRtt?: number;
+    /**
+     * The reason for the error during the risk API call if an error occurred.
+     */
+    errorReason?: S2SErrorReason;
+    /**
+     * The HTTP response status that was received for the risk API call if an error occurred.
+     */
+    errorHttpStatus?: number;
+    /**
+     * An error message that contains more details about the risk API error if an error occurred.
+     */
+    errorMessage?: string;
+};

package/lib/context/interfaces/RiskApiData.js

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

package/lib/context/interfaces/ServerData.d.ts

@@ -0,0 +1,18 @@
+export declare type ServerData = {
+    /**
+     * The operating system platform.
+     */
+    osName?: string;
+    /**
+     * The server region the request hit.
+     */
+    region?: string;
+    /**
+     * The host name of the operating system.
+     */
+    nodeName?: string;
+    /**
+     * The name or code associated with the server PoP/datacenter.
+     */
+    datacenter?: string;
+};

package/lib/context/interfaces/ServerData.js

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

package/lib/context/interfaces/TlsData.d.ts

@@ -0,0 +1,30 @@
+export declare type TlsData = {
+    /**
+     * The TLS version used for the HTTPS request (e.g., 1.2, 1.3).
+     */
+    tlsProtocol?: string;
+    /**
+     * The Server Name Indication (SNI) the client sent in the TLS Client Hello packet of the HTTPS request.
+     */
+    tlsServer?: string;
+    /**
+     * The name of the TLS cipher used to encrypt the HTTPS request.
+     */
+    tlsCipher?: string;
+    /**
+     * The hash used to encrypt the HTTPS request.
+     */
+    tlsCiphersSha?: string;
+    /**
+     * The hash of the TLS extension identifiers sent from the client as part of the TLS handshake
+     */
+    tlsExtensionSha?: string;
+    /**
+     * The client's preferred TLS ciphers for the HTTPS request.
+     */
+    tlsPreferredCiphers?: string;
+    /**
+     * The JA3 fingerprint computed from the TLS Client Hello packet of th HTTPS request.
+     */
+    tlsJa3Fingerprint?: string;
+};

package/lib/context/interfaces/TlsData.js

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

package/lib/context/interfaces/TokenData.d.ts

@@ -0,0 +1,16 @@
+import { IToken, TokenParseResult } from '../../risk_token';
+import { MobileData } from './MobileData';
+export declare type TokenData<Req, Res> = {
+    /**
+     * The result of token parsing.
+     */
+    tokenParseResult: TokenParseResult;
+    /**
+     * An interface representing the risk token.
+     */
+    token?: IToken<Req, Res>;
+    /**
+     * An object containing details about the mobile data if the request was made from a mobile device.
+     */
+    mobileData?: MobileData<Req, Res>;
+};

package/lib/context/interfaces/TokenData.js

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

package/lib/context/interfaces/index.d.ts

@@ -0,0 +1,8 @@
+export * from './RequestData';
+export * from './RiskApiData';
+export * from './MobileData';
+export * from './TokenData';
+export * from './TlsData';
+export * from './ServerData';
+export * from './IContext';
+export * from './ReadonlyContext';

package/lib/context/interfaces/index.js

@@ -0,0 +1,8 @@
+export * from './RequestData';
+export * from './RiskApiData';
+export * from './MobileData';
+export * from './TokenData';
+export * from './TlsData';
+export * from './ServerData';
+export * from './IContext';
+export * from './ReadonlyContext';

package/lib/cors/CustomBlockResponseHeadersHandler.d.ts

@@ -0,0 +1,2 @@
+import { ReadonlyHeaders } from '../http';
+export declare type CustomBlockResponseHeadersHandler<Req> = (request: Req) => ReadonlyHeaders | Promise<ReadonlyHeaders>;

package/lib/cors/CustomBlockResponseHeadersHandler.js

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

package/lib/cors/CustomPreflightHandler.d.ts

@@ -0,0 +1,2 @@
+import { IMinimalResponse } from '../http';
+export declare type CustomPreflightHandler<Req> = (request: Req) => IMinimalResponse | Promise<IMinimalResponse>;

package/lib/cors/CustomPreflightHandler.js

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

package/lib/cors/DefaultCors.d.ts

@@ -0,0 +1,15 @@
+import { ICors } from './ICors';
+import { IConfiguration } from '../config';
+import { ReadonlyContext } from '../context';
+import { ReadonlyHeaders, IMinimalResponse } from '../http';
+export declare class DefaultCors<Req, Res> implements ICors<Req, Res> {
+    private readonly customBlockResponseHeaders;
+    private readonly customPreflightHandler;
+    private readonly logger;
+    constructor(config: IConfiguration<Req, Res>);
+    isPreflightRequest(context: ReadonlyContext<Req, Res>): boolean;
+    runPreflightCustomHandler(context: ReadonlyContext<Req, Res>): Promise<IMinimalResponse>;
+    isCorsRequest(context: ReadonlyContext<Req, Res>): boolean;
+    getCorsBlockHeaders(context: ReadonlyContext<Req, Res>): Promise<ReadonlyHeaders>;
+    getDefaultCorsHeaders(context: ReadonlyContext<Req, Res>): ReadonlyHeaders;
+}

package/lib/cors/DefaultCors.js

@@ -0,0 +1,59 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ACCESS_CONTROL_REQUEST_METHOD_HEADER, ORIGIN_HEADER } from './constants';
+import { HttpMethod } from '../http';
+export class DefaultCors {
+    constructor(config) {
+        this.customBlockResponseHeaders = config.corsCreateCustomBlockResponseHeaders;
+        this.customPreflightHandler = config.corsCustomPreflightHandler;
+        this.logger = config.logger;
+    }
+    isPreflightRequest(context) {
+        const { requestData } = context;
+        return !!(requestData.method.toUpperCase() === HttpMethod.OPTIONS &&
+            requestData.headers[ORIGIN_HEADER] &&
+            requestData.headers[ACCESS_CONTROL_REQUEST_METHOD_HEADER]);
+    }
+    runPreflightCustomHandler(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.customPreflightHandler && typeof this.customPreflightHandler === 'function') {
+                try {
+                    return yield this.customPreflightHandler(context.requestData.request.getUnderlyingRequest());
+                }
+                catch (e) {
+                    this.logger.debug(`Exception occurred while executing custom preflight handler: ${e}`);
+                }
+            }
+            return null;
+        });
+    }
+    isCorsRequest(context) {
+        return !!context.requestData.headers[ORIGIN_HEADER];
+    }
+    getCorsBlockHeaders(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.customBlockResponseHeaders && typeof this.customBlockResponseHeaders === 'function') {
+                try {
+                    return yield this.customBlockResponseHeaders(context.requestData.request.getUnderlyingRequest());
+                }
+                catch (e) {
+                    this.logger.debug(`Exception occurred in px_cors_create_custom_block_response_headers custom function: ${e}`);
+                }
+            }
+            return this.getDefaultCorsHeaders(context);
+        });
+    }
+    getDefaultCorsHeaders(context) {
+        return {
+            'Access-Control-Allow-Origin': context.requestData.headers[ORIGIN_HEADER],
+            'Access-Control-Allow-Credentials': ['true'],
+        };
+    }
+}

package/lib/cors/ICors.d.ts

@@ -0,0 +1,26 @@
+import { ReadonlyContext } from '../context';
+import { IMinimalResponse } from '../http';
+import { ReadonlyHeaders } from '../http';
+export interface ICors<Req, Res> {
+    /**
+     * @param context
+     * @returns boolean - Whether the request is preflight.
+     */
+    isPreflightRequest(context: ReadonlyContext<Req, Res>): boolean;
+    /**
+     * @param context- The request context.
+     * @returns IMinimalResponse- The response that return to client for preflight request.
+     */
+    runPreflightCustomHandler(context: ReadonlyContext<Req, Res>): Promise<IMinimalResponse> | null;
+    /**
+     * @param context- The request context.
+     * @returns boolean - Whether the request is CORS.
+     */
+    isCorsRequest(context: ReadonlyContext<Req, Res>): boolean;
+    /**
+     *
+     * @param context - The request context.
+     * @returns ReadOnlyHeaders - headers to be added to the block response.
+     */
+    getCorsBlockHeaders(context: ReadonlyContext<Req, Res>): Promise<ReadonlyHeaders>;
+}

package/lib/cors/ICors.js

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

package/lib/cors/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ORIGIN_HEADER = "origin";
+export declare const ACCESS_CONTROL_REQUEST_METHOD_HEADER = "access-control-request-method";

package/lib/cors/constants.js

@@ -0,0 +1,2 @@
+export const ORIGIN_HEADER = 'origin';
+export const ACCESS_CONTROL_REQUEST_METHOD_HEADER = 'access-control-request-method';

package/lib/cors/index.d.ts

@@ -0,0 +1,5 @@
+export { ICors } from './ICors';
+export { CustomPreflightHandler } from './CustomPreflightHandler';
+export { CustomBlockResponseHeadersHandler } from './CustomBlockResponseHeadersHandler';
+export { DefaultCors } from './DefaultCors';
+export * from './constants';

package/lib/cors/index.js

@@ -0,0 +1,2 @@
+export { DefaultCors } from './DefaultCors';
+export * from './constants';

package/lib/custom_parameters/CustomParameters.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/custom_parameters/CustomParametersFunction.d.ts

@@ -1,4 +1,3 @@
 import { ConfigurationParams } from '../config';
 import { CustomParameters } from './CustomParameters';
-import { IIncomingRequest } from '../http/interfaces/IIncomingRequest';
-export declare type CustomParametersFunction = (config: ConfigurationParams, httpRequest: IIncomingRequest) => CustomParameters | Promise<CustomParameters>;
+export declare type CustomParametersFunction<Req, Res> = (config: ConfigurationParams<Req, Res>, request: Req) => CustomParameters | Promise<CustomParameters>;

package/lib/custom_parameters/CustomParametersFunction.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/custom_parameters/CustomParametersUtils.d.ts

@@ -1,7 +1,7 @@
 import { IConfiguration } from '../config';
-import { IContext } from '../context';
+import { ReadonlyContext } from '../context';
 import { CustomParameters } from './CustomParameters';
 export declare namespace CustomParametersUtils {
-    const handleCustomParameters: (config: IConfiguration, context: IContext) => Promise<void>;
+    const createCustomParameters: <Req, Res>(config: IConfiguration<Req, Res>, context: ReadonlyContext<Req, Res>) => Promise<CustomParameters | null>;
     const normalizeCustomParams: (customParameters: Record<string, any>) => CustomParameters;
 }