@axeptio/behavior-detection 1.0.2 → 1.1.0

package/dist/esm/strategies/visibility.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Visibility Strategy
+ * Detects bot-like behavior based on tab visibility and focus patterns
+ *
+ * Key detection signals:
+ * - Actions while document.hidden === true (bots ignore visibility)
+ * - No pause when tab loses focus
+ * - Activity resumes too quickly after tab regains focus
+ * - Focus patterns: humans focus inputs before typing
+ */
+import { BaseStrategy } from '../strategy.js';
+export declare class VisibilityStrategy extends BaseStrategy {
+    readonly name = "visibility";
+    readonly defaultWeight = 0.1;
+    private events;
+    private focusTypingPairs;
+    private actionsWhileHidden;
+    private lastVisibilityChange;
+    private resumeDelays;
+    private isActive;
+    private visibilityListener;
+    private focusListener;
+    private blurListener;
+    private clickListener;
+    private keydownListener;
+    private inputFocusListener;
+    private lastFocusedInput;
+    private hasTypedInFocusedInput;
+    private lastActionTime;
+    private preHideActionTime;
+    start(): void;
+    private recordAction;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    /**
+     * Score based on actions while document was hidden
+     * Humans can't interact with hidden tabs; bots can
+     */
+    private scoreHiddenActions;
+    /**
+     * Score based on how quickly activity resumes after tab becomes visible
+     * Humans need time to refocus (100-500ms minimum)
+     * Bots often resume instantly (< 50ms)
+     */
+    private scoreResumeDelays;
+    /**
+     * Score based on focus-to-keypress timing
+     * Humans focus inputs before typing (natural delay 100-500ms)
+     * Bots often type without focusing or with instant delay
+     */
+    private scoreFocusTyping;
+    getDebugInfo(): {
+        eventCount: number;
+        actionsWhileHidden: number;
+        visibilityChanges: number;
+        focusChanges: number;
+        resumeDelays: number[];
+        focusTypingPairs: {
+            delay: number;
+            element: string;
+        }[];
+    };
+}

package/dist/esm/strategies/visibility.js

@@ -0,0 +1,295 @@
+/**
+ * Visibility Strategy
+ * Detects bot-like behavior based on tab visibility and focus patterns
+ *
+ * Key detection signals:
+ * - Actions while document.hidden === true (bots ignore visibility)
+ * - No pause when tab loses focus
+ * - Activity resumes too quickly after tab regains focus
+ * - Focus patterns: humans focus inputs before typing
+ */
+import { BaseStrategy } from '../strategy.js';
+export class VisibilityStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'visibility';
+        this.defaultWeight = 0.10;
+        this.events = [];
+        this.focusTypingPairs = [];
+        this.actionsWhileHidden = 0;
+        this.lastVisibilityChange = null;
+        this.resumeDelays = [];
+        this.isActive = false;
+        // Listeners
+        this.visibilityListener = null;
+        this.focusListener = null;
+        this.blurListener = null;
+        this.clickListener = null;
+        this.keydownListener = null;
+        this.inputFocusListener = null;
+        // State
+        this.lastFocusedInput = null;
+        this.hasTypedInFocusedInput = false;
+        this.lastActionTime = 0;
+        this.preHideActionTime = 0;
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        // Track visibility changes
+        this.visibilityListener = () => {
+            const now = Date.now();
+            const wasHidden = document.hidden;
+            // Track time between visibility changes
+            if (this.lastVisibilityChange && !wasHidden) {
+                // Tab just became visible again
+                // Check if there was activity right before becoming visible
+                // Humans need time to refocus after tab switch
+                if (this.lastActionTime > 0 && this.preHideActionTime > 0) {
+                    const timeSinceLastAction = now - this.lastActionTime;
+                    // If action was very recent (< 50ms), suspicious
+                    if (timeSinceLastAction < 50) {
+                        this.actionsWhileHidden++;
+                    }
+                }
+                // Track resume delay (time until first action after visibility)
+                // Will be calculated when next action occurs
+                this.lastVisibilityChange = { hidden: false, timestamp: now };
+            }
+            else if (wasHidden) {
+                // Tab just became hidden - record pre-hide action time
+                this.preHideActionTime = this.lastActionTime;
+                this.lastVisibilityChange = { hidden: true, timestamp: now };
+            }
+            this.events.push({
+                type: 'visibility_change',
+                timestamp: now,
+                wasHidden,
+            });
+        };
+        // Track window focus
+        this.focusListener = () => {
+            this.events.push({
+                type: 'focus_change',
+                timestamp: Date.now(),
+                wasHidden: document.hidden,
+                wasFocused: true,
+            });
+        };
+        this.blurListener = () => {
+            this.events.push({
+                type: 'focus_change',
+                timestamp: Date.now(),
+                wasHidden: document.hidden,
+                wasFocused: false,
+            });
+        };
+        // Track actions while hidden
+        this.clickListener = (e) => {
+            this.recordAction('click', e);
+        };
+        this.keydownListener = (e) => {
+            this.recordAction('keydown', e);
+            // Track focus-to-keypress timing
+            if (this.lastFocusedInput && !this.hasTypedInFocusedInput) {
+                const now = Date.now();
+                const delay = now - this.lastFocusedInput.timestamp;
+                this.focusTypingPairs.push({
+                    focusTime: this.lastFocusedInput.timestamp,
+                    firstKeypressTime: now,
+                    delay,
+                    element: this.lastFocusedInput.element,
+                });
+                this.hasTypedInFocusedInput = true;
+            }
+        };
+        // Track input focus for focus-typing analysis
+        this.inputFocusListener = (e) => {
+            const target = e.target;
+            if (target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA')) {
+                this.lastFocusedInput = {
+                    element: target.tagName.toLowerCase(),
+                    timestamp: Date.now(),
+                };
+                this.hasTypedInFocusedInput = false;
+            }
+        };
+        document.addEventListener('visibilitychange', this.visibilityListener);
+        window.addEventListener('focus', this.focusListener);
+        window.addEventListener('blur', this.blurListener);
+        document.addEventListener('click', this.clickListener, { passive: true });
+        document.addEventListener('keydown', this.keydownListener, { passive: true });
+        document.addEventListener('focusin', this.inputFocusListener, { passive: true });
+    }
+    recordAction(_type, _event) {
+        const now = Date.now();
+        this.lastActionTime = now;
+        // Check if action occurred while document was hidden
+        if (document.hidden) {
+            this.actionsWhileHidden++;
+            this.events.push({
+                type: 'action_while_hidden',
+                timestamp: now,
+                wasHidden: true,
+            });
+            // Notify detector - this is a strong bot signal
+            this.notifyEvent(1.0);
+        }
+        // Track resume delay after visibility change
+        if (this.lastVisibilityChange && !this.lastVisibilityChange.hidden) {
+            const resumeDelay = now - this.lastVisibilityChange.timestamp;
+            // Only count if this is the first action after becoming visible
+            // and the delay is reasonable (< 10 seconds)
+            if (resumeDelay > 0 && resumeDelay < 10000 && this.resumeDelays.length < 20) {
+                // Check if we haven't already recorded a delay for this visibility change
+                const lastRecordedDelay = this.resumeDelays[this.resumeDelays.length - 1];
+                if (lastRecordedDelay === undefined || Math.abs(resumeDelay - lastRecordedDelay) > 100) {
+                    this.resumeDelays.push(resumeDelay);
+                }
+            }
+        }
+    }
+    stop() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        if (this.visibilityListener) {
+            document.removeEventListener('visibilitychange', this.visibilityListener);
+            this.visibilityListener = null;
+        }
+        if (this.focusListener) {
+            window.removeEventListener('focus', this.focusListener);
+            this.focusListener = null;
+        }
+        if (this.blurListener) {
+            window.removeEventListener('blur', this.blurListener);
+            this.blurListener = null;
+        }
+        if (this.clickListener) {
+            document.removeEventListener('click', this.clickListener);
+            this.clickListener = null;
+        }
+        if (this.keydownListener) {
+            document.removeEventListener('keydown', this.keydownListener);
+            this.keydownListener = null;
+        }
+        if (this.inputFocusListener) {
+            document.removeEventListener('focusin', this.inputFocusListener);
+            this.inputFocusListener = null;
+        }
+    }
+    reset() {
+        this.events = [];
+        this.focusTypingPairs = [];
+        this.actionsWhileHidden = 0;
+        this.lastVisibilityChange = null;
+        this.resumeDelays = [];
+        this.lastFocusedInput = null;
+        this.hasTypedInFocusedInput = false;
+        this.lastActionTime = 0;
+        this.preHideActionTime = 0;
+    }
+    score() {
+        // Need some visibility events to score
+        if (this.events.length < 2)
+            return undefined;
+        let score = 0;
+        let factors = 0;
+        // 1. Actions while hidden (strongest signal)
+        const hiddenActionScore = this.scoreHiddenActions();
+        if (hiddenActionScore !== undefined) {
+            score += hiddenActionScore;
+            factors++;
+        }
+        // 2. Resume delay analysis
+        const resumeScore = this.scoreResumeDelays();
+        if (resumeScore !== undefined) {
+            score += resumeScore;
+            factors++;
+        }
+        // 3. Focus-typing pattern
+        const focusTypingScore = this.scoreFocusTyping();
+        if (focusTypingScore !== undefined) {
+            score += focusTypingScore;
+            factors++;
+        }
+        return factors > 0 ? score / factors : undefined;
+    }
+    /**
+     * Score based on actions while document was hidden
+     * Humans can't interact with hidden tabs; bots can
+     */
+    scoreHiddenActions() {
+        if (this.actionsWhileHidden === 0)
+            return 1.0; // Perfect
+        // Any action while hidden is highly suspicious
+        if (this.actionsWhileHidden >= 5)
+            return 0.1;
+        if (this.actionsWhileHidden >= 3)
+            return 0.2;
+        if (this.actionsWhileHidden >= 1)
+            return 0.3;
+        return 1.0;
+    }
+    /**
+     * Score based on how quickly activity resumes after tab becomes visible
+     * Humans need time to refocus (100-500ms minimum)
+     * Bots often resume instantly (< 50ms)
+     */
+    scoreResumeDelays() {
+        if (this.resumeDelays.length < 2)
+            return undefined;
+        // Count suspiciously fast resumes (< 50ms)
+        const fastResumeCount = this.resumeDelays.filter(d => d < 50).length;
+        const fastResumeRatio = fastResumeCount / this.resumeDelays.length;
+        if (fastResumeRatio >= 0.8)
+            return 0.1;
+        if (fastResumeRatio >= 0.5)
+            return 0.3;
+        if (fastResumeRatio >= 0.3)
+            return 0.5;
+        if (fastResumeRatio > 0)
+            return 0.7;
+        return 1.0;
+    }
+    /**
+     * Score based on focus-to-keypress timing
+     * Humans focus inputs before typing (natural delay 100-500ms)
+     * Bots often type without focusing or with instant delay
+     */
+    scoreFocusTyping() {
+        if (this.focusTypingPairs.length < 2)
+            return undefined;
+        let suspiciousCount = 0;
+        for (const pair of this.focusTypingPairs) {
+            // Instant typing after focus (< 20ms) is suspicious
+            if (pair.delay < 20) {
+                suspiciousCount++;
+            }
+        }
+        const suspiciousRatio = suspiciousCount / this.focusTypingPairs.length;
+        if (suspiciousRatio >= 0.8)
+            return 0.2;
+        if (suspiciousRatio >= 0.5)
+            return 0.4;
+        if (suspiciousRatio >= 0.3)
+            return 0.6;
+        if (suspiciousRatio > 0)
+            return 0.8;
+        return 1.0;
+    }
+    getDebugInfo() {
+        return {
+            eventCount: this.events.length,
+            actionsWhileHidden: this.actionsWhileHidden,
+            visibilityChanges: this.events.filter(e => e.type === 'visibility_change').length,
+            focusChanges: this.events.filter(e => e.type === 'focus_change').length,
+            resumeDelays: this.resumeDelays,
+            focusTypingPairs: this.focusTypingPairs.map(p => ({
+                delay: p.delay,
+                element: p.element,
+            })),
+        };
+    }
+}

package/dist/index.d.ts

@@ -33,6 +33,6 @@
  */
 export { BehaviorDetector } from './behavior-detector.js';
 export type { DetectionStrategy, StrategyConfig } from './strategy.js';
-export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, } from './strategies/index.js';
+export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, Timing, Visibility, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, TimingStrategy, VisibilityStrategy, } from './strategies/index.js';
 export type { BehaviorSettings, ScoreOptions, ScoreResult, ScoreBreakdown, TrackedEvent, EventType, ScoringFunction, } from './types.js';
 export { DEFAULT_SETTINGS } from './types.js';

package/dist/strategies/click.d.ts

@@ -1,6 +1,11 @@
 /**
  * Click Behavior Detection Strategy
  * Monitors specific elements for click positioning patterns
+ *
+ * Enhanced detection:
+ * - Click-mouse position delta (bots using .click() have mismatched positions)
+ * - Pre-click mouse trajectory analysis
+ * - Time between last mousemove and click
  */
 import { BaseStrategy } from '../strategy.js';
 export declare class ClickStrategy extends BaseStrategy {
@@ -35,5 +40,8 @@ export declare class ClickStrategy extends BaseStrategy {
         };
         inViewport: number;
         trackedElements: number;
+        mouseClickDeltas: number[];
+        timeSinceMouseMoves: number[];
+        untrustedClicks: number;
     };
 }

package/dist/strategies/environment.d.ts

@@ -1,8 +1,29 @@
 /**
  * Environment Fingerprinting Strategy
  * Captures browser environment on initialization and tick updates
+ * Includes critical automation/bot detection signals
  */
 import { BaseStrategy } from '../strategy.js';
+interface AutomationIndicators {
+    /** navigator.webdriver === true (most reliable indicator) */
+    isWebdriver: boolean;
+    /** HeadlessChrome or Headless in user agent */
+    hasHeadlessUA: boolean;
+    /** window.chrome exists but window.chrome.runtime is undefined */
+    hasChromelessRuntime: boolean;
+    /** WebGL renderer is SwiftShader or software renderer */
+    hasSoftwareRenderer: boolean;
+    /** No plugins on desktop browser (suspicious) */
+    hasNoPlugins: boolean;
+    /** Automation framework globals detected */
+    hasAutomationGlobals: boolean;
+    /** List of detected automation globals */
+    detectedGlobals: string[];
+    /** CDP (Chrome DevTools Protocol) injection detected */
+    hasCDPInjection: boolean;
+    /** Detected CDP injection keys */
+    detectedCDPKeys: string[];
+}
 interface EnvironmentData {
     screenWidth: number;
     screenHeight: number;
@@ -29,6 +50,10 @@ interface EnvironmentData {
     featureInconsistency: boolean;
     isMobile: boolean;
     timestamp: number;
+    /** Automation/bot detection indicators */
+    automation: AutomationIndicators;
+    /** WebGL renderer string (for debugging) */
+    webglRenderer?: string;
 }
 export declare class EnvironmentStrategy extends BaseStrategy {
     readonly name = "environment";
@@ -40,6 +65,10 @@ export declare class EnvironmentStrategy extends BaseStrategy {
     onTick(_timestamp: number): void;
     score(): number | undefined;
     private isMobileDevice;
+    /**
+     * Detect automation indicators
+     */
+    private detectAutomation;
     private captureEnvironment;
     getDebugInfo(): EnvironmentData | null;
     /**
@@ -48,5 +77,15 @@ export declare class EnvironmentStrategy extends BaseStrategy {
      * Returns null if environment hasn't been captured yet
      */
     isMobile(): boolean | null;
+    /**
+     * Get automation detection results
+     * Returns null if environment hasn't been captured yet
+     */
+    getAutomationIndicators(): AutomationIndicators | null;
+    /**
+     * Quick check if any strong automation indicator is present
+     * Returns true if likely a bot, false if likely human, null if not checked yet
+     */
+    isLikelyBot(): boolean | null;
 }
 export {};

package/dist/strategies/index.d.ts

@@ -9,6 +9,8 @@ export { TapStrategy } from './tap.js';
 export { KeyboardStrategy } from './keyboard.js';
 export { EnvironmentStrategy } from './environment.js';
 export { ResizeStrategy } from './resize.js';
+export { TimingStrategy } from './timing.js';
+export { VisibilityStrategy } from './visibility.js';
 export { MouseStrategy as Mouse } from './mouse.js';
 export { ScrollStrategy as Scroll } from './scroll.js';
 export { ClickStrategy as Click } from './click.js';
@@ -16,3 +18,5 @@ export { TapStrategy as Tap } from './tap.js';
 export { KeyboardStrategy as Keyboard } from './keyboard.js';
 export { EnvironmentStrategy as Environment } from './environment.js';
 export { ResizeStrategy as Resize } from './resize.js';
+export { TimingStrategy as Timing } from './timing.js';
+export { VisibilityStrategy as Visibility } from './visibility.js';

package/dist/strategies/mouse.d.ts

@@ -2,8 +2,27 @@
  * Mouse Movement Detection Strategy
  * Autonomous module that manages its own mouse event listeners and state
  * Tracks distance and angle to detect unnatural jumps and sharp turns
+ *
+ * Enhanced detection:
+ * - Pre-click stillness (micro-movements before clicks)
+ * - Entry point analysis (where mouse enters viewport)
+ * - Velocity consistency
  */
 import { BaseStrategy, type TimeSeriesPoint } from '../strategy.js';
+interface MousePosition {
+    x: number;
+    y: number;
+    timestamp: number;
+}
+interface EntryPoint {
+    x: number;
+    y: number;
+    timestamp: number;
+    /** Distance from nearest edge (0 = at edge) */
+    edgeDistance: number;
+    /** Which edge: 'top' | 'bottom' | 'left' | 'right' | 'corner' | 'center' */
+    entryEdge: 'top' | 'bottom' | 'left' | 'right' | 'corner' | 'center';
+}
 export declare class MouseStrategy extends BaseStrategy {
     readonly name = "mouse";
     readonly defaultWeight = 0.3;
@@ -15,8 +34,15 @@ export declare class MouseStrategy extends BaseStrategy {
     private rollingWindowMs;
     private listener;
     private leaveListener;
+    private enterListener;
     private isActive;
     private screenDiagonal;
+    /** Entry points tracking */
+    private entryPoints;
+    /** Micro-movements in last 500ms (for stillness detection) */
+    private microMovements;
+    /** Stillness window in ms */
+    private readonly STILLNESS_WINDOW;
     constructor(options?: {
         rollingWindow?: number;
     });
@@ -26,14 +52,40 @@ export declare class MouseStrategy extends BaseStrategy {
     score(): number | undefined;
     /**
      * Mouse-specific pattern detection
-     * Detects bot-like patterns: constant velocity, linear paths
+     * Detects bot-like patterns: constant velocity, linear paths, suspicious entry points
      */
     private detectMousePatterns;
+    /**
+     * Score based on viewport entry points
+     * Humans enter from edges with momentum; bots often start at (0,0) or center
+     */
+    private scoreEntryPoints;
+    /**
+     * Score based on micro-movements (tremor detection)
+     * Humans have natural hand tremor causing 1-5px jitter
+     * Bots have perfect stillness or no micro-movements
+     */
+    private scoreMicroMovements;
+    /**
+     * Get micro-movement count for external use (e.g., by ClickStrategy)
+     */
+    getMicroMovementCount(): number;
+    /**
+     * Get last position for external use
+     */
+    getLastPosition(): {
+        x: number;
+        y: number;
+    } | null;
     getDebugInfo(): {
         eventCount: number;
         rollingWindow: number;
         isActive: boolean;
         distanceSeries: TimeSeriesPoint[];
         angleSeries: TimeSeriesPoint[];
+        entryPoints: EntryPoint[];
+        microMovementCount: number;
+        lastPosition: MousePosition | null;
     };
 }
+export {};

package/dist/strategies/timing.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Timing Analysis Strategy
+ * Detects bot-like timing patterns in user interactions
+ *
+ * Key detection signals:
+ * - Pre-action stillness (humans have micro-movements before clicking)
+ * - Action timing patterns (machine-precise intervals)
+ * - Inactivity patterns (bursts after long silence, no idle variance)
+ * - Actions while tab is hidden (bots ignore visibility)
+ */
+import { BaseStrategy } from '../strategy.js';
+export declare class TimingStrategy extends BaseStrategy {
+    readonly name = "timing";
+    readonly defaultWeight = 0.15;
+    private actions;
+    private mouseStillness;
+    private microMovements;
+    private isActive;
+    private mouseListener;
+    private clickListener;
+    private keydownListener;
+    private scrollListener;
+    /** Time window to consider for pre-action stillness (ms) */
+    private readonly STILLNESS_WINDOW;
+    /** Minimum distance to count as meaningful movement (px) */
+    private readonly MICRO_MOVEMENT_THRESHOLD;
+    /** Maximum micro-movement to count (jitter vs intentional) (px) */
+    private readonly MAX_MICRO_MOVEMENT;
+    /** Machine-precision threshold (intervals within this are suspicious) */
+    private readonly MACHINE_PRECISION_THRESHOLD;
+    start(): void;
+    private recordAction;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    /**
+     * Score based on pre-action stillness
+     * Humans have micro-movements before clicking; bots are perfectly still
+     */
+    private scorePreActionStillness;
+    /**
+     * Score mouse-to-click delay patterns (using pre-filtered cache)
+     */
+    private scoreMouseToClickDelayFromCache;
+    /**
+     * Score action intervals for machine-like precision
+     * Detects exact intervals: 100ms, 500ms, 1000ms
+     */
+    private scoreActionIntervals;
+    /**
+     * Score based on actions while document was hidden (using pre-computed count)
+     */
+    private scoreHiddenActionsFromCount;
+    getDebugInfo(): {
+        actionCount: number;
+        clickCount: number;
+        keydownCount: number;
+        scrollCount: number;
+        hiddenActionCount: number;
+        microMovementCount: number;
+        intervals: number[];
+        lastStillnessDuration: number | null;
+    };
+}

package/dist/strategies/visibility.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Visibility Strategy
+ * Detects bot-like behavior based on tab visibility and focus patterns
+ *
+ * Key detection signals:
+ * - Actions while document.hidden === true (bots ignore visibility)
+ * - No pause when tab loses focus
+ * - Activity resumes too quickly after tab regains focus
+ * - Focus patterns: humans focus inputs before typing
+ */
+import { BaseStrategy } from '../strategy.js';
+export declare class VisibilityStrategy extends BaseStrategy {
+    readonly name = "visibility";
+    readonly defaultWeight = 0.1;
+    private events;
+    private focusTypingPairs;
+    private actionsWhileHidden;
+    private lastVisibilityChange;
+    private resumeDelays;
+    private isActive;
+    private visibilityListener;
+    private focusListener;
+    private blurListener;
+    private clickListener;
+    private keydownListener;
+    private inputFocusListener;
+    private lastFocusedInput;
+    private hasTypedInFocusedInput;
+    private lastActionTime;
+    private preHideActionTime;
+    start(): void;
+    private recordAction;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    /**
+     * Score based on actions while document was hidden
+     * Humans can't interact with hidden tabs; bots can
+     */
+    private scoreHiddenActions;
+    /**
+     * Score based on how quickly activity resumes after tab becomes visible
+     * Humans need time to refocus (100-500ms minimum)
+     * Bots often resume instantly (< 50ms)
+     */
+    private scoreResumeDelays;
+    /**
+     * Score based on focus-to-keypress timing
+     * Humans focus inputs before typing (natural delay 100-500ms)
+     * Bots often type without focusing or with instant delay
+     */
+    private scoreFocusTyping;
+    getDebugInfo(): {
+        eventCount: number;
+        actionsWhileHidden: number;
+        visibilityChanges: number;
+        focusChanges: number;
+        resumeDelays: number[];
+        focusTypingPairs: {
+            delay: number;
+            element: string;
+        }[];
+    };
+}