@riavzon/bot-detector 1.0.0

package/dist/main.d.mts

@@ -0,0 +1,1607 @@
+/// <reference types="node" />
+import z from "zod";
+import maxmind from "maxmind";
+import { RootDatabase } from "lmdb";
+import { Storage } from "unstorage";
+import { IResult } from "ua-parser-js";
+import { Request, RequestHandler } from "express";
+import { BgpRecord, CityGeoRecord, CrawlersRecord, GeoRecord, JA4, ProxyRecord, ThreatRecord, TorRecord, UserAgentRecord } from "@riavzon/shield-base";
+import mysql from "mysql2/promise";
+import postgresql from "db0/connectors/postgresql";
+import betterSqlite3Connector from "db0/connectors/better-sqlite3";
+import cloudflareD1Connector from "db0/connectors/cloudflare-d1";
+import planetscale from "db0/connectors/planetscale";
+import redisDriver from "unstorage/drivers/redis";
+import lruDriver from "unstorage/drivers/lru-cache";
+import fsLiteDriver from "unstorage/drivers/fs-lite";
+import upstashDriver from "unstorage/drivers/upstash";
+import vercelRuntimeCacheDriver from "unstorage/drivers/vercel-runtime-cache";
+import cloudflareR2BindingDriver from "unstorage/drivers/cloudflare-r2-binding";
+import cloudflareKVBindingDriver from "unstorage/drivers/cloudflare-kv-binding";
+import cloudflareKVHTTPDriver from "unstorage/drivers/cloudflare-kv-http";
+import { SendOptions } from "send";
+import { EventEmitter } from "events";
+import * as http from "http";
+import { ParsedQs } from "qs";
+import { Options, Ranges, Result } from "range-parser";
+
+//#region src/botDetector/middlewares/canaryCookieChecker.d.ts
+declare global {
+  namespace Express {
+    interface Request {
+      newVisitorId?: string;
+      botDetection: {
+        success: boolean;
+        banned: boolean;
+        time: string;
+        ipAddress: string;
+      };
+    }
+  }
+}
+declare function validator(buildCustomContext?: (req: Request) => unknown): RequestHandler;
+//#endregion
+//#region src/botDetector/types/dbTypes.d.ts
+type Opts$1<T extends (opts?: any) => any> = NonNullable<Parameters<T>[0]>;
+interface SupportedDbDrivers {
+  'mysql-pool': mysql.PoolOptions;
+  postgresql: Opts$1<typeof postgresql>;
+  sqlite: Opts$1<typeof betterSqlite3Connector>;
+  'cloudflare-d1': Opts$1<typeof cloudflareD1Connector>;
+  planetscale: Opts$1<typeof planetscale>;
+}
+type DbConfig = { [K in keyof SupportedDbDrivers]: {
+  driver: K;
+} & SupportedDbDrivers[K] }[keyof SupportedDbDrivers];
+//#endregion
+//#region src/botDetector/types/storageTypes.d.ts
+type Opts<T extends (opts?: any) => any> = NonNullable<Parameters<T>[0]>;
+interface SupportedDrivers {
+  upstash: Opts<typeof upstashDriver>;
+  'lru': Opts<typeof lruDriver>;
+  redis: Opts<typeof redisDriver>;
+  'fs': Opts<typeof fsLiteDriver>;
+  'cloudflare-kv-binding': Opts<typeof cloudflareKVBindingDriver>;
+  'cloudflare-kv-http': Opts<typeof cloudflareKVHTTPDriver>;
+  'cloudflare-r2-binding': Opts<typeof cloudflareR2BindingDriver>;
+  'vercel': Opts<typeof vercelRuntimeCacheDriver>;
+}
+type CacheConfig = { [K in keyof SupportedDrivers]: {
+  driver: K;
+} & SupportedDrivers[K] }[keyof SupportedDrivers];
+//#endregion
+//#region src/botDetector/types/configSchema.d.ts
+declare const configSchema: z.ZodObject<{
+  store: z.ZodObject<{
+    main: z.ZodNonOptional<z.ZodCustom<DbConfig, DbConfig>>;
+  }, z.z.core.$strict>;
+  banScore: z.ZodDefault<z.ZodNumber>;
+  maxScore: z.ZodDefault<z.ZodNumber>;
+  restoredReputationPoints: z.ZodDefault<z.ZodNumber>;
+  setNewComputedScore: z.ZodDefault<z.ZodBoolean>;
+  whiteList: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodString]>>>>;
+  checksTimeRateControl: z.ZodPrefault<z.ZodObject<{
+    checkEveryRequest: z.ZodDefault<z.ZodBoolean>;
+    checkEvery: z.ZodDefault<z.ZodNumber>;
+  }, z.z.core.$strip>>;
+  batchQueue: z.ZodPrefault<z.ZodObject<{
+    flushIntervalMs: z.ZodDefault<z.ZodNumber>;
+    maxBufferSize: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+  }, z.z.core.$strip>>;
+  storage: z.ZodOptional<z.ZodCustom<CacheConfig, CacheConfig>>;
+  checkers: z.ZodObject<{
+    localeMapsCheck: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        ipAndHeaderMismatch: z.ZodDefault<z.ZodNumber>;
+        missingHeader: z.ZodDefault<z.ZodNumber>;
+        missingGeoData: z.ZodDefault<z.ZodNumber>;
+        malformedHeader: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    knownBadUserAgents: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        criticalSeverity: z.ZodDefault<z.ZodNumber>;
+        highSeverity: z.ZodDefault<z.ZodNumber>;
+        mediumSeverity: z.ZodDefault<z.ZodNumber>;
+        lowSeverity: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableIpChecks: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodDefault<z.ZodNumber>;
+    }, z.z.core.$strip>], "enable">>;
+    enableGoodBotsChecks: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      banUnlistedBots: z.ZodDefault<z.ZodBoolean>;
+      penalties: z.ZodDefault<z.ZodNumber>;
+    }, z.z.core.$strip>], "enable">>;
+    enableBehaviorRateCheck: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      behavioral_window: z.ZodDefault<z.ZodNumber>;
+      behavioral_threshold: z.ZodDefault<z.ZodNumber>;
+      penalties: z.ZodDefault<z.ZodNumber>;
+    }, z.z.core.$strip>], "enable">>;
+    enableProxyIspCookiesChecks: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        cookieMissing: z.ZodDefault<z.ZodNumber>;
+        proxyDetected: z.ZodDefault<z.ZodNumber>;
+        multiSourceBonus2to3: z.ZodDefault<z.ZodNumber>;
+        multiSourceBonus4plus: z.ZodDefault<z.ZodNumber>;
+        hostingDetected: z.ZodDefault<z.ZodNumber>;
+        ispUnknown: z.ZodDefault<z.ZodNumber>;
+        orgUnknown: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableUaAndHeaderChecks: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        headlessBrowser: z.ZodDefault<z.ZodNumber>;
+        shortUserAgent: z.ZodDefault<z.ZodNumber>;
+        tlsCheckFailed: z.ZodDefault<z.ZodNumber>;
+        badUaChecker: z.ZodDefault<z.ZodBoolean>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableBrowserAndDeviceChecks: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        cliOrLibrary: z.ZodDefault<z.ZodNumber>;
+        internetExplorer: z.ZodDefault<z.ZodNumber>;
+        linuxOs: z.ZodDefault<z.ZodNumber>;
+        impossibleBrowserCombinations: z.ZodDefault<z.ZodNumber>;
+        browserTypeUnknown: z.ZodDefault<z.ZodNumber>;
+        browserNameUnknown: z.ZodDefault<z.ZodNumber>;
+        desktopWithoutOS: z.ZodDefault<z.ZodNumber>;
+        deviceVendorUnknown: z.ZodDefault<z.ZodNumber>;
+        browserVersionUnknown: z.ZodDefault<z.ZodNumber>;
+        deviceModelUnknown: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableGeoChecks: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      bannedCountries: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        countryUnknown: z.ZodDefault<z.ZodNumber>;
+        regionUnknown: z.ZodDefault<z.ZodNumber>;
+        latLonUnknown: z.ZodDefault<z.ZodNumber>;
+        districtUnknown: z.ZodDefault<z.ZodNumber>;
+        cityUnknown: z.ZodDefault<z.ZodNumber>;
+        timezoneUnknown: z.ZodDefault<z.ZodNumber>;
+        subregionUnknown: z.ZodDefault<z.ZodNumber>;
+        phoneUnknown: z.ZodDefault<z.ZodNumber>;
+        continentUnknown: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableKnownThreatsDetections: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        anonymiseNetwork: z.ZodDefault<z.ZodNumber>;
+        threatLevels: z.ZodPrefault<z.ZodObject<{
+          criticalLevel1: z.ZodDefault<z.ZodNumber>;
+          currentAttacksLevel2: z.ZodDefault<z.ZodNumber>;
+          threatLevel3: z.ZodDefault<z.ZodNumber>;
+          threatLevel4: z.ZodDefault<z.ZodNumber>;
+        }, z.z.core.$strip>>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableAsnClassification: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        contentClassification: z.ZodDefault<z.ZodNumber>;
+        unknownClassification: z.ZodDefault<z.ZodNumber>;
+        lowVisibilityPenalty: z.ZodDefault<z.ZodNumber>;
+        lowVisibilityThreshold: z.ZodDefault<z.ZodNumber>;
+        comboHostingLowVisibility: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableTorAnalysis: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        runningNode: z.ZodDefault<z.ZodNumber>;
+        exitNode: z.ZodDefault<z.ZodNumber>;
+        webExitCapable: z.ZodDefault<z.ZodNumber>;
+        guardNode: z.ZodDefault<z.ZodNumber>;
+        badExit: z.ZodDefault<z.ZodNumber>;
+        obsoleteVersion: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableTimezoneConsistency: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodDefault<z.ZodNumber>;
+    }, z.z.core.$strip>], "enable">>;
+    honeypot: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableSessionCoherence: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      penalties: z.ZodPrefault<z.ZodObject<{
+        pathMismatch: z.ZodDefault<z.ZodNumber>;
+        missingReferer: z.ZodDefault<z.ZodNumber>;
+        domainMismatch: z.ZodDefault<z.ZodNumber>;
+      }, z.z.core.$strip>>;
+    }, z.z.core.$strip>], "enable">>;
+    enableVelocityFingerprint: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      cvThreshold: z.ZodDefault<z.ZodNumber>;
+      penalties: z.ZodDefault<z.ZodNumber>;
+    }, z.z.core.$strip>], "enable">>;
+    enableKnownBadIpsCheck: z.ZodPrefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      enable: z.ZodLiteral<false>;
+    }, z.z.core.$strip>, z.ZodObject<{
+      enable: z.ZodLiteral<true>;
+      highRiskPenalty: z.ZodDefault<z.ZodNumber>;
+    }, z.z.core.$strip>], "enable">>;
+  }, z.z.core.$strip>;
+  generator: z.ZodPrefault<z.ZodObject<{
+    scoreThreshold: z.ZodDefault<z.ZodNumber>;
+    generateTypes: z.ZodDefault<z.ZodBoolean>;
+    deleteAfterBuild: z.ZodDefault<z.ZodBoolean>;
+    mmdbctlPath: z.ZodDefault<z.ZodString>;
+  }, z.z.core.$strip>>;
+  headerOptions: z.ZodPrefault<z.ZodObject<{
+    weightPerMustHeader: z.ZodDefault<z.ZodNumber>;
+    missingBrowserEngine: z.ZodDefault<z.ZodNumber>;
+    postManOrInsomiaHeaders: z.ZodDefault<z.ZodNumber>;
+    AJAXHeaderExists: z.ZodDefault<z.ZodNumber>;
+    connectionHeaderIsClose: z.ZodDefault<z.ZodNumber>;
+    originHeaderIsNULL: z.ZodDefault<z.ZodNumber>;
+    originHeaderMismatch: z.ZodDefault<z.ZodNumber>;
+    omittedAcceptHeader: z.ZodDefault<z.ZodNumber>;
+    clientHintsMissingForBlink: z.ZodDefault<z.ZodNumber>;
+    teHeaderUnexpectedForBlink: z.ZodDefault<z.ZodNumber>;
+    clientHintsUnexpectedForGecko: z.ZodDefault<z.ZodNumber>;
+    teHeaderMissingForGecko: z.ZodDefault<z.ZodNumber>;
+    aggressiveCacheControlOnGet: z.ZodDefault<z.ZodNumber>;
+    crossSiteRequestMissingReferer: z.ZodDefault<z.ZodNumber>;
+    inconsistentSecFetchMode: z.ZodDefault<z.ZodNumber>;
+    hostMismatchWeight: z.ZodDefault<z.ZodNumber>;
+  }, z.z.core.$strip>>;
+  pathTraveler: z.ZodPrefault<z.ZodObject<{
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    maxPathLength: z.ZodDefault<z.ZodNumber>;
+    pathLengthToLong: z.ZodDefault<z.ZodNumber>;
+    longDecoding: z.ZodDefault<z.ZodNumber>;
+    traversalDetected: z.ZodDefault<z.ZodNumber>;
+  }, z.z.core.$strip>>;
+  punishmentType: z.ZodPrefault<z.ZodObject<{
+    enableFireWallBan: z.ZodDefault<z.ZodBoolean>;
+  }, z.z.core.$strip>>;
+  logLevel: z.ZodDefault<z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+    fatal: "fatal";
+  }>>;
+}, z.z.core.$strip>;
+type BotDetectorConfig = z.infer<typeof configSchema>;
+type BotDetectorConfigInput = z.input<typeof configSchema>;
+//#endregion
+//#region src/botDetector/types/generator.d.ts
+interface BannedRecord {
+  range: string;
+  score: number;
+  country: string | null;
+  userAgent: string | null;
+  reason: string;
+  comment: 'Automatically generated by @riavzon/botDetector';
+}
+interface HighRiskRecord {
+  range: string;
+  visitorId: string;
+  score: number;
+  country: string | null;
+  region: string | null;
+  regionName: string | null;
+  city: string | null;
+  lat: string | null;
+  lon: string | null;
+  timezone: string | null;
+  isp: string | null;
+  org: string | null;
+  browser: string | null;
+  browserType: string | null;
+  browserVersion: string | null;
+  os: string | null;
+  deviceType: string | null;
+  deviceVendor: string | null;
+  deviceModel: string | null;
+  proxy: boolean;
+  hosting: boolean;
+  requestCount: number;
+  firstSeen: string | null;
+  lastSeen: string | null;
+  comment: 'Automatically generated by @riavzon/botDetector';
+}
+//#endregion
+//#region src/botDetector/helpers/mmdbDataReaders.d.ts
+type ThreatRecordModified = ThreatRecord & {
+  network: string;
+};
+interface DataReaders {
+  asnDataBase(ip: string): BgpRecord | null;
+  cityDataBase(ip: string): CityGeoRecord | null;
+  countryDataBase(ip: string): GeoRecord | null;
+  goodBotsDataBase(ip: string): CrawlersRecord | null;
+  torDataBase(ip: string): TorRecord | null;
+  proxyDataBase(ip: string): ProxyRecord | null;
+  fireholAnonDataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl1DataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl2DataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl3DataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl4DataBase(ip: string): ThreatRecordModified | null;
+  bannedDataBase(ip: string): BannedRecord | null;
+  highRiskDataBase(ip: string): HighRiskRecord | null;
+  getUserAgentLmdb(): RootDatabase<UserAgentRecord, string>;
+  getJa4Lmdb(): RootDatabase<JA4, string>;
+}
+declare class DataSources implements DataReaders {
+  private readonly readers;
+  private constructor();
+  static initialize(): Promise<DataSources>;
+  asnDataBase(ip: string): BgpRecord | null;
+  cityDataBase(ip: string): CityGeoRecord | null;
+  countryDataBase(ip: string): GeoRecord | null;
+  goodBotsDataBase(ip: string): CrawlersRecord | null;
+  torDataBase(ip: string): TorRecord | null;
+  proxyDataBase(ip: string): ProxyRecord | null;
+  fireholAnonDataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl1DataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl2DataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl3DataBase(ip: string): ThreatRecordModified | null;
+  fireholLvl4DataBase(ip: string): ThreatRecordModified | null;
+  bannedDataBase(ip: string): BannedRecord | null;
+  highRiskDataBase(ip: string): HighRiskRecord | null;
+  getUserAgentLmdb(): RootDatabase<UserAgentRecord, string>;
+  getJa4Lmdb(): RootDatabase<JA4, string>;
+}
+//#endregion
+//#region src/botDetector/types/geoTypes.d.ts
+interface GeoResponse {
+  country?: string;
+  countryCode?: string;
+  region?: string;
+  regionName?: string;
+  subregion?: string;
+  state?: string;
+  zipCode?: string;
+  city?: string;
+  phone?: string;
+  numericCode?: string;
+  native?: string;
+  continent?: string;
+  capital?: string;
+  district?: string;
+  lat?: string;
+  lon?: string;
+  timezone?: string;
+  timeZoneName?: string;
+  utc_offset?: string;
+  tld?: string;
+  nationality?: string;
+  currency?: string;
+  iso639?: string;
+  languages?: string;
+  isp?: string;
+  org?: string;
+  as_org?: string;
+  proxy?: boolean;
+  hosting?: boolean;
+}
+//#endregion
+//#region src/botDetector/types/UAparserTypes.d.ts
+interface ParsedUAResult {
+  device: string;
+  deviceVendor?: string;
+  deviceModel?: string;
+  browser?: string;
+  browserType?: string;
+  browserVersion?: string;
+  botAI: boolean;
+  bot: boolean;
+  os?: string;
+  allResults: IResult;
+}
+//#endregion
+//#region src/botDetector/types/botDetectorTypes.d.ts
+interface ValidationContext<TCustom = Record<string, never>> {
+  req: Request;
+  ipAddress: string;
+  parsedUA: Partial<ParsedUAResult>;
+  geoData: Partial<GeoResponse>;
+  cookie?: string;
+  proxy: {
+    isProxy: boolean;
+    proxyType?: string;
+  };
+  anon: boolean;
+  bgp: Partial<Omit<BgpRecord, 'range'>>;
+  tor: Partial<Omit<TorRecord, 'range'>>;
+  threatLevel: 1 | 2 | 3 | 4 | null;
+  custom: TCustom;
+}
+//#endregion
+//#region src/botDetector/types/checkersTypes.d.ts
+type BanReasonCode = 'IP_INVALID' | 'BEHAVIOR_TOO_FAST' | 'GOOD_BOT_IDENTIFIED' | 'BAD_GOOGLEBOT' | 'SHORT_USER_AGENT' | 'CLI_OR_LIBRARY' | 'KALI_LINUX_OS' | 'INTERNET_EXPLORER' | 'COOKIE_MISSING' | 'BANNED_COUNTRY' | 'COUNTRY_UNKNOWN' | 'PROXY_DETECTED' | 'HOSTING_DETECTED' | 'TIMEZONE_UNKNOWN' | 'ISP_UNKNOWN' | 'REGION_UNKNOWN' | 'LAT_LON_UNKNOWN' | 'ORG_UNKNOWN' | 'DEVICE_TYPE_UNKNOWN' | 'DEVICE_VENDOR_UNKNOWN' | 'BROWSER_TYPE_UNKNOWN' | 'BROWSER_VERSION_UNKNOWN' | 'DISTRICT_UNKNOWN' | 'CITY_UNKNOWN' | 'OS_UNKNOWN' | 'BROWSER_NAME_UNKNOWN' | 'HEADLESS_BROWSER_DETECTED' | 'LOCALE_MISMATCH' | 'TZ_MISMATCH' | 'TLS_CHECK_FAILED' | 'HEADER_SCORE_TOO_HIGH' | 'META_UA_CHECK_FAILED' | 'DESKTOP_WITHOUT_OS' | 'NO_MODEL' | 'XSS SCRIPTING ATTEMPT' | 'PATH_TRAVELER_FOUND' | 'BAD_UA_DETECTED' | 'BAD_BOT_DETECTED' | 'ANONYMITY_NETWORK' | 'FIREHOL_L1_THREAT' | 'FIREHOL_L2_THREAT' | 'FIREHOL_L3_THREAT' | 'FIREHOL_L4_THREAT' | 'ASN_HOSTING_CLASSIFIED' | 'ASN_CLASSIFICATION_UNKNOWN' | 'ASN_LOW_VISIBILITY' | 'ASN_HOSTING_LOW_VISIBILITY_COMBO' | 'TOR_ACTIVE_NODE' | 'TOR_EXIT_NODE' | 'TOR_WEB_EXIT_CAPABLE' | 'TOR_GUARD_NODE' | 'TOR_BAD_EXIT' | 'TOR_OBSOLETE_VERSION' | 'TZ_HEADER_GEO_MISMATCH' | 'HONEYPOT_PATH_HIT' | 'SESSION_COHERENCE_VIOLATION' | 'SESSION_COHERENCE_PATH_MISMATCH' | 'SESSION_COHERENCE_MISSING_REFERER' | 'SESSION_COHERENCE_DOMAIN_MISMATCH' | 'SESSION_COHERENCE_INVALID_REFERER' | 'TIMING_TOO_REGULAR' | 'PREVIOUSLY_BANNED_IP' | 'PREVIOUSLY_HIGH_RISK_IP';
+interface BannedInfo {
+  score: number;
+  reasons: BanReasonCode[];
+}
+interface IBotChecker<Code, TCustom = Record<string, never>> {
+  name: string;
+  phase: 'cheap' | 'heavy';
+  isEnabled(config: BotDetectorConfig): boolean;
+  run(ctx: ValidationContext<TCustom>, config: BotDetectorConfig): Promise<{
+    score: number;
+    reasons: Code[] | BanReasonCode[];
+  }> | {
+    score: number;
+    reasons: Code[] | BanReasonCode[];
+  };
+}
+//#endregion
+//#region src/botDetector/types/fingerPrint.d.ts
+interface userValidation {
+  cookie: string | null;
+  visitorId: string;
+  userAgent: string;
+  ipAddress: string;
+  country: string | null;
+  region: string | null;
+  regionName: string | null;
+  city: string | null;
+  district: string | null;
+  lat: string | null;
+  lon: string;
+  timezone: string | null;
+  currency: string | null;
+  isp: string | null;
+  org: string | null;
+  as: string | null;
+  device_type: string | null;
+  browser: string | null;
+  proxy: boolean;
+  hosting: boolean;
+  is_bot: boolean;
+  first_seen: string | null;
+  last_seen: string | null;
+  request_count: number;
+  deviceVendor?: string;
+  deviceModel?: string;
+  browserType?: string;
+  browserVersion?: string;
+  os?: string;
+  activity_score?: string;
+}
+//#endregion
+//#region src/botDetector/types/batchQueue.d.ts
+interface VisitorUpsertParams {
+  insert: userValidation;
+}
+interface ScoreUpdateParams {
+  score: number;
+  cookie: string;
+}
+interface IsBotUpdateParams {
+  isBot: boolean;
+  cookie: string;
+}
+interface BannedIpParams {
+  cookie: string;
+  ipAddress: string;
+  country: string;
+  user_agent: string;
+  info: BannedInfo;
+}
+interface OpParams {
+  visitor_upsert: VisitorUpsertParams;
+  score_update: ScoreUpdateParams;
+  is_bot_update: IsBotUpdateParams;
+  update_banned_ip: BannedIpParams;
+}
+type BatchQueueOps = 'visitor_upsert' | 'score_update' | 'is_bot_update' | 'update_banned_ip';
+type Priority = 'immediate' | 'deferred';
+//#endregion
+//#region src/botDetector/db/batchQueue.d.ts
+declare class BatchQueue {
+  private jobs;
+  private timer;
+  private flushPromise;
+  private get config();
+  private get log();
+  addQueue<T extends BatchQueueOps>(canary: string, ipAddress: string, type: T, params: OpParams[T], priority?: Priority): Promise<void>;
+  flush(): Promise<void>;
+  private runJob;
+  private executeBatch;
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/botDetector/config/config.d.ts
+/**
+ * @description
+ * The bot detector library's configuration object.
+ * Contains the core configuration to make the library usable client side.
+ * @module jwtAuth/config
+ * @see {@link ./jwtAuth/types/configSchema.js}
+ */
+declare function configuration(config: BotDetectorConfigInput): Promise<void>;
+declare function getBatchQueue(): BatchQueue;
+declare function getStorage(): Storage;
+declare function getDataSources(): DataSources;
+//#endregion
+//#region node_modules/@types/express-serve-static-core/index.d.ts
+declare global {
+  namespace Express {
+    // These open interfaces may be extended in an application-specific manner via declaration merging.
+    // See for example method-override.d.ts (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/method-override/index.d.ts)
+    interface Request {}
+    interface Response {}
+    interface Locals {}
+    interface Application {}
+  }
+}
+interface NextFunction {
+  (err?: any): void;
+  /**
+   * "Break-out" of a router by calling {next('router')};
+   * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.router}
+   */
+  (deferToNext: "router"): void;
+  /**
+   * "Break-out" of a route by calling {next('route')};
+   * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.application}
+   */
+  (deferToNext: "route"): void;
+}
+interface ParamsDictionary {
+  [key: string]: string | string[];
+  [key: number]: string;
+}
+interface ParamsFlatDictionary {
+  [key: string | number]: string;
+}
+interface Locals extends Express.Locals {}
+interface RequestHandler$1<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> {
+  // tslint:disable-next-line callable-types (This is extended from and can't extend from a type alias in ts<2.2)
+  (req: Request$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response<ResBody, LocalsObj>, next: NextFunction): unknown;
+}
+type ErrorRequestHandler<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = (err: any, req: Request$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response<ResBody, LocalsObj>, next: NextFunction) => unknown;
+type PathParams = string | RegExp | Array<string | RegExp>;
+type RequestHandlerParams<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj> | ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, LocalsObj> | Array<RequestHandler$1<P> | ErrorRequestHandler<P>>;
+type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;
+type GetRouteParameter<S extends string> = RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>; // dprint-ignore
+type RouteParameters<Route extends string | RegExp> = Route extends string ? Route extends `${infer Required}{${infer Optional}}${infer Next}` ? ParseRouteParameters<Required> & Partial<ParseRouteParameters<Optional>> & RouteParameters<Next> : ParseRouteParameters<Route> : ParamsFlatDictionary;
+type ParseRouteParameters<Route extends string> = string extends Route ? ParamsDictionary : Route extends `${string}:${infer Rest}` ? (GetRouteParameter<Rest> extends never ? ParamsDictionary : { [P in GetRouteParameter<Rest>]: string }) & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown) : Route extends `${string}*${infer Rest}` ? (GetRouteParameter<Rest> extends never ? ParamsDictionary : { [P in GetRouteParameter<Rest>]: string[] }) & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown) : {};
+/* eslint-disable @definitelytyped/no-unnecessary-generics */
+interface IRouterMatcher<T, Method extends "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head" = any> {
+  <Route extends string | RegExp, P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(// (it's used as the default type parameter for P)
+  path: Route, // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <Path extends string | RegExp, P = RouteParameters<Path>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(// (it's used as the default type parameter for P)
+  path: Path, // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(path: PathParams, // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(path: PathParams, // (This generic is meant to be passed explicitly.)
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  (path: PathParams, subApplication: Application): T;
+}
+interface IRouterHandler<T, Route extends string | RegExp = string> {
+  (...handlers: Array<RequestHandler$1<RouteParameters<Route>>>): T;
+  (...handlers: Array<RequestHandlerParams<RouteParameters<Route>>>): T;
+  <P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(// (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = RouteParameters<Route>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(// (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(// (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandler$1<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+  <P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>>(// (This generic is meant to be passed explicitly.)
+  // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+  ...handlers: Array<RequestHandlerParams<P, ResBody, ReqBody, ReqQuery, LocalsObj>>): T;
+}
+/* eslint-enable @definitelytyped/no-unnecessary-generics */
+interface IRouter extends RequestHandler$1 {
+  /**
+   * Map the given param placeholder `name`(s) to the given callback(s).
+   *
+   * Parameter mapping is used to provide pre-conditions to routes
+   * which use normalized placeholders. For example a _:user_id_ parameter
+   * could automatically load a user's information from the database without
+   * any additional code,
+   *
+   * The callback uses the samesignature as middleware, the only differencing
+   * being that the value of the placeholder is passed, in this case the _id_
+   * of the user. Once the `next()` function is invoked, just like middleware
+   * it will continue on to execute the route, or subsequent parameter functions.
+   *
+   *      app.param('user_id', function(req, res, next, id){
+   *        User.find(id, function(err, user){
+   *          if (err) {
+   *            next(err);
+   *          } else if (user) {
+   *            req.user = user;
+   *            next();
+   *          } else {
+   *            next(new Error('failed to load user'));
+   *          }
+   *        });
+   *      });
+   */
+  param(name: string, handler: RequestParamHandler): this;
+  /**
+   * Special-cased "all" method, applying the given route `path`,
+   * middleware, and callback to _every_ HTTP method.
+   */
+  all: IRouterMatcher<this, "all">;
+  get: IRouterMatcher<this, "get">;
+  post: IRouterMatcher<this, "post">;
+  put: IRouterMatcher<this, "put">;
+  delete: IRouterMatcher<this, "delete">;
+  patch: IRouterMatcher<this, "patch">;
+  options: IRouterMatcher<this, "options">;
+  head: IRouterMatcher<this, "head">;
+  checkout: IRouterMatcher<this>;
+  connect: IRouterMatcher<this>;
+  copy: IRouterMatcher<this>;
+  lock: IRouterMatcher<this>;
+  merge: IRouterMatcher<this>;
+  mkactivity: IRouterMatcher<this>;
+  mkcol: IRouterMatcher<this>;
+  move: IRouterMatcher<this>;
+  "m-search": IRouterMatcher<this>;
+  notify: IRouterMatcher<this>;
+  propfind: IRouterMatcher<this>;
+  proppatch: IRouterMatcher<this>;
+  purge: IRouterMatcher<this>;
+  report: IRouterMatcher<this>;
+  search: IRouterMatcher<this>;
+  subscribe: IRouterMatcher<this>;
+  trace: IRouterMatcher<this>;
+  unlock: IRouterMatcher<this>;
+  unsubscribe: IRouterMatcher<this>;
+  link: IRouterMatcher<this>;
+  unlink: IRouterMatcher<this>;
+  use: IRouterHandler<this> & IRouterMatcher<this>;
+  route<T extends string | RegExp>(prefix: T): IRoute<T>;
+  route(prefix: PathParams): IRoute;
+  /**
+   * Stack of configured routes
+   */
+  stack: ILayer[];
+}
+interface ILayer {
+  route?: IRoute;
+  name: string | "<anonymous>";
+  params?: Record<string, any>;
+  keys: string[];
+  path?: string;
+  method: string;
+  regexp: RegExp;
+  handle: (req: Request$1, res: Response, next: NextFunction) => any;
+}
+interface IRoute<Route extends string | RegExp = string> {
+  path: string;
+  stack: ILayer[];
+  all: IRouterHandler<this, Route>;
+  get: IRouterHandler<this, Route>;
+  post: IRouterHandler<this, Route>;
+  put: IRouterHandler<this, Route>;
+  delete: IRouterHandler<this, Route>;
+  patch: IRouterHandler<this, Route>;
+  options: IRouterHandler<this, Route>;
+  head: IRouterHandler<this, Route>;
+  checkout: IRouterHandler<this, Route>;
+  copy: IRouterHandler<this, Route>;
+  lock: IRouterHandler<this, Route>;
+  merge: IRouterHandler<this, Route>;
+  mkactivity: IRouterHandler<this, Route>;
+  mkcol: IRouterHandler<this, Route>;
+  move: IRouterHandler<this, Route>;
+  "m-search": IRouterHandler<this, Route>;
+  notify: IRouterHandler<this, Route>;
+  purge: IRouterHandler<this, Route>;
+  report: IRouterHandler<this, Route>;
+  search: IRouterHandler<this, Route>;
+  subscribe: IRouterHandler<this, Route>;
+  trace: IRouterHandler<this, Route>;
+  unlock: IRouterHandler<this, Route>;
+  unsubscribe: IRouterHandler<this, Route>;
+}
+interface Router$1 extends IRouter {}
+/**
+ * Options passed down into `res.cookie`
+ * @link https://expressjs.com/en/api.html#res.cookie
+ */
+interface CookieOptions {
+  /** Convenient option for setting the expiry time relative to the current time in **milliseconds**. */
+  maxAge?: number | undefined;
+  /** Indicates if the cookie should be signed. */
+  signed?: boolean | undefined;
+  /** Expiry date of the cookie in GMT. If not specified (undefined), creates a session cookie. */
+  expires?: Date | undefined;
+  /** Flags the cookie to be accessible only by the web server. */
+  httpOnly?: boolean | undefined;
+  /** Path for the cookie. Defaults to “/”. */
+  path?: string | undefined;
+  /** Domain name for the cookie. Defaults to the domain name of the app. */
+  domain?: string | undefined;
+  /** Marks the cookie to be used with HTTPS only. */
+  secure?: boolean | undefined;
+  /** A synchronous function used for cookie value encoding. Defaults to encodeURIComponent. */
+  encode?: ((val: string) => string) | undefined;
+  /**
+   * Value of the “SameSite” Set-Cookie attribute.
+   * @link https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00#section-4.1.1.
+   */
+  sameSite?: boolean | "lax" | "strict" | "none" | undefined;
+  /**
+   * Value of the “Priority” Set-Cookie attribute.
+   * @link https://datatracker.ietf.org/doc/html/draft-west-cookie-priority-00#section-4.3
+   */
+  priority?: "low" | "medium" | "high";
+  /** Marks the cookie to use partioned storage. */
+  partitioned?: boolean | undefined;
+}
+type Errback = (err: Error) => void;
+/**
+ * @param P  For most requests, this should be `ParamsDictionary`, but if you're
+ * using this in a route handler for a route that uses a `RegExp`, then `req.params`
+ * will only contains strings, in which case you should use `ParamsFlatDictionary` instead.
+ *
+ * @example
+ *     app.get('/user/:id', (req, res) => res.send(req.params.id)); // implicitly `ParamsDictionary`, parameter is string
+ *     app.get('/user/*id', (req, res) => res.send(req.params.id)); // implicitly `ParamsDictionary`, parameter is string[]
+ *     app.get(/user\/(?<id>.*)/, (req, res) => res.send(req.params.id)); // implicitly `ParamsFlatDictionary`, parameter is string
+ *     app.get(/user\/(.*)/, (req, res) => res.send(req.params[0])); // implicitly `ParamsFlatDictionary`, parameter is string
+ */
+interface Request$1<P = ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> extends http.IncomingMessage, Express.Request {
+  /**
+   * Return request header.
+   *
+   * The `Referrer` header field is special-cased,
+   * both `Referrer` and `Referer` are interchangeable.
+   *
+   * Examples:
+   *
+   *     req.get('Content-Type');
+   *     // => "text/plain"
+   *
+   *     req.get('content-type');
+   *     // => "text/plain"
+   *
+   *     req.get('Something');
+   *     // => undefined
+   *
+   * Aliased as `req.header()`.
+   */
+  get(name: "set-cookie"): string[] | undefined;
+  get(name: string): string | undefined;
+  header(name: "set-cookie"): string[] | undefined;
+  header(name: string): string | undefined;
+  /**
+   * Check if the given `type(s)` is acceptable, returning
+   * the best match when true, otherwise `undefined`, in which
+   * case you should respond with 406 "Not Acceptable".
+   *
+   * The `type` value may be a single mime type string
+   * such as "application/json", the extension name
+   * such as "json", a comma-delimted list such as "json, html, text/plain",
+   * or an array `["json", "html", "text/plain"]`. When a list
+   * or array is given the _best_ match, if any is returned.
+   *
+   * Examples:
+   *
+   *     // Accept: text/html
+   *     req.accepts('html');
+   *     // => "html"
+   *
+   *     // Accept: text/*, application/json
+   *     req.accepts('html');
+   *     // => "html"
+   *     req.accepts('text/html');
+   *     // => "text/html"
+   *     req.accepts('json, text');
+   *     // => "json"
+   *     req.accepts('application/json');
+   *     // => "application/json"
+   *
+   *     // Accept: text/*, application/json
+   *     req.accepts('image/png');
+   *     req.accepts('png');
+   *     // => false
+   *
+   *     // Accept: text/*;q=.5, application/json
+   *     req.accepts(['html', 'json']);
+   *     req.accepts('html, json');
+   *     // => "json"
+   */
+  accepts(): string[];
+  accepts(type: string): string | false;
+  accepts(type: string[]): string | false;
+  accepts(...type: string[]): string | false;
+  /**
+   * Returns the first accepted charset of the specified character sets,
+   * based on the request's Accept-Charset HTTP header field.
+   * If none of the specified charsets is accepted, returns false.
+   *
+   * For more information, or if you have issues or concerns, see accepts.
+   */
+  acceptsCharsets(): string[];
+  acceptsCharsets(charset: string): string | false;
+  acceptsCharsets(charset: string[]): string | false;
+  acceptsCharsets(...charset: string[]): string | false;
+  /**
+   * Returns the first accepted encoding of the specified encodings,
+   * based on the request's Accept-Encoding HTTP header field.
+   * If none of the specified encodings is accepted, returns false.
+   *
+   * For more information, or if you have issues or concerns, see accepts.
+   */
+  acceptsEncodings(): string[];
+  acceptsEncodings(encoding: string): string | false;
+  acceptsEncodings(encoding: string[]): string | false;
+  acceptsEncodings(...encoding: string[]): string | false;
+  /**
+   * Returns the first accepted language of the specified languages,
+   * based on the request's Accept-Language HTTP header field.
+   * If none of the specified languages is accepted, returns false.
+   *
+   * For more information, or if you have issues or concerns, see accepts.
+   */
+  acceptsLanguages(): string[];
+  acceptsLanguages(lang: string): string | false;
+  acceptsLanguages(lang: string[]): string | false;
+  acceptsLanguages(...lang: string[]): string | false;
+  /**
+   * Parse Range header field, capping to the given `size`.
+   *
+   * Unspecified ranges such as "0-" require knowledge of your resource length. In
+   * the case of a byte range this is of course the total number of bytes.
+   * If the Range header field is not given `undefined` is returned.
+   * If the Range header field is given, return value is a result of range-parser.
+   * See more ./types/range-parser/index.d.ts
+   *
+   * NOTE: remember that ranges are inclusive, so for example "Range: users=0-3"
+   * should respond with 4 users when available, not 3.
+   */
+  range(size: number, options?: Options): Ranges | Result | undefined;
+  /**
+   * Return an array of Accepted media types
+   * ordered from highest quality to lowest.
+   */
+  accepted: MediaType[];
+  /**
+   * Check if the incoming request contains the "Content-Type"
+   * header field, and it contains the give mime `type`.
+   *
+   * Examples:
+   *
+   *      // With Content-Type: text/html; charset=utf-8
+   *      req.is('html');
+   *      req.is('text/html');
+   *      req.is('text/*');
+   *      // => true
+   *
+   *      // When Content-Type is application/json
+   *      req.is('json');
+   *      req.is('application/json');
+   *      req.is('application/*');
+   *      // => true
+   *
+   *      req.is('html');
+   *      // => false
+   */
+  is(type: string | string[]): string | false | null;
+  /**
+   * Return the protocol string "http" or "https"
+   * when requested with TLS. When the "trust proxy"
+   * setting is enabled the "X-Forwarded-Proto" header
+   * field will be trusted. If you're running behind
+   * a reverse proxy that supplies https for you this
+   * may be enabled.
+   */
+  readonly protocol: string;
+  /**
+   * Short-hand for:
+   *
+   *    req.protocol == 'https'
+   */
+  readonly secure: boolean;
+  /**
+   * Return the remote address, or when
+   * "trust proxy" is `true` return
+   * the upstream addr.
+   *
+   * Value may be undefined if the `req.socket` is destroyed
+   * (for example, if the client disconnected).
+   */
+  readonly ip: string | undefined;
+  /**
+   * When "trust proxy" is `true`, parse
+   * the "X-Forwarded-For" ip address list.
+   *
+   * For example if the value were "client, proxy1, proxy2"
+   * you would receive the array `["client", "proxy1", "proxy2"]`
+   * where "proxy2" is the furthest down-stream.
+   */
+  readonly ips: string[];
+  /**
+   * Return subdomains as an array.
+   *
+   * Subdomains are the dot-separated parts of the host before the main domain of
+   * the app. By default, the domain of the app is assumed to be the last two
+   * parts of the host. This can be changed by setting "subdomain offset".
+   *
+   * For example, if the domain is "tobi.ferrets.example.com":
+   * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
+   * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
+   */
+  readonly subdomains: string[];
+  /**
+   * Short-hand for `url.parse(req.url).pathname`.
+   */
+  readonly path: string;
+  /**
+   * Contains the hostname derived from the `Host` HTTP header.
+   */
+  readonly hostname: string;
+  /**
+   * Contains the host derived from the `Host` HTTP header.
+   */
+  readonly host: string;
+  /**
+   * Check if the request is fresh, aka
+   * Last-Modified and/or the ETag
+   * still match.
+   */
+  readonly fresh: boolean;
+  /**
+   * Check if the request is stale, aka
+   * "Last-Modified" and / or the "ETag" for the
+   * resource has changed.
+   */
+  readonly stale: boolean;
+  /**
+   * Check if the request was an _XMLHttpRequest_.
+   */
+  readonly xhr: boolean; // body: { username: string; password: string; remember: boolean; title: string; };
+  body: ReqBody; // cookies: { string; remember: boolean; };
+  cookies: any;
+  method: string;
+  params: P;
+  query: ReqQuery;
+  route: any;
+  signedCookies: any;
+  originalUrl: string;
+  url: string;
+  baseUrl: string;
+  app: Application;
+  /**
+   * After middleware.init executed, Request will contain res and next properties
+   * See: express/lib/middleware/init.js
+   */
+  res?: Response<ResBody, LocalsObj> | undefined;
+  next?: NextFunction | undefined;
+}
+interface MediaType {
+  value: string;
+  quality: number;
+  type: string;
+  subtype: string;
+}
+type Send<ResBody = any, T = Response<ResBody>> = (body?: ResBody) => T;
+interface SendFileOptions extends SendOptions {
+  /** Object containing HTTP headers to serve with the file. */
+  headers?: Record<string, unknown>;
+}
+interface DownloadOptions extends SendOptions {
+  /** Object containing HTTP headers to serve with the file. The header `Content-Disposition` will be overridden by the filename argument. */
+  headers?: Record<string, unknown>;
+}
+interface Response<ResBody = any, LocalsObj extends Record<string, any> = Record<string, any>, StatusCode extends number = number> extends http.ServerResponse, Express.Response {
+  /**
+   * Set status `code`.
+   */
+  status(code: StatusCode): this;
+  /**
+   * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
+   * @link http://expressjs.com/4x/api.html#res.sendStatus
+   *
+   * Examples:
+   *
+   *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
+   *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
+   *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
+   *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
+   */
+  sendStatus(code: StatusCode): this;
+  /**
+   * Set Link header field with the given `links`.
+   *
+   * Examples:
+   *
+   *    res.links({
+   *      next: 'http://api.example.com/users?page=2',
+   *      last: 'http://api.example.com/users?page=5'
+   *    });
+   */
+  links(links: any): this;
+  /**
+   * Send a response.
+   *
+   * Examples:
+   *
+   *     res.send(new Buffer('wahoo'));
+   *     res.send({ some: 'json' });
+   *     res.send('<p>some html</p>');
+   *     res.status(404).send('Sorry, cant find that');
+   */
+  send: Send<ResBody, this>;
+  /**
+   * Send JSON response.
+   *
+   * Examples:
+   *
+   *     res.json(null);
+   *     res.json({ user: 'tj' });
+   *     res.status(500).json('oh noes!');
+   *     res.status(404).json('I dont have that');
+   */
+  json: Send<ResBody, this>;
+  /**
+   * Send JSON response with JSONP callback support.
+   *
+   * Examples:
+   *
+   *     res.jsonp(null);
+   *     res.jsonp({ user: 'tj' });
+   *     res.status(500).jsonp('oh noes!');
+   *     res.status(404).jsonp('I dont have that');
+   */
+  jsonp: Send<ResBody, this>;
+  /**
+   * Transfer the file at the given `path`.
+   *
+   * Automatically sets the _Content-Type_ response header field.
+   * The callback `fn(err)` is invoked when the transfer is complete
+   * or when an error occurs. Be sure to check `res.headersSent`
+   * if you wish to attempt responding, as the header and some data
+   * may have already been transferred.
+   *
+   * Options:
+   *
+   *   - `maxAge`   defaulting to 0 (can be string converted by `ms`)
+   *   - `root`     root directory for relative filenames
+   *   - `headers`  object of headers to serve with file
+   *   - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them
+   *
+   * Other options are passed along to `send`.
+   *
+   * Examples:
+   *
+   *  The following example illustrates how `res.sendFile()` may
+   *  be used as an alternative for the `static()` middleware for
+   *  dynamic situations. The code backing `res.sendFile()` is actually
+   *  the same code, so HTTP cache support etc is identical.
+   *
+   *     app.get('/user/:uid/photos/:file', function(req, res){
+   *       var uid = req.params.uid
+   *         , file = req.params.file;
+   *
+   *       req.user.mayViewFilesFrom(uid, function(yes){
+   *         if (yes) {
+   *           res.sendFile('/uploads/' + uid + '/' + file);
+   *         } else {
+   *           res.send(403, 'Sorry! you cant see that.');
+   *         }
+   *       });
+   *     });
+   *
+   * @api public
+   */
+  sendFile(path: string, fn?: Errback): void;
+  sendFile(path: string, options: SendFileOptions, fn?: Errback): void;
+  /**
+   * Transfer the file at the given `path` as an attachment.
+   *
+   * Optionally providing an alternate attachment `filename`,
+   * and optional callback `fn(err)`. The callback is invoked
+   * when the data transfer is complete, or when an error has
+   * ocurred. Be sure to check `res.headersSent` if you plan to respond.
+   *
+   * The optional options argument passes through to the underlying
+   * res.sendFile() call, and takes the exact same parameters.
+   *
+   * This method uses `res.sendFile()`.
+   */
+  download(path: string, fn?: Errback): void;
+  download(path: string, filename: string, fn?: Errback): void;
+  download(path: string, filename: string, options: DownloadOptions, fn?: Errback): void;
+  /**
+   * Set _Content-Type_ response header with `type` through `mime.lookup()`
+   * when it does not contain "/", or set the Content-Type to `type` otherwise.
+   *
+   * Examples:
+   *
+   *     res.type('.html');
+   *     res.type('html');
+   *     res.type('json');
+   *     res.type('application/json');
+   *     res.type('png');
+   */
+  contentType(type: string): this;
+  /**
+   * Set _Content-Type_ response header with `type` through `mime.lookup()`
+   * when it does not contain "/", or set the Content-Type to `type` otherwise.
+   *
+   * Examples:
+   *
+   *     res.type('.html');
+   *     res.type('html');
+   *     res.type('json');
+   *     res.type('application/json');
+   *     res.type('png');
+   */
+  type(type: string): this;
+  /**
+   * Respond to the Acceptable formats using an `obj`
+   * of mime-type callbacks.
+   *
+   * This method uses `req.accepted`, an array of
+   * acceptable types ordered by their quality values.
+   * When "Accept" is not present the _first_ callback
+   * is invoked, otherwise the first match is used. When
+   * no match is performed the server responds with
+   * 406 "Not Acceptable".
+   *
+   * Content-Type is set for you, however if you choose
+   * you may alter this within the callback using `res.type()`
+   * or `res.set('Content-Type', ...)`.
+   *
+   *    res.format({
+   *      'text/plain': function(){
+   *        res.send('hey');
+   *      },
+   *
+   *      'text/html': function(){
+   *        res.send('<p>hey</p>');
+   *      },
+   *
+   *      'appliation/json': function(){
+   *        res.send({ message: 'hey' });
+   *      }
+   *    });
+   *
+   * In addition to canonicalized MIME types you may
+   * also use extnames mapped to these types:
+   *
+   *    res.format({
+   *      text: function(){
+   *        res.send('hey');
+   *      },
+   *
+   *      html: function(){
+   *        res.send('<p>hey</p>');
+   *      },
+   *
+   *      json: function(){
+   *        res.send({ message: 'hey' });
+   *      }
+   *    });
+   *
+   * By default Express passes an `Error`
+   * with a `.status` of 406 to `next(err)`
+   * if a match is not made. If you provide
+   * a `.default` callback it will be invoked
+   * instead.
+   */
+  format(obj: any): this;
+  /**
+   * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+   */
+  attachment(filename?: string): this;
+  /**
+   * Set header `field` to `val`, or pass
+   * an object of header fields.
+   *
+   * Examples:
+   *
+   *    res.set('Foo', ['bar', 'baz']);
+   *    res.set('Accept', 'application/json');
+   *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+   *
+   * Aliased as `res.header()`.
+   */
+  set(field: any): this;
+  set(field: string, value?: string | string[]): this;
+  header(field: any): this;
+  header(field: string, value?: string | string[]): this; // Property indicating if HTTP headers has been sent for the response.
+  headersSent: boolean;
+  /** Get value for header `field`. */
+  get(field: string): string | undefined;
+  /** Clear cookie `name`. */
+  clearCookie(name: string, options?: CookieOptions): this;
+  /**
+   * Set cookie `name` to `val`, with the given `options`.
+   *
+   * Options:
+   *
+   *    - `maxAge`   max-age in milliseconds, converted to `expires`
+   *    - `signed`   sign the cookie
+   *    - `path`     defaults to "/"
+   *
+   * Examples:
+   *
+   *    // "Remember Me" for 15 minutes
+   *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+   *
+   *    // save as above
+   *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+   */
+  cookie(name: string, val: string, options: CookieOptions): this;
+  cookie(name: string, val: any, options: CookieOptions): this;
+  cookie(name: string, val: any): this;
+  /**
+   * Set the location header to `url`.
+   *
+   * Examples:
+   *
+   *    res.location('/foo/bar').;
+   *    res.location('http://example.com');
+   *    res.location('../login'); // /blog/post/1 -> /blog/login
+   *
+   * Mounting:
+   *
+   *   When an application is mounted and `res.location()`
+   *   is given a path that does _not_ lead with "/" it becomes
+   *   relative to the mount-point. For example if the application
+   *   is mounted at "/blog", the following would become "/blog/login".
+   *
+   *      res.location('login');
+   *
+   *   While the leading slash would result in a location of "/login":
+   *
+   *      res.location('/login');
+   */
+  location(url: string): this;
+  /**
+   * Redirect to the given `url` with optional response `status`
+   * defaulting to 302.
+   *
+   * The resulting `url` is determined by `res.location()`, so
+   * it will play nicely with mounted apps, relative paths, etc.
+   *
+   * Examples:
+   *
+   *    res.redirect('/foo/bar');
+   *    res.redirect('http://example.com');
+   *    res.redirect(301, 'http://example.com');
+   *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+   */
+  redirect(url: string): void;
+  redirect(status: number, url: string): void;
+  /**
+   * Render `view` with the given `options` and optional callback `fn`.
+   * When a callback function is given a response will _not_ be made
+   * automatically, otherwise a response of _200_ and _text/html_ is given.
+   *
+   * Options:
+   *
+   *  - `cache`     boolean hinting to the engine it should cache
+   *  - `filename`  filename of the view being rendered
+   */
+  render(view: string, options?: object, callback?: (err: Error, html: string) => void): void;
+  render(view: string, callback?: (err: Error, html: string) => void): void;
+  locals: LocalsObj & Locals;
+  charset: string;
+  /**
+   * Adds the field to the Vary response header, if it is not there already.
+   * Examples:
+   *
+   *     res.vary('User-Agent').render('docs');
+   */
+  vary(field: string): this;
+  app: Application;
+  /**
+   * Appends the specified value to the HTTP response header field.
+   * If the header is not already set, it creates the header with the specified value.
+   * The value parameter can be a string or an array.
+   *
+   * Note: calling res.set() after res.append() will reset the previously-set header value.
+   *
+   * @since 4.11.0
+   */
+  append(field: string, value?: string[] | string): this;
+  /**
+   * After middleware.init executed, Response will contain req property
+   * See: express/lib/middleware/init.js
+   */
+  req: Request$1;
+}
+type RequestParamHandler = (req: Request$1, res: Response, next: NextFunction, value: any, name: string) => any;
+type ApplicationRequestHandler<T> = IRouterHandler<T> & IRouterMatcher<T> & ((...handlers: RequestHandlerParams[]) => T);
+interface Application<LocalsObj extends Record<string, any> = Record<string, any>> extends EventEmitter, IRouter, Express.Application {
+  /**
+   * Express instance itself is a request handler, which could be invoked without
+   * third argument.
+   */
+  (req: Request$1 | http.IncomingMessage, res: Response | http.ServerResponse): any;
+  /**
+   * Initialize the server.
+   *
+   *   - setup default configuration
+   *   - setup default middleware
+   *   - setup route reflection methods
+   */
+  init(): void;
+  /**
+   * Initialize application configuration.
+   */
+  defaultConfiguration(): void;
+  /**
+   * Register the given template engine callback `fn`
+   * as `ext`.
+   *
+   * By default will `require()` the engine based on the
+   * file extension. For example if you try to render
+   * a "foo.jade" file Express will invoke the following internally:
+   *
+   *     app.engine('jade', require('jade').__express);
+   *
+   * For engines that do not provide `.__express` out of the box,
+   * or if you wish to "map" a different extension to the template engine
+   * you may use this method. For example mapping the EJS template engine to
+   * ".html" files:
+   *
+   *     app.engine('html', require('ejs').renderFile);
+   *
+   * In this case EJS provides a `.renderFile()` method with
+   * the same signature that Express expects: `(path, options, callback)`,
+   * though note that it aliases this method as `ejs.__express` internally
+   * so if you're using ".ejs" extensions you dont need to do anything.
+   *
+   * Some template engines do not follow this convention, the
+   * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
+   * library was created to map all of node's popular template
+   * engines to follow this convention, thus allowing them to
+   * work seamlessly within Express.
+   */
+  engine(ext: string, fn: (path: string, options: object, callback: (e: any, rendered?: string) => void) => void): this;
+  /**
+   * Assign `setting` to `val`, or return `setting`'s value.
+   *
+   *    app.set('foo', 'bar');
+   *    app.get('foo');
+   *    // => "bar"
+   *    app.set('foo', ['bar', 'baz']);
+   *    app.get('foo');
+   *    // => ["bar", "baz"]
+   *
+   * Mounted servers inherit their parent server's settings.
+   */
+  set(setting: string, val: any): this;
+  get: ((name: string) => any) & IRouterMatcher<this>;
+  param(name: string | string[], handler: RequestParamHandler): this;
+  /**
+   * Return the app's absolute pathname
+   * based on the parent(s) that have
+   * mounted it.
+   *
+   * For example if the application was
+   * mounted as "/admin", which itself
+   * was mounted as "/blog" then the
+   * return value would be "/blog/admin".
+   */
+  path(): string;
+  /**
+   * Check if `setting` is enabled (truthy).
+   *
+   *    app.enabled('foo')
+   *    // => false
+   *
+   *    app.enable('foo')
+   *    app.enabled('foo')
+   *    // => true
+   */
+  enabled(setting: string): boolean;
+  /**
+   * Check if `setting` is disabled.
+   *
+   *    app.disabled('foo')
+   *    // => true
+   *
+   *    app.enable('foo')
+   *    app.disabled('foo')
+   *    // => false
+   */
+  disabled(setting: string): boolean;
+  /** Enable `setting`. */
+  enable(setting: string): this;
+  /** Disable `setting`. */
+  disable(setting: string): this;
+  /**
+   * Render the given view `name` name with `options`
+   * and a callback accepting an error and the
+   * rendered template string.
+   *
+   * Example:
+   *
+   *    app.render('email', { name: 'Tobi' }, function(err, html){
+   *      // ...
+   *    })
+   */
+  render(name: string, options?: object, callback?: (err: Error, html: string) => void): void;
+  render(name: string, callback: (err: Error, html: string) => void): void;
+  /**
+   * Listen for connections.
+   *
+   * A node `http.Server` is returned, with this
+   * application (which is a `Function`) as its
+   * callback. If you wish to create both an HTTP
+   * and HTTPS server you may do so with the "http"
+   * and "https" modules as shown here:
+   *
+   *    var http = require('http')
+   *      , https = require('https')
+   *      , express = require('express')
+   *      , app = express();
+   *
+   *    http.createServer(app).listen(80);
+   *    https.createServer({ ... }, app).listen(443);
+   */
+  listen(port: number, hostname: string, backlog: number, callback?: (error?: Error) => void): http.Server;
+  listen(port: number, hostname: string, callback?: (error?: Error) => void): http.Server;
+  listen(port: number, callback?: (error?: Error) => void): http.Server;
+  listen(callback?: (error?: Error) => void): http.Server;
+  listen(path: string, callback?: (error?: Error) => void): http.Server;
+  listen(handle: any, listeningListener?: (error?: Error) => void): http.Server;
+  router: Router$1;
+  settings: any;
+  resource: any;
+  map: any;
+  locals: LocalsObj & Locals;
+  /**
+   * The app.routes object houses all of the routes defined mapped by the
+   * associated HTTP verb. This object may be used for introspection
+   * capabilities, for example Express uses this internally not only for
+   * routing but to provide default OPTIONS behaviour unless app.options()
+   * is used. Your application or framework may also remove routes by
+   * simply by removing them from this object.
+   */
+  routes: any;
+  /**
+   * Used to get all registered routes in Express Application
+   */
+  _router: any;
+  use: ApplicationRequestHandler<this>;
+  /**
+   * The mount event is fired on a sub-app, when it is mounted on a parent app.
+   * The parent app is passed to the callback function.
+   *
+   * NOTE:
+   * Sub-apps will:
+   *  - Not inherit the value of settings that have a default value. You must set the value in the sub-app.
+   *  - Inherit the value of settings with no default value.
+   */
+  on: (event: "mount", callback: (parent: Application) => void) => this;
+  /**
+   * The app.mountpath property contains one or more path patterns on which a sub-app was mounted.
+   */
+  mountpath: string | string[];
+}
+interface Express extends Application {
+  request: Request$1;
+  response: Response;
+}
+//#endregion
+//#region src/botDetector/routes/visitorLog.d.ts
+declare const router: Router$1;
+//#endregion
+//#region src/botDetector/db/generator.d.ts
+declare function runGeneration(): Promise<void>;
+//#endregion
+//#region src/botDetector/penalties/banIP.d.ts
+declare function banIp(ip: string, info: BannedInfo): Promise<void> | void;
+//#endregion
+//#region src/botDetector/helpers/UAparser.d.ts
+declare function parseUA(userAgent: string | number): ParsedUAResult;
+//#endregion
+//#region src/botDetector/helpers/getIPInformation.d.ts
+declare function getData(ip: string): GeoResponse;
+//#endregion
+//#region src/botDetector/db/updateIsBot.d.ts
+declare function updateIsBot(isBot: boolean, cookie: string): Promise<void>;
+//#endregion
+//#region src/botDetector/db/updateBanned.d.ts
+declare function updateBannedIP(cookie: string, ipAddress: string, country: string, user_agent: string, info: BannedInfo): Promise<void>;
+//#endregion
+//#region src/botDetector/db/warmUp.d.ts
+declare function warmUp(): Promise<void>;
+//#endregion
+//#region src/botDetector/db/customUpdate.d.ts
+interface VisitorFingerPrint {
+  userAgent: string;
+  ipAddress: string;
+  country: string;
+  region: string;
+  regionName: string;
+  city: string;
+  district: string;
+  lat: string;
+  lon: string;
+  timezone: string;
+  currency: string;
+  isp: string;
+  org: string;
+  as: string;
+  device_type: string;
+  browser: string;
+  proxy: boolean;
+  hosting: boolean;
+  deviceVendor: string;
+  deviceModel: string;
+  browserType: string;
+  browserVersion: string;
+  os: string;
+}
+declare function updateVisitors(data: VisitorFingerPrint, cookie: string, visitor_id: string): Promise<{
+  success: boolean;
+  reason?: string;
+}>;
+//#endregion
+//#region src/botDetector/checkers/CheckerRegistry.d.ts
+declare const CheckerRegistry: {
+  register(checker: IBotChecker<BanReasonCode>): void;
+  getEnabled(phase: "cheap" | "heavy", config: BotDetectorConfig): IBotChecker<BanReasonCode>[];
+  clear(): void;
+};
+//#endregion
+//#region src/botDetector/helpers/exceptions.d.ts
+declare class BadBotDetected extends Error {
+  constructor(message?: string);
+}
+declare class GoodBotDetected extends Error {
+  constructor(message?: string);
+}
+//#endregion
+export { router as ApiResponse, BadBotDetected, type BanReasonCode, type BannedInfo, type BotDetectorConfig, type BotDetectorConfigInput, type CacheConfig, CheckerRegistry, DbConfig, type GeoResponse, GoodBotDetected, type IBotChecker, type ParsedUAResult, SupportedDbDrivers, SupportedDrivers, type ThreatRecordModified, type ValidationContext, type VisitorFingerPrint, banIp, configuration as defineConfiguration, validator as detectBots, getBatchQueue, getDataSources, getData as getGeoData, getStorage, parseUA, runGeneration, updateBannedIP, updateIsBot, updateVisitors, type userValidation, warmUp };
+//# sourceMappingURL=main.d.mts.map