perimeterx-js-core 0.1.0

package/lib/config/IConfiguration.d.ts

@@ -0,0 +1,172 @@
+import { ModuleMode } from '../utils';
+import { ILogger, LoggerSeverity } from '../logger';
+import { CustomParametersFunction } from '../custom_parameters';
+import { AdditionalActivityHandler } from '../additional_activity_handler';
+import { ConfigurationParams } from './ConfigurationParams';
+export interface IConfiguration<ParamsType extends ConfigurationParams = ConfigurationParams> {
+    /**
+     * The application ID.
+     */
+    readonly appId: string;
+    /**
+     * The cookie secret used to decrypt the risk cookie.
+     */
+    readonly cookieSecret: string;
+    /**
+     * The token used to authenticate with the Human/PerimeterX backend.
+     */
+    readonly authToken: string;
+    /**
+     * Whether the enforcer is enabled.
+     */
+    readonly moduleEnabled: boolean;
+    /**
+     * The timeout for risk API calls, in milliseconds.
+     */
+    readonly s2sTimeout: number;
+    /**
+     * An interface used to log enforcer debug and error messages.
+     */
+    readonly logger: ILogger;
+    /**
+     * The logger severity level of the logger.
+     */
+    readonly loggerSeverity: LoggerSeverity;
+    /**
+     * The default module mode of the enforcer.
+     */
+    readonly moduleMode: ModuleMode;
+    /**
+     * An array of header names to remove from all requests to Human/PerimeterX backends.
+     */
+    readonly sensitiveHeaders: string[];
+    /**
+     * An array of agents that should not go through the enforcer flow.
+     */
+    readonly filteredUserAgents: string[];
+    /**
+     * An array of regular expressions or prefixes of routes that should not go through the enforcer flow.
+     */
+    readonly filteredRoutes: string[];
+    /**
+     * An array of extensions that should not go through the enforcer flow.
+     */
+    readonly filteredExtensions: string[];
+    /**
+     * An array of IP addresses that should not go through the enforcer flow.
+     */
+    readonly filteredIps: string[];
+    /**
+     * An array of HTTP methods that should not go through the enforcer flow.
+     */
+    readonly filteredHttpMethods: string[];
+    /**
+     * An array of header names from which to extract the request IP.
+     */
+    readonly ipHeaders: string[];
+    /**
+     * An array of regular expressions or prefixes of routes that should go through the enforcer flow
+     * in active_blocking rather than monitor mode.
+     */
+    readonly enforcedRoutes: string[];
+    /**
+     * An array of regular expressions or prefixes of routes that should trigger a risk API call
+     * even if a valid, unexpired, low-score risk cookie is present.
+     */
+    readonly sensitiveRoutes: string[];
+    /**
+     * An array of regular expressions or prefixes of routes that should go through the enforcer flow
+     * in monitor rather than active_blocking mode.
+     */
+    readonly monitoredRoutes: string[];
+    /**
+     * The name of the header that contains the PX cookies.
+     */
+    readonly customCookieHeader: string;
+    /**
+     * Whether the enforcer should respond to first party endpoints.
+     */
+    readonly firstPartyEnabled: boolean;
+    /**
+     * The prefix to use for first party requests.
+     */
+    readonly firstPartyPrefix: string;
+    /**
+     * Whether the enforcer should return a JSON block response in cases where the
+     * Accept header on the request includes application/json.
+     */
+    readonly advancedBlockingResponseEnabled: boolean;
+    /**
+     * The name of the header which, if present on the request with a value of 1, should
+     * trigger the request to go through the enforcer flow in active_blocking mode.
+     */
+    readonly bypassMonitorHeader: string;
+    /**
+     * The origin the enforcer will use to make risk API requests.
+     */
+    readonly backendScoreApiUrl: string;
+    /**
+     * The origin the enforcer will use to proxy captcha script requests.
+     */
+    readonly backendCaptchaUrl: string;
+    /**
+     * The origin the enforcer will use to proxy sensor script requests.
+     */
+    readonly backendClientUrl: string;
+    /**
+     * The origin the enforcer will use to send first-party XHR and async activities.
+     */
+    readonly backendCollectorUrl: string;
+    /**
+     * An alternative third-party URL to retrieve the captcha script for the block page in case of error.
+     */
+    readonly altBackendCaptchaUrl: string;
+    /**
+     * The name and version of the enforcer module.
+     */
+    readonly moduleVersion: string;
+    /**
+     * The risk score at and above which the request should be blocked.
+     */
+    readonly blockingScore: number;
+    /**
+     * A URL to a custom CSS file that should be added to the block page.
+     */
+    readonly cssRef: string;
+    /**
+     * A URL to a custom JS file that should be added to the block page.
+     */
+    readonly jsRef: string;
+    /**
+     * A URL to a custom logo that should be added to the block page.
+     */
+    readonly customLogo: string;
+    /**
+     * The maximum expected iterations for PBKDF2. Used for Cookie v3 only.
+     */
+    readonly riskCookieMaxIterations: number;
+    /**
+     * The minimum expected iterations for PBKDF2. Used for Cookie v3 only.
+     */
+    readonly riskCookieMinIterations: number;
+    /**
+     * The maximum expected length of risk cookie beyond which it will not be processed.
+     */
+    readonly riskCookieMaxLength: number;
+    /**
+     * The maximum expected length of the user-agent beyond which it will be truncated.
+     */
+    readonly userAgentMaxLength: number;
+    /**
+     * A function returning CustomParameters that will be added to the enforcer activities.
+     */
+    readonly enrichCustomParameters: CustomParametersFunction;
+    /**
+     * A function that will be called after the asynchronous activities are sent to the backend.
+     */
+    readonly additionalActivityHandler: AdditionalActivityHandler;
+    /**
+     * Returns an object representation of the current configuration.
+     */
+    toParams(): ParamsType;
+}

package/lib/config/IConfiguration.js

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

package/lib/config/StaticConfigurationBase.d.ts

@@ -0,0 +1,57 @@
+import { IConfiguration } from './IConfiguration';
+import { ConfigurationParams } from './ConfigurationParams';
+import { CustomParametersFunction } from '../custom_parameters';
+import { AdditionalActivityHandler } from '../additional_activity_handler';
+import { ILogger, LoggerSeverity } from '../logger';
+import { ModuleMode } from '../utils';
+export declare abstract class StaticConfigurationBase<ParamsType extends ConfigurationParams = ConfigurationParams> implements IConfiguration<ParamsType> {
+    protected readonly configParams: ParamsType;
+    protected internalLogger: ILogger;
+    protected abstract getModuleVersion(): string;
+    protected constructor(params: ParamsType, defaultParams?: Partial<ParamsType>);
+    private initialize;
+    private throwIfMissingRequiredField;
+    private getValidConfigValue;
+    private isValidConfigValue;
+    private getDefaultConfigurationValue;
+    toParams(): ParamsType;
+    get moduleVersion(): string;
+    get logger(): ILogger;
+    get appId(): string;
+    get authToken(): string;
+    get blockingScore(): number;
+    get bypassMonitorHeader(): string;
+    get cookieSecret(): string;
+    get customCookieHeader(): string;
+    get customLogo(): string;
+    get enforcedRoutes(): string[];
+    get filteredExtensions(): string[];
+    get filteredHttpMethods(): string[];
+    get filteredIps(): string[];
+    get filteredRoutes(): string[];
+    get filteredUserAgents(): string[];
+    get firstPartyEnabled(): boolean;
+    get firstPartyPrefix(): string;
+    get loggerSeverity(): LoggerSeverity;
+    get moduleEnabled(): boolean;
+    get moduleMode(): ModuleMode;
+    get monitoredRoutes(): string[];
+    get s2sTimeout(): number;
+    get sensitiveHeaders(): string[];
+    get sensitiveRoutes(): string[];
+    get advancedBlockingResponseEnabled(): boolean;
+    get backendScoreApiUrl(): string;
+    get ipHeaders(): string[];
+    get backendCaptchaUrl(): string;
+    get backendClientUrl(): string;
+    get backendCollectorUrl(): string;
+    get cssRef(): string;
+    get jsRef(): string;
+    get riskCookieMaxIterations(): number;
+    get riskCookieMinIterations(): number;
+    get riskCookieMaxLength(): number;
+    get userAgentMaxLength(): number;
+    get enrichCustomParameters(): CustomParametersFunction;
+    get additionalActivityHandler(): AdditionalActivityHandler;
+    get altBackendCaptchaUrl(): string;
+}

package/lib/config/StaticConfigurationBase.js

@@ -0,0 +1,355 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticConfigurationBase = void 0;
+var DefaultConfigurations_1 = require("./DefaultConfigurations");
+var logger_1 = require("../logger");
+var utils_1 = require("../utils");
+var first_party_1 = require("../first_party");
+var StaticConfigurationBase = /** @class */ (function () {
+    function StaticConfigurationBase(params, defaultParams) {
+        this.configParams = this.initialize(params, __assign(__assign({}, DefaultConfigurations_1.DEFAULT_CONFIGURATIONS), defaultParams));
+        this.internalLogger = new logger_1.DefaultLogger(this.configParams.px_logger_severity);
+    }
+    StaticConfigurationBase.prototype.initialize = function (params, defaultParams) {
+        var _this = this;
+        this.throwIfMissingRequiredField(params);
+        var config = {};
+        Object.keys(defaultParams).forEach(function (k) {
+            config[k] = _this.getValidConfigValue(params, defaultParams, k);
+        });
+        return config;
+    };
+    StaticConfigurationBase.prototype.throwIfMissingRequiredField = function (params) {
+        var REQUIRED_FIELDS = ['px_app_id', 'px_cookie_secret', 'px_auth_token'];
+        REQUIRED_FIELDS.forEach(function (key) {
+            if (!params[key]) {
+                throw new utils_1.EnforcerException("".concat(key, " cannot be empty!"));
+            }
+        });
+    };
+    StaticConfigurationBase.prototype.getValidConfigValue = function (params, defaultParams, key) {
+        if (params[key] != null && this.isValidConfigValue(params, defaultParams, key)) {
+            return params[key];
+        }
+        else {
+            return this.getDefaultConfigurationValue(params, defaultParams, key);
+        }
+    };
+    StaticConfigurationBase.prototype.isValidConfigValue = function (params, defaultParams, key) {
+        switch (key) {
+            case 'px_logger_severity':
+                return (0, utils_1.isValidEnumValue)(logger_1.LoggerSeverity, params[key]);
+            case 'px_module_mode':
+                return (0, utils_1.isValidEnumValue)(utils_1.ModuleMode, params[key]);
+            default:
+                if (defaultParams[key] === null) {
+                    return typeof params[key] === 'function';
+                }
+                if (Array.isArray(defaultParams[key])) {
+                    return Array.isArray(params[key]);
+                }
+                return typeof params[key] === typeof defaultParams[key];
+        }
+    };
+    StaticConfigurationBase.prototype.getDefaultConfigurationValue = function (params, defaultParams, key) {
+        switch (key) {
+            case 'px_backend_url':
+                return "https://".concat((0, utils_1.getScoreApiDomain)(params.px_app_id));
+            case 'px_backend_collector_url':
+                return "https://".concat((0, utils_1.getCollectorDomain)(params.px_app_id));
+            case 'px_first_party_prefix':
+                return (0, first_party_1.getDefaultFirstPartyPrefix)(params.px_app_id);
+            default:
+                return defaultParams[key];
+        }
+    };
+    StaticConfigurationBase.prototype.toParams = function () {
+        return Object.assign({}, this.configParams);
+    };
+    Object.defineProperty(StaticConfigurationBase.prototype, "moduleVersion", {
+        get: function () {
+            return "".concat(this.getModuleVersion(), " (").concat(utils_1.CORE_MODULE_VERSION, ")");
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "logger", {
+        get: function () {
+            return this.internalLogger;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "appId", {
+        get: function () {
+            return this.configParams.px_app_id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "authToken", {
+        get: function () {
+            return this.configParams.px_auth_token;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "blockingScore", {
+        get: function () {
+            return this.configParams.px_blocking_score;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "bypassMonitorHeader", {
+        get: function () {
+            return this.configParams.px_bypass_monitor_header;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "cookieSecret", {
+        get: function () {
+            return this.configParams.px_cookie_secret;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "customCookieHeader", {
+        get: function () {
+            return this.configParams.px_custom_cookie_header;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "customLogo", {
+        get: function () {
+            return this.configParams.px_custom_logo;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "enforcedRoutes", {
+        get: function () {
+            return this.configParams.px_enforced_routes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "filteredExtensions", {
+        get: function () {
+            return this.configParams.px_filter_by_extension.map(function (ext) { return (ext.startsWith('.') ? ext : ".".concat(ext)); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "filteredHttpMethods", {
+        get: function () {
+            return this.configParams.px_filter_by_http_method;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "filteredIps", {
+        get: function () {
+            return this.configParams.px_filter_by_ip;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "filteredRoutes", {
+        get: function () {
+            return this.configParams.px_filter_by_route;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "filteredUserAgents", {
+        get: function () {
+            return this.configParams.px_filter_by_user_agent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "firstPartyEnabled", {
+        get: function () {
+            return this.configParams.px_first_party_enabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "firstPartyPrefix", {
+        get: function () {
+            return this.configParams.px_first_party_prefix;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "loggerSeverity", {
+        get: function () {
+            return this.logger.getLoggerSeverity();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "moduleEnabled", {
+        get: function () {
+            return this.configParams.px_module_enabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "moduleMode", {
+        get: function () {
+            return this.configParams.px_module_mode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "monitoredRoutes", {
+        get: function () {
+            return this.configParams.px_monitored_routes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "s2sTimeout", {
+        get: function () {
+            return this.configParams.px_s2s_timeout;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "sensitiveHeaders", {
+        get: function () {
+            return this.configParams.px_sensitive_headers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "sensitiveRoutes", {
+        get: function () {
+            return this.configParams.px_sensitive_routes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "advancedBlockingResponseEnabled", {
+        get: function () {
+            return this.configParams.px_advanced_blocking_response_enabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "backendScoreApiUrl", {
+        get: function () {
+            return this.configParams.px_backend_url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "ipHeaders", {
+        get: function () {
+            return this.configParams.px_ip_headers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "backendCaptchaUrl", {
+        get: function () {
+            return this.configParams.px_backend_captcha_url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "backendClientUrl", {
+        get: function () {
+            return this.configParams.px_backend_client_url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "backendCollectorUrl", {
+        get: function () {
+            return this.configParams.px_backend_collector_url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "cssRef", {
+        get: function () {
+            return this.configParams.px_css_ref;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "jsRef", {
+        get: function () {
+            return this.configParams.px_js_ref;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "riskCookieMaxIterations", {
+        get: function () {
+            return this.configParams.px_risk_cookie_max_iterations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "riskCookieMinIterations", {
+        get: function () {
+            return this.configParams.px_risk_cookie_min_iterations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "riskCookieMaxLength", {
+        get: function () {
+            return this.configParams.px_risk_cookie_max_length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "userAgentMaxLength", {
+        get: function () {
+            return this.configParams.px_user_agent_max_length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "enrichCustomParameters", {
+        get: function () {
+            return this.configParams.px_enrich_custom_parameters || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "additionalActivityHandler", {
+        get: function () {
+            return this.configParams.px_additional_activity_handler || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StaticConfigurationBase.prototype, "altBackendCaptchaUrl", {
+        get: function () {
+            return 'https://captcha.px-cloud.net';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return StaticConfigurationBase;
+}());
+exports.StaticConfigurationBase = StaticConfigurationBase;

package/lib/config/index.d.ts

@@ -0,0 +1,4 @@
+export { IConfiguration } from './IConfiguration';
+export { ConfigurationParams } from './ConfigurationParams';
+export { DEFAULT_CONFIGURATIONS } from './DefaultConfigurations';
+export { StaticConfigurationBase } from './StaticConfigurationBase';

package/lib/config/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticConfigurationBase = exports.DEFAULT_CONFIGURATIONS = void 0;
+var DefaultConfigurations_1 = require("./DefaultConfigurations");
+Object.defineProperty(exports, "DEFAULT_CONFIGURATIONS", { enumerable: true, get: function () { return DefaultConfigurations_1.DEFAULT_CONFIGURATIONS; } });
+var StaticConfigurationBase_1 = require("./StaticConfigurationBase");
+Object.defineProperty(exports, "StaticConfigurationBase", { enumerable: true, get: function () { return StaticConfigurationBase_1.StaticConfigurationBase; } });

package/lib/context/ContextBase.d.ts

@@ -0,0 +1,55 @@
+import { IConfiguration } from '../config';
+import { BlockReason, BlockAction } from '../block_handler';
+import { CustomParameters } from '../custom_parameters';
+import { FilterReason } from '../filter';
+import { IHttpRequest, HttpHeaders } from '../http';
+import { PXDE } from '../pxde';
+import { IBotDefenderToken, TokenOrigin } from '../risk_token';
+import { VidSource, PassReason, ICookieParser, IUuidGenerator } from '../utils';
+import { IContext, MobileData, RequestData, ResponseData, RiskApiData, ServerData, TlsData } from './IContext';
+export declare type ContextBaseOptions = {
+    cookieParser?: ICookieParser;
+    uuidGenerator?: IUuidGenerator;
+};
+export declare abstract class ContextBase<OptionsType extends ContextBaseOptions> implements IContext {
+    readonly requestId: string;
+    readonly requestData: RequestData;
+    readonly responseData: ResponseData;
+    readonly mobileData: MobileData;
+    readonly riskApiData: RiskApiData;
+    readonly tlsData: TlsData;
+    readonly serverData: ServerData;
+    uuid: string;
+    vid?: string;
+    vidSource?: VidSource;
+    isMonitoredRequest: boolean;
+    isSensitiveRequest: boolean;
+    score?: number;
+    passReason?: PassReason;
+    blockReason?: BlockReason;
+    blockAction?: BlockAction;
+    filterReason?: FilterReason;
+    tokenOrigin?: TokenOrigin;
+    riskToken?: IBotDefenderToken;
+    pxhd?: string;
+    pxde?: PXDE;
+    pxdeVerified?: boolean;
+    customParameters?: CustomParameters;
+    protected readonly config: IConfiguration;
+    protected constructor(config: IConfiguration, request: IHttpRequest, options?: OptionsType);
+    protected abstract createRiskToken(config: IConfiguration, cookies: Record<string, string>, options: OptionsType): IBotDefenderToken;
+    protected createRequestData(config: IConfiguration, request: IHttpRequest, cookieParser?: ICookieParser): RequestData;
+    protected extractUserAgentFromHeader(config: IConfiguration, headers: HttpHeaders): string;
+    protected extractIpFromHeader(config: IConfiguration, headers: HttpHeaders): string;
+    protected isMonitored(config: IConfiguration, requestData: RequestData): boolean;
+    protected isSensitive(config: IConfiguration, { url }: RequestData): boolean;
+    protected isAllowedToBypassMonitor(config: IConfiguration, requestData: RequestData): boolean;
+    completeInitialization(): Promise<void>;
+    protected setRiskTokenOnContext(config: IConfiguration, options: OptionsType): void;
+    protected setMobileTokenOnContext(config: IConfiguration, mobileToken: string, options: OptionsType): void;
+    protected setWebTokenOnContext(config: IConfiguration, options: OptionsType): void;
+    protected setCookiesOnContext(): void;
+    protected getMobileToken(config: IConfiguration, mobileToken: string, options: OptionsType): IBotDefenderToken;
+    protected handleCustomParameters(config: IConfiguration, request: IHttpRequest): Promise<void>;
+    get isMobile(): boolean;
+}