import { A as AutomationAssessment } from './version-Cv9x48z9.cjs'; export { a as AutomationConfidence, b as AutomationKind, V as VERSION, i as isBotUserAgent } from './version-Cv9x48z9.cjs'; interface ExtendedDocument extends Document { __selenium_evaluate?: unknown; __selenium_unwrapped?: unknown; __webdriver_evaluate?: unknown; __driver_evaluate?: unknown; __fxdriver_evaluate?: unknown; __driver_unwrapped?: unknown; __webdriver_unwrapped?: unknown; } interface ExtendedNavigator extends Omit { gpu?: GPU; deviceMemory?: number; /** Gecko-only OS/CPU string; absent in every other engine. */ oscpu?: string; connection?: { rtt?: number; }; userAgentData?: { brands: Array<{ brand: string; version: string; }>; mobile?: boolean; platform?: string; getHighEntropyValues?: (hints: string[]) => Promise<{ brands?: Array<{ brand: string; version: string; }>; fullVersionList?: Array<{ brand: string; version: string; }>; mobile?: boolean; platform?: string; platformVersion?: string; architecture?: string; bitness?: string; model?: string; formFactors?: string[]; }>; }; } interface ExtendedWindow extends Omit { Blob?: typeof Blob; Date?: DateConstructor; Error?: ErrorConstructor; Function?: FunctionConstructor; Intl?: typeof Intl; MimeType?: { prototype: MimeType; new (): MimeType; }; MimeTypeArray?: { prototype: MimeTypeArray; new (): MimeTypeArray; }; Notification?: typeof Notification; Plugin?: { prototype: Plugin; new (): Plugin; }; PluginArray?: { prototype: PluginArray; new (): PluginArray; }; URL?: typeof URL; Worker?: typeof Worker; console?: Console; callPhantom?: unknown; callSelenium?: unknown; _phantom?: unknown; __nightmare?: unknown; __playwright?: unknown; __pw_manual?: unknown; __playwright__binding__?: unknown; __pwInitScripts?: unknown; __puppeteer_evaluation_script__?: unknown; _WEBDRIVER_ELEM_CACHE?: unknown; _Selenium_IDE_Recorder?: unknown; _selenium?: unknown; calledSelenium?: unknown; awesomium?: unknown; RunPerfTest?: unknown; CefSharp?: unknown; fmget_targets?: unknown; geb?: unknown; nightmare?: unknown; __phantomas?: unknown; wdioElectron?: unknown; process?: { type?: string; versions?: { electron?: string; }; }; chrome?: { runtime?: unknown; }; domAutomation?: unknown; domAutomationController?: unknown; document: ExtendedDocument; navigator: ExtendedNavigator; } type InstantConfidenceLevel = "high" | "medium" | "low"; /** One weighted instant check, mirroring behavioral and server signals. */ interface InstantSignal { /** Matches the corresponding boolean field on {@link InstantClientResult} */ id: string; description: string; triggered: boolean; weight: number; confidence: InstantConfidenceLevel; /** `weight` when triggered, else 0 */ score: number; } interface InstantDetectorOptions { /** * Suspicion score at/above which `isLegitClient` becomes false. * Defaults to 0.5. Definitive automation markers weigh 0.9–1.0 (blocking on * their own); ambiguous, false-positive-prone checks weigh 0.25–0.45 so they * only block in combination. */ scoreThreshold?: number; } interface InstantClientResult { isWebDriver: boolean; isPhantomJS: boolean; isNightmare: boolean; isSelenium: boolean; isDomAutomation: boolean; isHeadless: boolean; isSuspiciousResolution: boolean; isUserAgentValid: boolean; isWebGLSupported: boolean; isModern: boolean; isMissingChromeObject: boolean; isSoftwareRenderer: boolean; isSuspiciousWindowDimensions: boolean; isEmptyPlugins: boolean; isAutomationArtifacts: boolean; isPlaywright: boolean; isPuppeteer: boolean; isChromeDriver: boolean; isSuspiciousWebDriverDescriptor: boolean; isUserAgentDataMismatch: boolean; isLanguageInconsistent: boolean; isPluginMimeTypeInconsistent: boolean; isNativeFunctionTampered: boolean; isNavigatorIdentityInconsistent: boolean; isPluginArrayInconsistent: boolean; isIframeInconsistent: boolean; isErrorStackAutomation: boolean; isDefaultAutomationViewport: boolean; isSuspiciousHardware: boolean; isZeroConnectionRtt: boolean; isCanvasTampered: boolean; isEngineInconsistent: boolean; isGpuPlatformMismatch: boolean; isMediaQueryInconsistent: boolean; isScreenGeometryInconsistent: boolean; isMissingProprietaryCodecs: boolean; isCanvasNoiseInjected: boolean; isTimezoneInconsistent: boolean; isMissingGreaseBrand: boolean; isChromium: boolean; /** * 0 (human) to 1 (definitely automated), aggregated as `1 - Π(1 - weightᵢ)` * over triggered signals — the same formula the behavioral and server layers use. */ suspicionScore: number; confidence: InstantConfidenceLevel; /** Per-check breakdown with weights, for explainability */ signals: InstantSignal[]; isLegitClient: boolean; /** Best-effort family attribution with evidence and plausible alternatives. */ automation: AutomationAssessment; } type InstantResultMetadata = "isChromium" | "suspicionScore" | "confidence" | "signals" | "isLegitClient" | "automation"; type ExtendedInstantCheck = "isNativeFunctionTampered" | "isNavigatorIdentityInconsistent" | "isPluginArrayInconsistent" | "isIframeInconsistent" | "isErrorStackAutomation" | "isDefaultAutomationViewport" | "isSuspiciousHardware" | "isZeroConnectionRtt" | "isCanvasTampered" | "isEngineInconsistent" | "isGpuPlatformMismatch" | "isMediaQueryInconsistent" | "isScreenGeometryInconsistent" | "isMissingProprietaryCodecs" | "isCanvasNoiseInjected" | "isTimezoneInconsistent" | "isMissingGreaseBrand"; /** Boolean inputs accepted by {@link buildInstantSignals}. */ type InstantSignalChecks = Omit & Partial>; interface InstantClientAsyncResult extends InstantClientResult { /** `true`/`false` on Chromium; `null` when the check does not apply */ isShaderF16Supported: boolean | null; /** CDP serialized a diagnostic object; `null` when console probing is unavailable */ isCdpDetected: boolean | null; /** Notification and Permissions API states contradict; `null` when unavailable */ isNotificationPermissionInconsistent: boolean | null; /** High-entropy Client Hints contradict the User-Agent; `null` when unavailable */ isHighEntropyUserAgentDataMismatch: boolean | null; /** Worker navigator values contradict the main realm; `null` when unavailable */ isWorkerInconsistent: boolean | null; /** Worker navigator exposes `webdriver === true`; `null` when unavailable */ isWebDriverInWorker?: boolean | null; /** Worker WebGL identity contradicts the main realm; `null` when unavailable */ isWorkerWebGLInconsistent?: boolean | null; /** CDP serialized a diagnostic object inside a worker; `null` when unavailable */ isCdpDetectedInWorker: boolean | null; /** Desktop Chromium enumerated no media devices at all; `null` when unavailable */ isMissingMediaDevices: boolean | null; /** * Installed speech voices contradict the claimed platform; `null` when * unavailable. Added after the original public shape; optional so existing * producers of this type keep compiling. */ isVoiceListInconsistent?: boolean | null; } /** Async-only values accepted by {@link buildInstantSignals}. */ type InstantAsyncChecks = Pick; type ConfidenceLevel = "high" | "medium" | "low"; interface BehavioralSignal { id: string; description: string; triggered: boolean; weight: number; confidence: ConfidenceLevel; score: number; } interface BehavioralSampleCounts { mouseMoves: number; scrolls: number; keyPresses: number; clicks: number; touches: number; syntheticEvents: number; } interface MouseSample { x: number; y: number; /** Browser-reported delta from the previous mouse event, when collected. */ movementX?: number; /** Browser-reported delta from the previous mouse event, when collected. */ movementY?: number; /** Page/screen coordinates used to detect a Chromium CDP Input leak. */ pageX?: number; pageY?: number; screenX?: number; screenY?: number; /** Whether browser chrome was hidden when this event was collected. */ isFullscreen?: boolean; t: number; isTrusted: boolean; } interface ScrollSample { deltaY: number; t: number; isTrusted: boolean; } interface KeySample { t: number; isTrusted: boolean; /** `true` for auto-repeat while a key is held — excluded from typing-rhythm analysis */ repeat?: boolean; } interface ClickSample { x: number; y: number; t: number; isTrusted: boolean; /** `MouseEvent.detail` — `0` for keyboard-activated clicks (Enter/Space on a control) */ detail?: number; /** Page/screen coordinates used to detect a Chromium CDP Input leak. */ pageX?: number; pageY?: number; screenX?: number; screenY?: number; /** Whether browser chrome was hidden when this event was collected. */ isFullscreen?: boolean; } interface TouchSample { t: number; isTrusted: boolean; /** * Primary contact point. Absent in samples recorded before touch gestures * were analysed, which the gesture heuristics skip rather than guess at. */ x?: number; y?: number; /** * `"start"` for a new contact, `"move"` while a finger drags. Absent in * older samples, which were all contacts and are treated as `"start"`. */ kind?: "start" | "move"; } interface BehavioralSamples { mouseMoves: MouseSample[]; scrolls: ScrollSample[]; keyPresses: KeySample[]; clicks: ClickSample[]; /** Touch activity — exempts tap-driven clicks from mouse-based signals */ touches?: TouchSample[]; observationMs: number; } interface BehavioralClientResult { suspicionScore: number; confidence: ConfidenceLevel; signals: BehavioralSignal[]; sampleCounts: BehavioralSampleCounts; observationMs: number; isLegitClient: boolean; } interface BehavioralDetectorOptions { context?: ExtendedWindow; minObservationMs?: number; scoreThreshold?: number; pollIntervalMs?: number; /** * Retain only samples from the last N milliseconds so a long-lived * `start()` (without `stop()`) cannot grow memory without bound and each * poll scores recent behavior. Defaults to 60000; set `Infinity` to keep * everything. Short one-shot `observe()` calls are unaffected. */ sampleWindowMs?: number; onUpdate?: (result: BehavioralClientResult) => void; } interface BehavioralClientDetector { start(): void; stop(): void; reset(): void; getResult(): BehavioralClientResult; observe(durationMs?: number): Promise; } /** * Combines triggered signal weights into one score: * `1 - Π(1 - weightᵢ)` — independent-probability union, so extra signals * always raise the score but never past 1. * @internal */ declare function aggregateSuspicionScore(signals: BehavioralSignal[]): number; /** * Confidence in the verdict based on sample volume and high-confidence signal hits. * @internal */ declare function resolveConfidence(signals: BehavioralSignal[], sampleCounts: BehavioralSampleCounts, suspicionScore: number): ConfidenceLevel; /** * Scores a set of recorded interaction samples without running a detector — * useful for analyzing samples collected elsewhere (e.g. beaconed to a server). */ declare function analyzeBehavioralSamples(samples: BehavioralSamples, scoreThreshold?: number): BehavioralClientResult; /** * Mouse path is a near-perfect line traversed at near-constant speed. * @internal */ declare function hasLinearMouseMovement(mouseMoves: MouseSample[]): boolean; /** More than 50 mouse events all report zero browser-provided movement deltas. */ declare function hasZeroMouseMovementDeltas(mouseMoves: MouseSample[]): boolean; declare function hasTeleportMouse(mouseMoves: MouseSample[]): boolean; /** * Repeated trusted pointer events expose CDP Input's page/screen coordinate * equality. Fullscreen and keyboard-activated clicks are excluded. * @internal */ declare function hasCdpInputCoordinateLeak(mouseMoves: MouseSample[], clicks: ClickSample[]): boolean; /** * A pointer click landed with no mouse or touch activity in the preceding 2s. * @internal */ declare function hasClickWithoutMouseMovement(mouseMoves: MouseSample[], clicks: ClickSample[], touches?: TouchSample[]): boolean; /** * Pointer clicks were recorded in a session with zero mouse or touch events. * @internal */ declare function hasNoMouseActivity(mouseMoves: MouseSample[], clicks: ClickSample[], touches?: TouchSample[]): boolean; /** * Scroll deltas and inter-event timing are too uniform to be a human hand. * @internal */ declare function hasLinearScroll(scrollEvents: ScrollSample[]): boolean; /** * Keystroke rhythm is metronome-uniform or faster than humanly possible. * @internal */ declare function hasLinearTyping(keyPresses: KeySample[]): boolean; /** * A swipe traced a near-perfect line at near-constant speed. Real fingers * arc and vary; a dispatched touch sequence interpolates. * @internal */ declare function hasLinearTouchMovement(touches?: TouchSample[]): boolean; /** * A contact point jumped an implausible distance mid-gesture. * @internal */ declare function hasTeleportTouch(touches?: TouchSample[]): boolean; /** * Taps land on a metronome, or faster than a finger can lift and fall. * @internal */ declare function hasLinearTapRhythm(touches?: TouchSample[]): boolean; /** * Any observed event was script-dispatched (`isTrusted === false`). * @internal */ declare function hasSyntheticEvents(samples: BehavioralSamples): boolean; /** * Evaluates every behavioral heuristic and returns the weighted signal list. * @internal */ declare function buildBehavioralSignals(samples: BehavioralSamples): BehavioralSignal[]; /** * Creates a detector that observes mouse, wheel, keyboard, click, and touch * events on `options.context` (defaults to `globalThis`) and scores how * robotic the interaction looks. * * Call `observe(ms)` for a one-shot observation, or `start()`/`stop()` + * `getResult()` to manage the window yourself. Pass `onUpdate` to receive * periodic results while observing. * * @example * const result = await createBehavioralClientDetector({ context: window }).observe(10_000); * if (!result.isLegitClient) challenge(); */ declare function createBehavioralClientDetector(options?: BehavioralDetectorOptions): BehavioralClientDetector; /** Chromium UA without the browser-provided `window.chrome` object */ declare function isMissingChromeObject(context: ExtendedWindow): boolean; /** WebGL reports a software renderer such as SwiftShader or llvmpipe */ declare function isSoftwareRenderer(context: ExtendedWindow): boolean; /** * The WebGL renderer names a graphics backend the User-Agent's platform * cannot provide — Direct3D off Windows, Metal off Apple, Adreno off Android. */ declare function isGpuPlatformMismatch(context: ExtendedWindow): boolean; /** Window has no browser chrome and sits at the origin — common in headless automation */ declare function isSuspiciousWindowDimensions(context: ExtendedWindow): boolean; /** Desktop Chromium with an empty plugin list */ declare function isEmptyPlugins(context: ExtendedWindow): boolean; /** Known automation framework/runtime artifacts on `window` / `document` */ declare function isAutomationArtifacts(context: ExtendedWindow): boolean; /** Playwright bindings or init-script registries leaked into the page realm. */ declare function isPlaywright(context: ExtendedWindow): boolean; /** Puppeteer evaluation helpers leaked into the page realm. */ declare function isPuppeteer(context: ExtendedWindow): boolean; /** ChromeDriver/Selenium `cdc_` and element-cache artifacts. */ declare function isChromeDriver(context: ExtendedWindow): boolean; /** UA major version or mobile/platform claim conflicts with User-Agent Client Hints. */ declare function isUserAgentDataMismatch(context: ExtendedWindow): boolean; /** `navigator.language` disagrees with the first entry in `navigator.languages`. */ declare function isLanguageInconsistent(context: ExtendedWindow): boolean; /** Plugin and MIME-type arrays were patched independently and no longer agree. */ declare function isPluginMimeTypeInconsistent(context: ExtendedWindow): boolean; /** Core functions or Navigator getters no longer have browser-native source. */ declare function isNativeFunctionTampered(context: ExtendedWindow): boolean; /** Legacy Navigator identity claims contradict the User-Agent or touch support. */ declare function isNavigatorIdentityInconsistent(context: ExtendedWindow): boolean; /** * `userAgentData.brands` omits Chromium's GREASE entry. * * Every Chromium build injects one, so a list without it was assembled by hand * — the signature of Client Hints set through an automation override rather * than produced by the browser. */ declare function isMissingGreaseBrand(context: ExtendedWindow): boolean; /** PluginArray/MimeTypeArray objects or entries do not use native prototypes. */ declare function isPluginArrayInconsistent(context: ExtendedWindow): boolean; /** * A fresh same-origin iframe hands back the page's own realm, or disagrees * with it about `navigator.webdriver`. * * Only signals that page and extension content cannot produce are used. An * `about:blank` frame is the one realm every content script reaches — ad * blockers, privacy tools, and the extensions Chromium forks ship built in all * inject there — so anything that injected code could define or proxy is out: * * - Navigator values are not compared here at all. That is exactly what * fingerprint protection rewrites inconsistently between realms, and * `isWorkerInconsistent` already covers persona spoofing from a worker, * which content scripts do not touch. * - `self.get` is not probed, since injected code can define it. * - Shared timer functions are not treated as evidence, since a tool that * neuters iframes can proxy them onto the parent's. * * What remains cannot happen in a real browser: a frame whose `window` or * `navigator` *is* the page's object is a stealth patch returning the parent * realm, and `webdriver` is set by the browser itself, so the two realms only * disagree when a patch reached one and not the other. */ declare function isIframeInconsistent(context: ExtendedWindow): boolean; /** Error stacks contain automation-specific source URLs or injected frames. */ declare function isErrorStackAutomation(context: ExtendedWindow): boolean; /** Screen/viewport matches common untouched automation defaults. */ declare function isDefaultAutomationViewport(context: ExtendedWindow): boolean; /** Spoofed or implausible CPU/device-memory combinations. */ declare function isSuspiciousHardware(context: ExtendedWindow): boolean; /** Network Information reports the zero-RTT default common in headless contexts. */ declare function isZeroConnectionRtt(context: ExtendedWindow): boolean; /** A deterministic 1px canvas write was modified on readback. */ declare function isCanvasTampered(context: ExtendedWindow): boolean; /** * Canvas rasterisation changes between two identical renders. * * Drawing is deterministic within a session on every real engine, and the * fingerprint protection that ships in browsers — Brave's farbling, Firefox in * resistFingerprinting mode — derives its noise from a per-session, per-origin * seed, so it too returns the same pixels twice. Only a spoofer that * re-randomises on every call disagrees with itself. */ declare function isCanvasNoiseInjected(context: ExtendedWindow): boolean; /** * The IANA time zone `Intl` resolves disagrees with `Date`'s UTC offset. * * Both read the same host setting, so they cannot legitimately diverge. Tools * that relocate a browser by patching one of the two — a `Date.getTimezoneOffset` * override, or a CDP timezone override applied to only one realm — split them. */ declare function isTimezoneInconsistent(context: ExtendedWindow): boolean; /** * The JavaScript engine contradicts the browser the User-Agent claims. * * `eval.toString().length` is 33 in V8 (single-line native source) and 37 in * SpiderMonkey and JavaScriptCore, and `InternalError` exists only in * SpiderMonkey — neither is touched by User-Agent spoofing. */ declare function isEngineInconsistent(context: ExtendedWindow): boolean; /** * CSS media queries contradict the values `navigator`/`screen` report. * Stealth patches override the JS getters but not the CSS engine behind them. */ declare function isMediaQueryInconsistent(context: ExtendedWindow): boolean; /** `screen` reports geometry no display pipeline can produce. */ declare function isScreenGeometryInconsistent(context: ExtendedWindow): boolean; /** * A Chromium build without H.264 — the bundled Chromium that Playwright and * unbranded automation images ship, as opposed to Google Chrome. */ declare function isMissingProprietaryCodecs(context: ExtendedWindow): boolean; /** `navigator.webdriver` was patched (own property) or deleted from the prototype */ declare function isSuspiciousWebDriverDescriptor(context: ExtendedWindow): boolean; interface WorkerChecks { isWorkerInconsistent: boolean | null; /** Added after the original public shape; optional for producer compatibility. */ isWebDriverInWorker?: boolean | null; /** Added after the original public shape; optional for producer compatibility. */ isWorkerWebGLInconsistent?: boolean | null; isCdpDetectedInWorker: boolean | null; } /** Detects the CDP Runtime serialization side effect used by Chromium automation. */ declare function checkCdpRuntime(context: ExtendedWindow): Promise; /** * Desktop Chromium that enumerates no media devices at all. Headless Chrome * ships without audio or video endpoints; a real desktop reports at least one. */ declare function checkMediaDevices(context: ExtendedWindow): Promise; /** * The installed speech voices contradict the platform the client claims. * * The voice list comes from the operating system and from the browser vendor's * own bundle, neither of which a User-Agent rewrite reaches. Anti-detect * browsers ship dedicated voice-table spoofing precisely because of this. */ declare function checkSpeechVoices(context: ExtendedWindow): Promise; /** Notification.permission disagrees with navigator.permissions.query(). */ declare function checkNotificationPermissionConsistency(context: ExtendedWindow): Promise; /** High-entropy UA-CH version, mobile, or platform values contradict the UA. */ declare function checkHighEntropyUserAgentData(context: ExtendedWindow): Promise; /** Compares Navigator values and the CDP side effect in a dedicated worker. */ declare function checkWorkerConsistency(context: ExtendedWindow): Promise; /** Chrome, Edge, and other Chromium-based browsers */ declare function isChromiumBrowser(context: ExtendedWindow): boolean; /** * Checks WebGPU `shader-f16` support on Chromium browsers. * Real Chrome/Edge 113+ clients typically expose this feature; bots often do not. * * @see https://scrapfly.io/web-scraping-tools/gpu-fingerprint/webgpu/shader-f16 */ declare function checkShaderF16Support(context: ExtendedWindow): Promise; /** * Builds the weighted instant signal list from the boolean checks. Pass * `asyncChecks` to include async-only WebGPU, CDP, permission, Client * Hints, and worker signals. `null`/`undefined` values are omitted. * @internal */ declare function buildInstantSignals(checks: InstantSignalChecks, asyncChecks?: Partial | boolean | null): InstantSignal[]; /** * Aggregates triggered instant signal weights as `1 - Π(1 - weightᵢ)`. * @internal */ declare function aggregateInstantSuspicionScore(signals: InstantSignal[]): number; /** * Confidence in the verdict based on high-confidence hits and the score. * @internal */ declare function resolveInstantConfidence(signals: InstantSignal[], suspicionScore: number): InstantConfidenceLevel; /** * Instant environment checks (automation, headless, UA, WebGL, etc.), scored * into a weighted `suspicionScore`. For Chromium WebGPU `shader-f16` * validation, use {@link detectInstantClientAsync}. */ declare function detectInstantClient(context: ExtendedWindow, options?: InstantDetectorOptions): InstantClientResult; /** * Instant checks plus async WebGPU, CDP, permissions, high-entropy Client * Hints, and worker-realm consistency checks. */ declare function detectInstantClientAsync(context: ExtendedWindow, options?: InstantDetectorOptions): Promise; /** * Returns `true` if the client looks human according to instant checks * (i.e. `detectInstantClient(...).isLegitClient`). * * This is the simplest entry point from the `bot-signal` package for most browser use cases. */ declare function isHuman(context: ExtendedWindow, options?: InstantDetectorOptions): boolean; /** * Async version that adds WebGPU, CDP, permissions, high-entropy Client Hints, * and worker-realm consistency checks. */ declare function isHumanAsync(context: ExtendedWindow, options?: InstantDetectorOptions): Promise; export { AutomationAssessment, type BehavioralClientDetector, type BehavioralClientResult, type BehavioralDetectorOptions, type BehavioralSampleCounts, type BehavioralSamples, type BehavioralSignal, type ClickSample, type ConfidenceLevel, type ExtendedDocument, type ExtendedNavigator, type ExtendedWindow, type InstantAsyncChecks, type InstantClientAsyncResult, type InstantClientResult, type InstantConfidenceLevel, type InstantDetectorOptions, type InstantSignal, type InstantSignalChecks, type KeySample, type MouseSample, type ScrollSample, type TouchSample, type WorkerChecks, aggregateInstantSuspicionScore, aggregateSuspicionScore, analyzeBehavioralSamples, buildBehavioralSignals, buildInstantSignals, checkCdpRuntime, checkHighEntropyUserAgentData, checkMediaDevices, checkNotificationPermissionConsistency, checkShaderF16Support, checkSpeechVoices, checkWorkerConsistency, createBehavioralClientDetector, detectInstantClient, detectInstantClientAsync, hasCdpInputCoordinateLeak, hasClickWithoutMouseMovement, hasLinearMouseMovement, hasLinearScroll, hasLinearTapRhythm, hasLinearTouchMovement, hasLinearTyping, hasNoMouseActivity, hasSyntheticEvents, hasTeleportMouse, hasTeleportTouch, hasZeroMouseMovementDeltas, isAutomationArtifacts, isCanvasNoiseInjected, isCanvasTampered, isChromeDriver, isChromiumBrowser, isDefaultAutomationViewport, isEmptyPlugins, isEngineInconsistent, isErrorStackAutomation, isGpuPlatformMismatch, isHuman, isHumanAsync, isIframeInconsistent, isLanguageInconsistent, isMediaQueryInconsistent, isMissingChromeObject, isMissingGreaseBrand, isMissingProprietaryCodecs, isNativeFunctionTampered, isNavigatorIdentityInconsistent, isPlaywright, isPluginArrayInconsistent, isPluginMimeTypeInconsistent, isPuppeteer, isScreenGeometryInconsistent, isSoftwareRenderer, isSuspiciousHardware, isSuspiciousWebDriverDescriptor, isSuspiciousWindowDimensions, isTimezoneInconsistent, isUserAgentDataMismatch, isZeroConnectionRtt, resolveConfidence, resolveInstantConfidence };