@tracelog/lib 0.0.8 → 0.2.0

package/dist/cjs/app.js

@@ -10,263 +10,165 @@ const session_handler_1 = require("./handlers/session.handler");
 const page_view_handler_1 = require("./handlers/page-view.handler");
 const click_handler_1 = require("./handlers/click.handler");
 const scroll_handler_1 = require("./handlers/scroll.handler");
-const validations_1 = require("./utils/validations");
-const event_types_1 = require("./types/event.types");
+const types_1 = require("./types");
 const google_analytics_integration_1 = require("./integrations/google-analytics.integration");
 const utils_1 = require("./utils");
 const storage_manager_1 = require("./managers/storage.manager");
-const constants_1 = require("./constants");
+const config_constants_1 = require("./constants/config.constants");
 const performance_handler_1 = require("./handlers/performance.handler");
 const error_handler_1 = require("./handlers/error.handler");
-const network_handler_1 = require("./handlers/network.handler");
-const validation_error_types_1 = require("./types/validation-error.types");
-const logging_1 = require("./utils/logging");
+/**
+ * Main application class for TraceLog analytics
+ * Orchestrates event tracking, session management, and integrations
+ */
 class App extends state_manager_1.StateManager {
     constructor() {
         super(...arguments);
         this.isInitialized = false;
-        this.googleAnalytics = null;
         this.suppressNextScrollTimer = null;
+        this.emitter = new utils_1.Emitter();
+        this.managers = {};
+        this.handlers = {};
+        this.integrations = {};
     }
-    /**
-     * Returns the initialization status of the app
-     * @returns true if the app is fully initialized, false otherwise
-     */
     get initialized() {
         return this.isInitialized;
     }
     async init(appConfig) {
         if (this.isInitialized) {
-            logging_1.debugLog.debug('App', 'App already initialized, skipping re-initialization', { projectId: appConfig.id });
             return;
         }
-        logging_1.debugLog.info('App', 'App initialization started', { projectId: appConfig.id });
-        this.validateAppReadiness(appConfig);
+        if (!appConfig.id?.trim()) {
+            throw new Error('Project ID is required');
+        }
+        this.managers.storage = new storage_manager_1.StorageManager();
         try {
-            this.initStorage();
-            await this.setState(appConfig);
-            await this.setIntegrations();
-            this.setEventManager();
-            await this.initHandlers();
-            this.isInitialized = true;
-            logging_1.debugLog.info('App', 'App initialization completed successfully', {
-                projectId: appConfig.id,
+            await this.setupState(appConfig);
+            await this.setupIntegrations();
+            this.managers.event = new event_manager_1.EventManager(this.managers.storage, this.integrations.googleAnalytics, this.emitter);
+            this.initializeHandlers();
+            await this.managers.event.recoverPersistedEvents().catch(() => {
+                utils_1.debugLog.warn('App', 'Failed to recover persisted events');
             });
+            this.isInitialized = true;
         }
         catch (error) {
-            this.isInitialized = false;
-            logging_1.debugLog.error('App', 'App initialization failed', { projectId: appConfig.id, error });
-            throw error;
-        }
-    }
-    /**
-     * Validates that the app is ready to initialize with the provided config
-     * This is a lightweight runtime validation layer that ensures the app receives proper config
-     * @param appConfig - The validated and normalized configuration
-     * @throws {ProjectIdValidationError} If project ID is invalid at runtime
-     */
-    validateAppReadiness(appConfig) {
-        // Lightweight validation - config should already be validated and normalized by api.ts
-        if (!appConfig?.id) {
-            logging_1.debugLog.clientError('App', 'Configuration integrity check failed - missing project ID', {
-                hasConfig: !!appConfig,
-                hasId: !!appConfig?.id,
-            });
-            throw new validation_error_types_1.ProjectIdValidationError('Configuration integrity check failed', 'app');
+            await this.destroy(true);
+            throw new Error(`TraceLog initialization failed: ${error}`);
         }
     }
     sendCustomEvent(name, metadata) {
-        if (!this.eventManager) {
-            logging_1.debugLog.warn('App', 'Custom event attempted before eventManager initialization', { eventName: name });
+        if (!this.managers.event) {
             return;
         }
-        const { valid, error, sanitizedMetadata } = (0, validations_1.isEventValid)(name, metadata);
-        if (valid) {
-            logging_1.debugLog.debug('App', 'Custom event validated and queued', { eventName: name, hasMetadata: !!sanitizedMetadata });
-            this.eventManager.track({
-                type: event_types_1.EventType.CUSTOM,
-                custom_event: {
-                    name,
-                    ...(sanitizedMetadata && { metadata: sanitizedMetadata }),
-                },
-            });
-        }
-        else {
-            const currentMode = this.get('config')?.mode;
-            logging_1.debugLog.clientError('App', `Custom event validation failed: ${error ?? 'unknown error'}`, {
-                eventName: name,
-                validationError: error,
-                hasMetadata: !!metadata,
-                mode: currentMode,
-            });
-            if (currentMode === 'qa' || currentMode === 'debug') {
-                throw new Error(`custom event "${name}" validation failed (${error ?? 'unknown error'}). Please, review your event data and try again.`);
+        const { valid, error, sanitizedMetadata } = (0, utils_1.isEventValid)(name, metadata);
+        if (!valid) {
+            const config = this.get('config');
+            if (config?.mode === 'qa' || config?.mode === 'debug') {
+                throw new Error(`Custom event "${name}" validation failed: ${error}`);
             }
+            return;
         }
+        this.managers.event.track({
+            type: types_1.EventType.CUSTOM,
+            custom_event: {
+                name,
+                ...(sanitizedMetadata && { metadata: sanitizedMetadata }),
+            },
+        });
+    }
+    on(event, callback) {
+        this.emitter.on(event, callback);
+    }
+    off(event, callback) {
+        this.emitter.off(event, callback);
     }
-    destroy() {
-        if (!this.isInitialized) {
-            logging_1.debugLog.warn('App', 'Destroy called but app was not initialized');
+    async destroy(force = false) {
+        if (!this.isInitialized && !force) {
             return;
         }
-        logging_1.debugLog.info('App', 'App cleanup started');
-        if (this.googleAnalytics) {
-            this.googleAnalytics.cleanup();
-        }
-        if (this.sessionHandler) {
-            this.sessionHandler.stopTracking();
-        }
-        if (this.pageViewHandler) {
-            this.pageViewHandler.stopTracking();
-        }
-        if (this.clickHandler) {
-            this.clickHandler.stopTracking();
-        }
-        if (this.scrollHandler) {
-            this.scrollHandler.stopTracking();
-        }
-        if (this.performanceHandler) {
-            this.performanceHandler.stopTracking();
-        }
-        if (this.errorHandler) {
-            this.errorHandler.stopTracking();
-        }
-        if (this.networkHandler) {
-            this.networkHandler.stopTracking();
-        }
+        this.integrations.googleAnalytics?.cleanup();
+        const handlerCleanups = Object.values(this.handlers)
+            .filter(Boolean)
+            .map(async (handler) => {
+            try {
+                await handler.stopTracking();
+            }
+            catch {
+                utils_1.debugLog.warn('App', 'Failed to stop tracking');
+            }
+        });
+        await Promise.allSettled(handlerCleanups);
         if (this.suppressNextScrollTimer) {
             clearTimeout(this.suppressNextScrollTimer);
             this.suppressNextScrollTimer = null;
         }
-        if (this.eventManager) {
-            this.eventManager.stop();
-        }
+        this.managers.event?.stop();
+        this.emitter.removeAllListeners();
         this.set('hasStartSession', false);
         this.set('suppressNextScroll', false);
         this.set('sessionId', null);
         this.isInitialized = false;
-        logging_1.debugLog.info('App', 'App cleanup completed successfully');
-    }
-    async setState(appConfig) {
-        this.setApiUrl(appConfig.id, appConfig.allowHttp);
-        await this.setConfig(appConfig);
-        this.setUserId();
-        this.setDevice();
-        this.setPageUrl();
+        this.handlers = {};
     }
-    setApiUrl(id, allowHttp = false) {
-        const apiManager = new api_manager_1.ApiManager();
-        this.set('apiUrl', apiManager.getUrl(id, allowHttp));
-    }
-    async setConfig(appConfig) {
+    async setupState(appConfig) {
+        // Set API URL
+        const apiUrl = (0, api_manager_1.getApiUrlForProject)(appConfig.id, appConfig.allowHttp);
+        this.set('apiUrl', apiUrl);
+        // Get remote configuration
         const configManager = new config_manager_1.ConfigManager();
-        const config = await configManager.get(this.get('apiUrl'), appConfig);
-        this.set('config', config);
-    }
-    setUserId() {
-        const userManager = new user_manager_1.UserManager(this.storageManager);
-        const userId = userManager.getId();
+        const config = await configManager.get(apiUrl, appConfig);
+        const { config: normalizedConfig } = (0, utils_1.normalizeConfig)(config);
+        this.set('config', normalizedConfig);
+        // Set user ID
+        const userId = user_manager_1.UserManager.getId(this.managers.storage, normalizedConfig.id);
         this.set('userId', userId);
-    }
-    setDevice() {
-        const device = (0, utils_1.getDeviceType)();
-        this.set('device', device);
-    }
-    setPageUrl() {
-        const initialUrl = (0, utils_1.normalizeUrl)(window.location.href, this.get('config').sensitiveQueryParams);
-        this.set('pageUrl', initialUrl);
-    }
-    async setIntegrations() {
-        const isIPExcluded = this.get('config').ipExcluded;
-        const measurementId = this.get('config').integrations?.googleAnalytics?.measurementId;
-        if (!isIPExcluded && measurementId?.trim()) {
-            this.googleAnalytics = new google_analytics_integration_1.GoogleAnalyticsIntegration();
-            await this.googleAnalytics.initialize();
-        }
-    }
-    async initHandlers() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before handlers');
-        }
-        if (!this.storageManager) {
-            throw new Error('StorageManager must be initialized before handlers');
-        }
-        this.initSessionHandler();
-        this.initPageViewHandler();
-        this.initClickHandler();
-        this.initScrollHandler();
-        await this.initPerformanceHandler();
-        this.initErrorHandler();
-        this.initNetworkHandler();
-    }
-    initStorage() {
-        this.storageManager = new storage_manager_1.StorageManager();
-    }
-    setEventManager() {
-        if (!this.storageManager) {
-            throw new Error('StorageManager must be initialized before EventManager');
-        }
-        this.eventManager = new event_manager_1.EventManager(this.storageManager, this.googleAnalytics);
-    }
-    initSessionHandler() {
-        if (!this.storageManager || !this.eventManager) {
-            throw new Error('StorageManager and EventManager must be initialized before SessionHandler');
-        }
-        this.sessionHandler = new session_handler_1.SessionHandler(this.storageManager, this.eventManager);
-        this.sessionHandler.startTracking();
-    }
-    initPageViewHandler() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before PageViewHandler');
-        }
-        const onPageViewTrack = () => this.onPageViewTrack();
-        this.pageViewHandler = new page_view_handler_1.PageViewHandler(this.eventManager, onPageViewTrack);
-        this.pageViewHandler.startTracking();
-    }
-    onPageViewTrack() {
-        this.set('suppressNextScroll', true);
-        if (this.suppressNextScrollTimer) {
-            clearTimeout(this.suppressNextScrollTimer);
-            this.suppressNextScrollTimer = null;
-        }
-        this.suppressNextScrollTimer = window.setTimeout(() => {
-            this.set('suppressNextScroll', false);
-        }, constants_1.SCROLL_DEBOUNCE_TIME_MS * constants_1.SCROLL_SUPPRESSION_CONSTANTS.SUPPRESS_MULTIPLIER);
-    }
-    initClickHandler() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before ClickHandler');
-        }
-        this.clickHandler = new click_handler_1.ClickHandler(this.eventManager);
-        this.clickHandler.startTracking();
-    }
-    initScrollHandler() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before ScrollHandler');
-        }
-        this.scrollHandler = new scroll_handler_1.ScrollHandler(this.eventManager);
-        this.scrollHandler.startTracking();
-    }
-    async initPerformanceHandler() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before PerformanceHandler');
-        }
-        this.performanceHandler = new performance_handler_1.PerformanceHandler(this.eventManager);
-        await this.performanceHandler.startTracking();
-    }
-    initErrorHandler() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before ErrorHandler');
+        // Set device and page info
+        this.set('device', (0, utils_1.getDeviceType)());
+        const pageUrl = (0, utils_1.normalizeUrl)(window.location.href, normalizedConfig.sensitiveQueryParams);
+        this.set('pageUrl', pageUrl);
+    }
+    async setupIntegrations() {
+        const config = this.get('config');
+        const measurementId = config.integrations?.googleAnalytics?.measurementId;
+        if (!config.ipExcluded && measurementId?.trim()) {
+            try {
+                this.integrations.googleAnalytics = new google_analytics_integration_1.GoogleAnalyticsIntegration();
+                await this.integrations.googleAnalytics.initialize();
+            }
+            catch {
+                this.integrations.googleAnalytics = undefined;
+            }
         }
-        this.errorHandler = new error_handler_1.ErrorHandler(this.eventManager);
-        this.errorHandler.startTracking();
     }
-    initNetworkHandler() {
-        if (!this.eventManager) {
-            throw new Error('EventManager must be initialized before NetworkHandler');
-        }
-        this.networkHandler = new network_handler_1.NetworkHandler(this.eventManager);
-        this.networkHandler.startTracking();
+    initializeHandlers() {
+        this.handlers.session = new session_handler_1.SessionHandler(this.managers.storage, this.managers.event);
+        this.handlers.session.startTracking().catch((error) => {
+            utils_1.debugLog.error('App', 'Session handler failed to start', {
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        });
+        const onPageView = () => {
+            this.set('suppressNextScroll', true);
+            if (this.suppressNextScrollTimer) {
+                clearTimeout(this.suppressNextScrollTimer);
+            }
+            this.suppressNextScrollTimer = window.setTimeout(() => {
+                this.set('suppressNextScroll', false);
+            }, config_constants_1.SCROLL_DEBOUNCE_TIME_MS * config_constants_1.SCROLL_SUPPRESS_MULTIPLIER);
+        };
+        this.handlers.pageView = new page_view_handler_1.PageViewHandler(this.managers.event, onPageView);
+        this.handlers.pageView.startTracking();
+        this.handlers.click = new click_handler_1.ClickHandler(this.managers.event);
+        this.handlers.click.startTracking();
+        this.handlers.scroll = new scroll_handler_1.ScrollHandler(this.managers.event);
+        this.handlers.scroll.startTracking();
+        this.handlers.performance = new performance_handler_1.PerformanceHandler(this.managers.event);
+        this.handlers.performance.startTracking().catch(() => {
+            utils_1.debugLog.warn('App', 'Failed to start performance tracking');
+        });
+        this.handlers.error = new error_handler_1.ErrorHandler(this.managers.event);
+        this.handlers.error.startTracking();
     }
 }
 exports.App = App;

package/dist/cjs/app.types.d.ts

@@ -1,7 +1,2 @@
-export * from './types/common.types';
-export * from './types/config.types';
-export * from './types/device.types';
-export * from './types/event.types';
-export * from './types/mode.types';
-export * from './types/queue.types';
-export * from './types/tag.types';
+export { Mode, EventType, DeviceType, ScrollDirection, ErrorType, TagConditionOperator, TagLogicalOperator, TagConditionType, } from './types';
+export type { ScrollData, ClickData, CustomEventData, MetadataType, WebVitalsData, ErrorData, PageViewData, UTM, EventData, AppConfig, ApiConfig, ExtendedEventsQueueDto, TagConfig, BaseEventsQueueDto, WebVitalType, SessionEndReason, } from './types';

package/dist/cjs/app.types.js

@@ -1,23 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types/common.types"), exports);
-__exportStar(require("./types/config.types"), exports);
-__exportStar(require("./types/device.types"), exports);
-__exportStar(require("./types/event.types"), exports);
-__exportStar(require("./types/mode.types"), exports);
-__exportStar(require("./types/queue.types"), exports);
-__exportStar(require("./types/tag.types"), exports);
+exports.TagConditionType = exports.TagLogicalOperator = exports.TagConditionOperator = exports.ErrorType = exports.ScrollDirection = exports.DeviceType = exports.EventType = exports.Mode = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "Mode", { enumerable: true, get: function () { return types_1.Mode; } });
+Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return types_1.EventType; } });
+Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return types_1.DeviceType; } });
+Object.defineProperty(exports, "ScrollDirection", { enumerable: true, get: function () { return types_1.ScrollDirection; } });
+Object.defineProperty(exports, "ErrorType", { enumerable: true, get: function () { return types_1.ErrorType; } });
+Object.defineProperty(exports, "TagConditionOperator", { enumerable: true, get: function () { return types_1.TagConditionOperator; } });
+Object.defineProperty(exports, "TagLogicalOperator", { enumerable: true, get: function () { return types_1.TagLogicalOperator; } });
+Object.defineProperty(exports, "TagConditionType", { enumerable: true, get: function () { return types_1.TagConditionType; } });

package/dist/cjs/constants/api.constants.js

@@ -1,17 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONFIG = exports.DEFAULT_API_CONFIG = void 0;
-const limits_constants_1 = require("./limits.constants");
-const timing_constants_1 = require("./timing.constants");
+const config_constants_1 = require("./config.constants");
 exports.DEFAULT_API_CONFIG = {
-    samplingRate: limits_constants_1.DEFAULT_SAMPLING_RATE,
-    tags: [],
+    samplingRate: config_constants_1.DEFAULT_SAMPLING_RATE,
     excludedUrlPaths: [],
+    tags: [],
+    ipExcluded: false,
 };
 const DEFAULT_CONFIG = (config) => ({
     ...exports.DEFAULT_API_CONFIG,
     ...config,
-    sessionTimeout: timing_constants_1.DEFAULT_SESSION_TIMEOUT_MS,
     allowHttp: false,
+    sessionTimeout: config_constants_1.DEFAULT_SESSION_TIMEOUT,
+    samplingRate: config.samplingRate && config.samplingRate > config_constants_1.MIN_SAMPLING_RATE && config.samplingRate <= config_constants_1.MAX_SAMPLING_RATE
+        ? config.samplingRate
+        : config_constants_1.DEFAULT_SAMPLING_RATE,
+    excludedUrlPaths: config.excludedUrlPaths ?? [],
+    tags: config.tags ?? [],
+    ipExcluded: config.ipExcluded ?? false,
 });
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

package/dist/cjs/constants/config.constants.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Consolidated configuration constants for TraceLog
+ * This file centralizes all timing, limits, browser, and initialization constants
+ */
+export declare const DEFAULT_SESSION_TIMEOUT: number;
+export declare const DUPLICATE_EVENT_THRESHOLD_MS = 1000;
+export declare const EVENT_SENT_INTERVAL_MS = 10000;
+export declare const SCROLL_DEBOUNCE_TIME_MS = 250;
+export declare const DEFAULT_VISIBILITY_TIMEOUT_MS = 2000;
+export declare const EVENT_EXPIRY_HOURS = 24;
+export declare const EVENT_PERSISTENCE_MAX_AGE_MS: number;
+export declare const MAX_EVENTS_QUEUE_LENGTH = 500;
+export declare const MAX_RETRIES = 3;
+export declare const RETRY_DELAY_MS = 5000;
+export declare const REQUEST_TIMEOUT_MS = 10000;
+export declare const MAX_METADATA_SIZE = 5000;
+export declare const DEFAULT_MOTION_THRESHOLD = 2;
+export declare const SIGNIFICANT_SCROLL_DELTA = 10;
+export declare const MIN_SCROLL_DEPTH_CHANGE = 5;
+export declare const SCROLL_MIN_EVENT_INTERVAL_MS = 500;
+export declare const MAX_SCROLL_EVENTS_PER_SESSION = 120;
+export declare const DEFAULT_SAMPLING_RATE = 1;
+export declare const MIN_SAMPLING_RATE = 0;
+export declare const MAX_SAMPLING_RATE = 1;
+export declare const BATCH_SIZE_THRESHOLD = 50;
+export declare const MIN_SESSION_TIMEOUT_MS = 30000;
+export declare const MAX_SESSION_TIMEOUT_MS = 86400000;
+export declare const MAX_CUSTOM_EVENT_NAME_LENGTH = 120;
+export declare const MAX_CUSTOM_EVENT_STRING_SIZE: number;
+export declare const MAX_CUSTOM_EVENT_KEYS = 10;
+export declare const MAX_CUSTOM_EVENT_ARRAY_SIZE = 10;
+export declare const MAX_TEXT_LENGTH = 255;
+export declare const MAX_STRING_LENGTH = 1000;
+export declare const MAX_ARRAY_LENGTH = 100;
+export declare const MAX_OBJECT_DEPTH = 3;
+export declare const PRECISION_TWO_DECIMALS: 2;
+export declare const SYNC_XHR_TIMEOUT_MS = 2000;
+export declare const MAX_FINGERPRINTS = 1000;
+export declare const FINGERPRINT_CLEANUP_MULTIPLIER = 10;
+export declare const MAX_FINGERPRINTS_HARD_LIMIT = 2000;
+export declare const HTML_DATA_ATTR_PREFIX = "data-tl";
+export declare const INTERACTIVE_SELECTORS: readonly ["button", "a", "input[type=\"button\"]", "input[type=\"submit\"]", "input[type=\"reset\"]", "input[type=\"checkbox\"]", "input[type=\"radio\"]", "select", "textarea", "[role=\"button\"]", "[role=\"link\"]", "[role=\"tab\"]", "[role=\"menuitem\"]", "[role=\"option\"]", "[role=\"checkbox\"]", "[role=\"radio\"]", "[role=\"switch\"]", "[routerLink]", "[ng-click]", "[data-action]", "[data-click]", "[data-navigate]", "[data-toggle]", "[onclick]", ".btn", ".button", ".clickable", ".nav-link", ".menu-item", "[data-testid]", "[tabindex=\"0\"]"];
+export declare const UTM_PARAMS: string[];
+export declare const INITIALIZATION_MAX_CONCURRENT_RETRIES = 20;
+export declare const INITIALIZATION_CONCURRENT_RETRY_DELAY_MS = 50;
+export declare const INITIALIZATION_TIMEOUT_MS = 10000;
+export declare const SESSION_SYNC_TIMEOUT_MS = 2000;
+export declare const SESSION_MAX_RETRY_ATTEMPTS = 3;
+export declare const SESSION_CLEANUP_DELAY_MS = 100;
+export declare const CROSS_TAB_INITIALIZATION_LOCK_TIMEOUT_MS = 5000;
+export declare const TAB_HEARTBEAT_INTERVAL_MS = 5000;
+export declare const TAB_ELECTION_TIMEOUT_MS = 2000;
+export declare const TAB_CLEANUP_DELAY_MS = 1000;
+export declare const SESSION_RECOVERY_WINDOW_MULTIPLIER = 2;
+export declare const MAX_SESSION_RECOVERY_ATTEMPTS = 3;
+export declare const MAX_SESSION_RECOVERY_WINDOW_MS: number;
+export declare const MIN_SESSION_RECOVERY_WINDOW_MS: number;
+export declare const SCROLL_SUPPRESS_MULTIPLIER = 2;
+export declare const RETRY_BACKOFF_INITIAL = 1000;
+export declare const RETRY_BACKOFF_MAX = 30000;
+export declare const RATE_LIMIT_INTERVAL = 1000;
+export declare const MAX_RETRY_ATTEMPTS = 10;
+export declare const ALLOWED_API_CONFIG_KEYS: Set<"mode" | "samplingRate" | "excludedUrlPaths" | keyof import("../types").ExclusiveApiConfig>;
+export declare const VALIDATION_MESSAGES: {
+    readonly MISSING_PROJECT_ID: "Project ID is required";
+    readonly PROJECT_ID_EMPTY_AFTER_TRIM: "Project ID is required";
+    readonly INVALID_SESSION_TIMEOUT: "Session timeout must be between 30000ms (30 seconds) and 86400000ms (24 hours)";
+    readonly INVALID_SAMPLING_RATE: "Sampling rate must be greater than 0 and less than or equal to 1";
+    readonly INVALID_ERROR_SAMPLING_RATE: "Error sampling must be between 0 and 1";
+    readonly INVALID_GOOGLE_ANALYTICS_ID: "Google Analytics measurement ID is required when integration is enabled";
+    readonly INVALID_SCROLL_CONTAINER_SELECTORS: "Scroll container selectors must be valid CSS selectors";
+    readonly INVALID_GLOBAL_METADATA: "Global metadata must be an object";
+    readonly INVALID_SENSITIVE_QUERY_PARAMS: "Sensitive query params must be an array of strings";
+};
+export declare const XSS_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];