import { RedactionOptions } from './redact';
import { ErrorMechanism } from './errors/error-payload';
import { type InactiveSpan } from './tracing';
export declare class HumanBehaviorTracker {
    private eventQueue;
    private pendingCustomEvents;
    private pendingLogs;
    private pendingNetworkErrors;
    /**
     * Outbound custom-event batch queue. Debounced flush at
     * CUSTOM_EVENT_FLUSH_MS or hard-flush at CUSTOM_EVENT_BATCH_MAX. Mirrors
     * PostHog's 100ms / 50-event default. Preserves insertion order.
     */
    private customEventBatch;
    private customEventBatchTimer;
    private readonly CUSTOM_EVENT_FLUSH_MS;
    private readonly CUSTOM_EVENT_BATCH_MAX;
    private sessionId;
    private windowId;
    private _sessionActivityTimestamp;
    private _sessionStartTimestamp;
    private userProperties;
    private isProcessing;
    private flushInterval;
    private readonly IDLE_FLUSH_INTERVAL_MS;
    private readonly LIVE_FLUSH_INTERVAL_MS;
    private readonly LIVE_FLUSH_GRACE_MS;
    private flushTier;
    private liveFlushDeadline;
    private readonly MAX_QUEUE_SIZE;
    private heartbeatInterval;
    private readonly HEARTBEAT_INTERVAL_MS;
    private readonly SESSION_IDLE_TIMEOUT_MS;
    private readonly SESSION_MAX_LENGTH_MS;
    /** Only emit `$focus` blurred after blur lasts this long (quick alt-tab → no chop). */
    private focusBlurGraceTimeout;
    private readonly FOCUS_BLUR_GRACE_MS;
    /** Last `$focus` marker we pushed (`null` = never blurred in this session tree). */
    private lastEmittedFocusState;
    private api;
    private endUserId;
    private apiKey;
    private ingestionUrl;
    private initialized;
    initializationPromise: Promise<void> | null;
    private monthlyLimitReached;
    private redactionManager;
    private propertyManager;
    private isDomReady;
    private requestQueue;
    private domReadyHandlers;
    private originalConsole;
    private consoleTrackingEnabled;
    private originalFetch;
    private networkTrackingEnabled;
    private captureRequestBodiesFlag;
    private lastRequestContext?;
    private lastRequestContextAt;
    private readonly ERROR_REQUEST_WINDOW_MS;
    private enableConsoleTrackingFlag;
    private enableNetworkTrackingFlag;
    private enableErrorTrackingFlag;
    private enableWebVitalsFlag;
    private enableTracingFlag;
    private tracing;
    private errorCapture;
    private errorFilterOptions;
    private captureThirdPartyResourceErrorsFlag;
    private readonly breadcrumbs;
    private release;
    private environment;
    private commitSha;
    private dist;
    navigationTrackingEnabled: boolean;
    private currentUrl;
    private previousUrl;
    private originalPushState;
    private originalReplaceState;
    private navigationListeners;
    /**
     * Timestamp of the last `pushState` call. Used by the `hashchange`
     * listener to suppress the dup pageview when a `pushState('/foo#bar')`
     * also fires `hashchange` synchronously.
     */
    private lastPushStateAt;
    /** Window for hashchange-after-pushState dedupe. */
    private readonly NAVIGATION_DEDUPE_MS;
    private _connectionBlocked;
    private recordInstance;
    private sessionStartTime;
    private rrwebRecord;
    private fullSnapshotTimeout;
    private cssSnapshotCapture;
    private localAssetSnapshotCapture;
    private contrastCapture;
    private brokenAssetHandler;
    private brokenAssetSeen;
    private recordCanvas;
    private isStarted;
    private minimumDurationMilliseconds;
    private readonly _window_id_storage_key;
    private readonly _primary_window_exists_storage_key;
    private _isIdle;
    private _lastActivityTimestamp;
    private readonly IDLE_THRESHOLD_MS;
    private frictionClicks;
    private frictionMutationObserver;
    /**
     * Check if the tracker has been started
     */
    get isTrackerStarted(): boolean;
    /**
     * DOM ready detection - more aggressive
     */
    private setupDomReadyHandler;
    /**
     * Called when DOM is ready - processes queued requests
     */
    private onDomReady;
    /**
     * Queue a request until DOM is ready
     */
    private queueRequest;
    /**
     * Process a request (called after DOM is ready)
     */
    private processRequest;
    /**
     * Register a handler to be called when DOM is ready
     */
    private registerDomReadyHandler;
    /**
     * Initialize the HumanBehavior tracker
     * This is the main entry point - call this once per page
     */
    static init(apiKey: string, options?: {
        ingestionUrl?: string;
        logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
        redactFields?: string[];
        redactionStrategy?: {
            mode: 'privacy-first' | 'visibility-first';
            unredactFields?: string[];
            redactFields?: string[];
        };
        enableAutomaticTracking?: boolean;
        suppressConsoleErrors?: boolean;
        recordCanvas?: boolean;
        enableAutomaticProperties?: boolean;
        propertyDenylist?: string[];
        automaticTrackingOptions?: {
            trackButtons?: boolean;
            trackLinks?: boolean;
            trackForms?: boolean;
            includeText?: boolean;
            includeClasses?: boolean;
        };
        maxQueueSize?: number;
        enableConsoleTracking?: boolean;
        enableNetworkTracking?: boolean;
        enableErrorTracking?: boolean;
        ignoreErrors?: (string | RegExp)[];
        denyUrls?: (string | RegExp)[];
        allowUrls?: (string | RegExp)[];
        captureThirdPartyResourceErrors?: boolean;
        release?: string;
        environment?: string;
        commitSha?: string;
        dist?: string;
        captureRequestBodies?: boolean;
        enableWebVitals?: boolean;
        enableTracing?: boolean;
        minimumDurationMilliseconds?: number;
    }): HumanBehaviorTracker;
    constructor(apiKey: string | undefined, ingestionUrl?: string, options?: {
        enableAutomaticProperties?: boolean;
        propertyDenylist?: string[];
        redactionStrategy?: {
            mode: 'privacy-first' | 'visibility-first';
            unredactFields?: string[];
            redactFields?: string[];
        };
        redactFields?: string[];
        maxQueueSize?: number;
        enableConsoleTracking?: boolean;
        enableNetworkTracking?: boolean;
        enableErrorTracking?: boolean;
        ignoreErrors?: (string | RegExp)[];
        denyUrls?: (string | RegExp)[];
        allowUrls?: (string | RegExp)[];
        captureThirdPartyResourceErrors?: boolean;
        release?: string;
        environment?: string;
        commitSha?: string;
        dist?: string;
        captureRequestBodies?: boolean;
        enableWebVitals?: boolean;
        enableTracing?: boolean;
        minimumDurationMilliseconds?: number;
    });
    private init;
    /**
     * ✅ FIXED: Wait for Kafka-based initialization to complete
     */
    private ensureInitialized;
    /**
     * Setup navigation event tracking for SPA navigation
     */
    private setupNavigationTracking;
    /**
     * Track navigation events and send custom events
     */
    trackNavigationEvent(type: string, fromUrl: string, toUrl: string): Promise<void>;
    trackPageView(url?: string): Promise<void>;
    customEvent(eventName: string, properties?: Record<string, any>): Promise<void>;
    /** Append to the outbound batch and arm/refresh the flush timer. */
    private queueCustomEvent;
    /**
     * Teardown-path flush of the outbound custom-event batch: synchronous
     * sendBeacon (survives navigation), falling back to a keepalive fetch
     * when the beacon is unavailable or refuses the payload. Never awaited —
     * callers are unload/hidden handlers that cannot block.
     */
    private flushCustomEventBatchBeacon;
    /**
     * Drain the sub-minimum-duration buffer into the outbound batch. The
     * minimum-duration gate is a delivery *delay*, not a filter — every event
     * in `pendingCustomEvents` is sent verbatim once the session crosses the
     * threshold. FullSnapshots bypass that gate entirely, so the replay
     * already exists server-side; a teardown that drops this buffer is what
     * produces replays with zero analytics events. Called from the hidden/
     * pagehide handlers right before the batch is beaconed out.
     */
    private drainPendingCustomEventsForTeardown;
    /**
     * Flush the outbound custom-event batch. Falls back to per-event
     * `sendCustomEvent` (and finally to the rrweb event-stream Type-5
     * payload) when the batch endpoint errors — this is the same fallback
     * behaviour pre-0.7 had for individual sends.
     */
    private flushCustomEventBatch;
    /**
     * Setup automatic tracking for buttons, links, and forms
     */
    private setupAutomaticTracking;
    /**
     * PostHog/Mixpanel-style autocapture. One `$click` event per user click.
     * Walks up to the nearest interactive ancestor so a click on a <span>
     * inside a <button> is attributed to the button. The event name stays
     * constant (no per-label fragmentation) and text/role/etc. live as
     * properties.
     *
     * Note: the dashboard's hard-coded event name is `$click`, so we keep
     * that as the public event name. The shape is what changed (single
     * event, richer properties) — semantically this is "autocapture".
     */
    private setupAutocapture;
    /**
     * Build a short DOM path like `body > div#root > button.cta`. Capped at
     * 8 ancestors so deeply-nested DOMs don't blow up the payload.
     */
    private buildDomPath;
    /**
     * Wire the friction detectors: one click listener, plus the page-reaction
     * signals they need (mutations, scroll, typing, navigation).
     */
    private setupFrictionClickDetection;
    /**
     * Emit `$rageclick` / `$deadclick`. Property shape is load-bearing: the
     * dashboard, replay inspector and visitor timeline read `element`,
     * `elementId`, `elementClass`, `elementText`, `page` and `clickCount`.
     */
    private fireFrictionEvent;
    /**
     * Setup automatic link tracking
     * TEMPORARILY DISABLED: Automatic custom event tracking
     */
    private setupAutomaticLinkTracking;
    /**
     * Setup automatic form tracking
     */
    private setupAutomaticFormTracking;
    /**
     * Cleanup navigation tracking
     */
    private cleanupNavigationTracking;
    static logToStorage(message: string): void;
    /**
     * Configure logging behavior for the SDK
     * @param config Logger configuration options
     */
    static configureLogging(config: {
        level?: 'none' | 'error' | 'warn' | 'info' | 'debug';
        enableConsole?: boolean;
        enableStorage?: boolean;
    }): void;
    /**
     * Enable console event tracking
     */
    enableConsoleTracking(): void;
    /**
     * Enable network error tracking by intercepting the global fetch API
     */
    enableNetworkTracking(): void;
    /**
     * Capture Core Web Vitals (FCP, LCP, CLS, INP, TTFB) via Google's
     * `web-vitals` library. Each metric is reported once with its FINAL value
     * (LCP/CLS/INP settle at page-hide) and emitted as a `$web_vitals` custom
     * event, so it flows through the existing batch → /customEvent/batch →
     * ClickHouse path with no backend change. See ADR-3.
     *
     * The library is loaded via dynamic import() so it stays off the initial
     * bundle and the critical render path. CLS/INP fire their final callback on
     * visibilitychange/pagehide and ride the SDK's existing batch-flush + beacon
     * fallback, so no extra unload handling is needed. Best-effort: a failed
     * import is swallowed, matching the other trackers.
     */
    enableWebVitalsTracking(): void;
    /**
     * Enable distributed tracing: a page-load transaction with navigation-phase
     * + resource child spans, custom spans via startSpan/startInactiveSpan, and
     * trace-context header propagation on same-origin requests. Spans batch
     * through `api.sendSpans` (and sendBeacon on unload). Best-effort.
     */
    enableTracing(): void;
    /**
     * Time a synchronous/async callback as a tracing span (child of the current
     * page-load trace). No-op (still runs the callback) if tracing is disabled.
     */
    startSpan<T>(opts: {
        name: string;
        op?: string;
        attributes?: Record<string, unknown>;
    }, callback: () => T): T;
    /**
     * Open a tracing span the caller ends manually (`span.end()`). Returns a
     * no-op span if tracing is disabled.
     */
    startInactiveSpan(opts: {
        name: string;
        op?: string;
        attributes?: Record<string, unknown>;
    }): InactiveSpan;
    /**
     * Handle a completed (failed) XHR: record a breadcrumb, capture redacted
     * requestContext, and ship a network-error report — mirroring the fetch path.
     */
    private handleXhrComplete;
    /**
     * Build a redacted requestContext for an error-correlated request. Metadata
     * (url/method/status) is always included; bodies + headers only when the host
     * opted in via `captureRequestBodies`.
     */
    private buildRequestContext;
    /** Normalize a fetch HeadersInit into a plain object for redaction. */
    private headersToObject;
    /**
     * Setup crash/error capture.
     *
     * Installs listeners for uncaught errors (`window.onerror`) and unhandled
     * promise rejections, then ships a structured report via `api.sendError`.
     * The heavy lifting (stack parsing, breadcrumbs, dedup) lives in the pure
     * helpers under `./errors`; this just supplies the live session context.
     *
     * Note: this is separate from the rrweb console-noise `preventDefault()`
     * filter installed during construction — that filter only suppresses the
     * SDK's own internal noise from the console and does not stop genuine app
     * crashes from reaching this handler.
     */
    private setupErrorCapture;
    /**
     * Record a breadcrumb (recent user action) for crash-report context.
     * Safe to call even when error tracking is disabled — the buffer just
     * accumulates and is never read.
     */
    private addBreadcrumb;
    /**
     * Manually report a caught error from a try/catch path. The report is
     * marked `handled: true` (it didn't crash the app) and otherwise flows
     * through the same pipeline (breadcrumbs, dedup, send) as uncaught errors.
     * `options.componentStack` attaches a React component stack; `options.mechanism`
     * lets the React error boundary mark its reports as `react`.
     * No-op if error capture isn't active yet (before `start()` or when the
     * `enableErrorTracking` option is false). Never throws into the host app.
     */
    captureException(error: unknown, options?: {
        componentStack?: string;
        mechanism?: ErrorMechanism;
    }): void;
    /**
     * Flush pending custom events (queued before 5 seconds)
     */
    private flushPendingCustomEvents;
    /**
     * Flush pending logs (queued before 5 seconds)
     */
    private flushPendingLogs;
    /**
     * Flush pending network errors (queued before 5 seconds)
     */
    private flushPendingNetworkErrors;
    /**
     * Enable page load tracking - detects heavy page loads (>3 seconds)
     */
    enablePageLoadTracking(): void;
    /**
     * Track heavy page loads using Performance API
     */
    private trackPageLoad;
    /**
     * Check if network request should be skipped (SDK's own requests)
     */
    private shouldSkipNetworkTracking;
    /**
     * Classify HTTP error status codes
     */
    private classifyHttpError;
    /**
     * Classify network errors (CORS, timeouts, blocked requests, etc.)
     */
    private classifyNetworkError;
    /**
     * Disable console event tracking
     */
    disableConsoleTracking(): void;
    private trackConsoleEvent;
    /**
     * Check if the actual caller (not SDK wrapper) is from SDK code
     * Since we intercept console methods, the stack will always include SDK frames.
     * We need to look at the actual caller frame (the one that called console.error/warn from user code).
     */
    private isSDKStackFrame;
    /** Tracks whether unload listeners are already attached on the global
     *  window so we don't stack them across HMR / re-init cycles. The flag
     *  lives on `window`, not on `this`, because in dev environments
     *  (Next.js Turbopack HMR, module duplication) the instance can change
     *  even when window-level listeners are already in place. Stacking
     *  listeners means N copies of `pagehide` → N parallel sendBeacons →
     *  browsers throttle some, and only the first sub-100ms one survives
     *  reliably. The downstream symptom is a /session-end beacon that
     *  silently fails to deliver, making the dashboard fall through to the
     *  75-second age-out path instead of immediate eviction.
     */
    private setupPageUnloadHandler;
    viewLogs(): void;
    /**
     * Add user identification information to the tracker
     * If userId is not provided, will use userProperties.email as the userId (if present)
     */
    identifyUser(userPropertiesOrArg: Record<string, any> | {
        userProperties: Record<string, any>;
        identityToken?: string;
    }, options?: {
        identityToken?: string;
    }): Promise<string>;
    /**
     * Get current user attributes
     */
    getUserAttributes(): Record<string, any>;
    start(): Promise<void>;
    /**
     * Push an rrweb custom event (type 5) that records a tab visibility
     * transition. The archiver and replay player both consume this marker
     * to gate active-duration calculations: time when state==='hidden' is
     * excluded from "Active Time Spent" regardless of any rrweb activity
     * that happens during it (animations, ad rotations, etc).
     *
     * Best-effort: failures are silent. The marker is just a hint; the
     * existing 30s AFK + 2.5s gap rules still bound active time even if
     * we drop one of these.
     */
    private emitVisibilityMarker;
    /** rrweb Custom event for archiver/player: engaged = visible && focused. */
    private emitFocusMarker;
    private setupWindowFocusTracking;
    private onWindowBlur;
    private onWindowFocus;
    /**
     * Manually trigger a FullSnapshot (for navigation events)
     * Delays snapshot to avoid capturing mid-animation states
     */
    private takeFullSnapshot;
    stop(): Promise<void>;
    /**
     * Add an event to the ingestion queue
     * Events are sent directly without processing to avoid corruption
     */
    addEvent(event: any): Promise<void>;
    /**
     * Calculate session duration
     * Uses most recent event timestamp minus session start timestamp
     */
    private getSessionDuration;
    /**
     * Check if session duration is below minimum threshold
     * Returns true if we should skip sending (session too short)
     */
    private shouldSkipDueToMinimumDuration;
    /**
     * Flush events to the ingestion server
     * Events are sent in chunks to handle large payloads efficiently
     */
    /**
     * (Re)start the periodic flush interval at the cadence for the current
     * tier. Idempotent: safe to call repeatedly; only the interval handle is
     * recreated.
     */
    private armFlushTimer;
    /**
     * React to the server's `liveViewerActive` signal (read off the /events
     * response). A positive signal pushes the live-tier deadline forward and
     * switches to the fast cadence; once the grace window lapses with no fresh
     * positive signal, we fall back to the idle cadence. Only re-arms the timer
     * when the tier actually changes, so this is cheap to call every flush.
     */
    private noteLiveViewerSignal;
    private flushEvents;
    /**
     * Check if an event represents user interaction (not background DOM mutations)
     */
    private isInteractiveEvent;
    /**
     * Update idle state based on event activity
     * Also updates session activity timestamp to prevent premature session expiration
     */
    private updateIdleState;
    /**
     * Add an event to the session recording queue
     * These are typically FullSnapshots or IncrementalSnapshots
     */
    addRecordingEvent(event: any): Promise<void>;
    /**
     * Check if sessionStorage is available and can be used
     */
    private _canUseSessionStorage;
    private _canUseLocalStorage;
    /**
     * Get windowId from sessionStorage
     * SessionStorage persists across page reloads but is unique per window/tab
     */
    private _getWindowIdFromStorage;
    /**
     * Set windowId in sessionStorage
     */
    private _setWindowIdInStorage;
    /**
     * Remove windowId from sessionStorage
     */
    private _removeWindowIdFromStorage;
    /**
     * Check if primary_window_exists flag is set in sessionStorage
     * This flag indicates if a window was opened as a new tab/window (not a reload)
     */
    private _getPrimaryWindowExists;
    /**
     * Set primary_window_exists flag in sessionStorage
     * This flag is set when DOM loads and cleared on beforeunload
     */
    private _setPrimaryWindowExists;
    /**
     * Get or create windowId with multi-window detection
     * - Reuses windowId on page reload (same tab)
     * - Creates new windowId for new windows/tabs
     */
    private getOrCreateWindowId;
    /**
     * Setup beforeunload listener to clear primary_window_exists flag
     * This allows us to distinguish page reloads from new windows/tabs
     */
    private setupWindowUnloadListener;
    private setCookie;
    getCookie(name: string): string | null;
    /**
     * Delete a cookie by setting its expiration date to the past
     * @param name The name of the cookie to delete
     */
    private deleteCookie;
    /**
     * Clear user data and reset session when user signs out of the site
     * This should be called when a user logs out of your application to prevent
     * data contamination between different users
     */
    logout(): void;
    /**
     * Start redaction functionality for sensitive input fields
     * @param options Optional configuration for redaction behavior
     */
    redact(options?: RedactionOptions): Promise<void>;
    /**
     * Set specific fields to be redacted (for visibility-first mode)
     * @param fields Array of CSS selectors for fields to redact
     */
    setRedactedFields(fields: string[]): void;
    /**
     * Set specific fields to be unredacted (everything else stays redacted by rrweb)
     * @param fields Array of CSS selectors for fields to unredact (e.g., ['#username', '#comment'])
     */
    setUnredactedFields(fields: string[]): void;
    private restartWithNewRedaction;
    /**
     * Check if any fields are currently unredacted
     */
    hasUnredactedFields(): boolean;
    /**
     * Get the currently unredacted fields
     */
    getUnredactedFields(): string[];
    /**
     * Remove specific fields from unredaction (they become redacted again)
     * @param fields Array of CSS selectors for fields to redact
     */
    redactFields(fields: string[]): void;
    /**
     * Clear all unredacted fields (everything becomes redacted again)
     */
    clearUnredactedFields(): void;
    /**
     * Check and refresh session if expired (called before adding events)
     * Uses in-memory state as source of truth
     */
    private checkAndRefreshSession;
    /**
     * Get or create session ID with timeout checking
     * Called once during initialization
     * Uses in-memory state as source of truth
     *
     * Session identity is shared across browser tabs (localStorage), matching
     * GA/PostHog: a new tab joins the live session and records under its own
     * `windowId`; the player groups per-window recordings inside the session.
     */
    private getOrCreateSessionId;
    /**
     * Get session data (check memory first, then tab-scoped sessionStorage)
     */
    private getStoredSession;
    /**
     * Create a new session (update memory first, then persistence)
     */
    private createNewSession;
    /**
     * Update session activity timestamp (update memory first, then persistence)
     * Note: This is called by checkAndRefreshSession() for any event, not just user interactions
     * For user interactions, updateIdleState() also updates this, keeping them in sync
     */
    private updateSessionActivity;
    /**
     * If another tab kept (or rotated) the shared session while this tab's
     * in-memory copy went stale, adopt it instead of minting a competitor.
     * Returns true when an existing shared session was adopted.
     */
    private _adoptOrCreateSession;
    /** Shared session blob (localStorage). Concurrent tabs share one session. */
    private _writeStoredSession;
    private _readStoredSessionRaw;
    private _clearStoredSession;
    /**
     * Get the current session ID
     */
    getSessionId(): string;
    /**
     * Get the current URL being tracked
     */
    getCurrentUrl(): string;
    /**
     * Get current snapshot frequency info
     * Uses configured values (5 minutes, 1000 events)
     */
    getSnapshotFrequencyInfo(): {
        sessionDuration: number;
        currentInterval: number;
        currentThreshold: number;
        phase: string;
    };
    /**
     * Test if the tracker can reach the ingestion server
     */
    testConnection(): Promise<{
        success: boolean;
        error?: string;
    }>;
    /**
     * Get connection status and recommendations
     */
    getConnectionStatus(): {
        blocked: boolean;
        recommendations: string[];
    };
    /**
     * Check if the current user is a preexisting user
     * Returns true if the user has an existing endUserId cookie from a previous session
     */
    isPreexistingUser(): boolean;
    /**
     * Get user information including whether they are preexisting
     */
    getUserInfo(): {
        endUserId: string | null;
        sessionId: string;
        isPreexistingUser: boolean;
        initialized: boolean;
    };
    /**
     * Set a session property that will be included in all events for this session
     */
    setSessionProperty(key: string, value: any): void;
    /**
     * Set multiple session properties
     */
    setSessionProperties(properties: Record<string, any>): void;
    /**
     * Get a session property
     */
    getSessionProperty(key: string): any;
    /**
     * Remove a session property
     */
    removeSessionProperty(key: string): void;
    /**
     * Set a user property that will be included in all events
     */
    setUserProperty(key: string, value: any): void;
    /**
     * Set multiple user properties
     */
    setUserProperties(properties: Record<string, any>): void;
    /**
     * Get a user property
     */
    getUserProperty(key: string): any;
    /**
     * Remove a user property
     */
    removeUserProperty(key: string): void;
    /**
     * Set a property only if it hasn't been set before
     */
    setOnce(key: string, value: any, scope?: 'session' | 'user'): void;
    /**
     * Clear all session properties
     */
    clearSessionProperties(): void;
    /**
     * Clear all user properties
     */
    clearUserProperties(): void;
    /**
     * Get all properties for debugging
     */
    getAllProperties(): {
        automatic: Record<string, any>;
        session: Record<string, any>;
        user: Record<string, any>;
        initial: Record<string, any>;
    };
}
export default HumanBehaviorTracker;
//# sourceMappingURL=tracker.d.ts.map