@tracelog/lib 0.0.8 → 0.2.0

package/dist/esm/api.d.ts

@@ -1,15 +1,12 @@
-import { MetadataType } from './types/common.types';
-import { AppConfig } from './types/config.types';
+import { MetadataType, AppConfig, EmitterCallback, EmitterMap } from './types';
 import './types/window.types';
-export * as Types from './app.types';
-export * as Constants from './app.constants';
 /**
  * Initializes the tracelog app with the provided configuration.
  * If already initialized, this function returns early without error.
  * @param appConfig - The configuration object for the app
- * @throws {Error} If initialization is currently in progress
+ * @throws {Error} If initialization fails or environment is invalid
  * @example
- * await init({ id: 'my-project-id' });
+ * await tracelog.init({ id: 'my-project-id' });
  */
 export declare const init: (appConfig: AppConfig) => Promise<void>;
 /**
@@ -18,29 +15,46 @@ export declare const init: (appConfig: AppConfig) => Promise<void>;
  * @param metadata - Optional metadata to attach to the event.
  * @example
  * // Send a custom event with metadata
- * event('user_signup', { method: 'email', plan: 'premium' });
+ * tracelog.event('user_signup', { method: 'email', plan: 'premium' });
  * @example
  * // Send a custom event without metadata
- * event('user_login');
+ * tracelog.event('user_login');
  * @remarks
- * This function should be called after the app has been initialized using the `init` function.
+ * This function should be called after the app has been initialized using the `tracelog.init` function.
  */
 export declare const event: (name: string, metadata?: Record<string, MetadataType>) => void;
+/**
+ * Subscribe to events emitted by TraceLog
+ * @param event - Event name to listen to
+ * @param callback - Function to call when event is emitted
+ * @example
+ * // Listen for real-time events
+ * tracelog.on('realtime', (data) => {
+ *   console.log('Event tracked:', data.type, data.data);
+ * });
+ *
+ * // Listen for sent events
+ * tracelog.on('sent', (data) => {
+ *   console.log('Events sent:', data.eventCount);
+ * });
+ */
+export declare const on: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
+/**
+ * Unsubscribe from events emitted by TraceLog
+ * @param event - Event name to stop listening to
+ * @param callback - The same function reference that was used in on()
+ * @example
+ * // Remove a specific listener
+ * tracelog.off('realtime', myCallback);
+ */
+export declare const off: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
 /**
  * Checks if the app has been initialized.
  * @returns true if the app is initialized, false otherwise
  */
 export declare const isInitialized: () => boolean;
-/**
- * Gets the current initialization status for debugging purposes.
- * @returns Object with detailed initialization state
- */
-export declare const getInitializationStatus: () => {
-    isInitialized: boolean;
-    isInitializing: boolean;
-    hasInstance: boolean;
-};
 /**
  * Destroys the current app instance and cleans up resources.
+ * @throws {Error} If not initialized or already destroying
  */
-export declare const destroy: () => void;
+export declare const destroy: () => Promise<void>;

package/dist/esm/api.js

@@ -1,83 +1,54 @@
 import { App } from './app';
-import { debugLog } from './utils/logging';
-import { validateAndNormalizeConfig } from './utils/validations';
-import { INITIALIZATION_CONSTANTS } from './constants';
+import { debugLog, validateAndNormalizeConfig } from './utils';
+import { TestBridge } from './test-bridge';
 import './types/window.types';
-export * as Types from './app.types';
-export * as Constants from './app.constants';
 let app = null;
 let isInitializing = false;
+let isDestroying = false;
 /**
  * Initializes the tracelog app with the provided configuration.
  * If already initialized, this function returns early without error.
  * @param appConfig - The configuration object for the app
- * @throws {Error} If initialization is currently in progress
+ * @throws {Error} If initialization fails or environment is invalid
  * @example
- * await init({ id: 'my-project-id' });
+ * await tracelog.init({ id: 'my-project-id' });
  */
 export const init = async (appConfig) => {
+    // Browser environment check
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        throw new Error('This library can only be used in a browser environment');
+    }
+    // Already initialized - safe to return
+    if (app) {
+        debugLog.debug('API', 'Library already initialized, skipping duplicate initialization');
+        return;
+    }
+    // Prevent concurrent initialization
+    if (isInitializing) {
+        debugLog.warn('API', 'Initialization already in progress');
+        throw new Error('Initialization already in progress');
+    }
+    isInitializing = true;
     try {
-        debugLog.info('API', 'Library initialization started', { id: appConfig.id });
-        if (typeof window === 'undefined' || typeof document === 'undefined') {
-            debugLog.clientError('API', 'Browser environment required - this library can only be used in a browser environment', {
-                hasWindow: typeof window !== 'undefined',
-                hasDocument: typeof document !== 'undefined',
-            });
-            throw new Error('This library can only be used in a browser environment');
-        }
-        if (app) {
-            debugLog.debug('API', 'Library already initialized, skipping duplicate initialization', {
-                projectId: appConfig.id,
-            });
-            return;
-        }
-        if (isInitializing) {
-            debugLog.debug('API', 'Concurrent initialization detected, waiting for completion', { projectId: appConfig.id });
-            let retries = 0;
-            const maxRetries = INITIALIZATION_CONSTANTS.MAX_CONCURRENT_RETRIES;
-            const retryDelay = INITIALIZATION_CONSTANTS.CONCURRENT_RETRY_DELAY_MS;
-            while (isInitializing && retries < maxRetries) {
-                await new Promise((resolve) => setTimeout(resolve, retryDelay));
-                retries++;
-            }
-            if (app) {
-                debugLog.debug('API', 'Concurrent initialization completed successfully', {
-                    projectId: appConfig.id,
-                    retriesUsed: retries,
-                });
-                return;
-            }
-            if (isInitializing) {
-                debugLog.error('API', 'Initialization timeout - concurrent initialization took too long', {
-                    projectId: appConfig.id,
-                    retriesUsed: retries,
-                    maxRetries,
-                });
-                throw new Error('App initialization timeout - concurrent initialization took too long');
-            }
-        }
-        isInitializing = true;
-        debugLog.debug('API', 'Validating and normalizing configuration', { projectId: appConfig.id });
+        debugLog.info('API', 'Initializing TraceLog', { projectId: appConfig.id });
         const validatedConfig = validateAndNormalizeConfig(appConfig);
-        debugLog.debug('API', 'Creating App instance', { projectId: validatedConfig.id });
         const instance = new App();
-        await instance.init(validatedConfig);
-        app = instance;
-        debugLog.info('API', 'Library initialization completed successfully', {
-            projectId: validatedConfig.id,
-        });
-    }
-    catch (error) {
-        // Ensure complete cleanup on initialization failure
-        if (app && !app.initialized) {
-            // Clean up partially initialized app instance
+        try {
+            await instance.init(validatedConfig);
+            app = instance;
+            debugLog.info('API', 'TraceLog initialized successfully', { projectId: validatedConfig.id });
+        }
+        catch (error) {
             try {
-                app.destroy();
+                await instance.destroy(true);
             }
             catch (cleanupError) {
                 debugLog.warn('API', 'Failed to cleanup partially initialized app', { cleanupError });
             }
+            throw error;
         }
+    }
+    catch (error) {
         app = null;
         debugLog.error('API', 'Initialization failed', { error });
         throw error;
@@ -92,36 +63,59 @@ export const init = async (appConfig) => {
  * @param metadata - Optional metadata to attach to the event.
  * @example
  * // Send a custom event with metadata
- * event('user_signup', { method: 'email', plan: 'premium' });
+ * tracelog.event('user_signup', { method: 'email', plan: 'premium' });
  * @example
  * // Send a custom event without metadata
- * event('user_login');
+ * tracelog.event('user_login');
  * @remarks
- * This function should be called after the app has been initialized using the `init` function.
+ * This function should be called after the app has been initialized using the `tracelog.init` function.
  */
 export const event = (name, metadata) => {
+    if (!app) {
+        throw new Error('TraceLog not initialized. Please call init() first.');
+    }
     try {
-        if (!app) {
-            debugLog.clientError('API', 'Custom event failed - Library not initialized. Please call TraceLog.init() first', {
-                eventName: name,
-                hasMetadata: !!metadata,
-            });
-            throw new Error('App not initialized');
-        }
-        debugLog.debug('API', 'Sending custom event', {
-            eventName: name,
-            hasMetadata: !!metadata,
-            metadataKeys: metadata ? Object.keys(metadata) : [],
-        });
         app.sendCustomEvent(name, metadata);
     }
     catch (error) {
-        debugLog.error('API', 'Event tracking failed', { eventName: name, error, hasMetadata: !!metadata });
-        if (error instanceof Error &&
-            (error.message === 'App not initialized' || error.message.includes('validation failed'))) {
-            throw error;
-        }
+        debugLog.error('API', 'Failed to send custom event', { eventName: name, error });
+        throw error;
+    }
+};
+/**
+ * Subscribe to events emitted by TraceLog
+ * @param event - Event name to listen to
+ * @param callback - Function to call when event is emitted
+ * @example
+ * // Listen for real-time events
+ * tracelog.on('realtime', (data) => {
+ *   console.log('Event tracked:', data.type, data.data);
+ * });
+ *
+ * // Listen for sent events
+ * tracelog.on('sent', (data) => {
+ *   console.log('Events sent:', data.eventCount);
+ * });
+ */
+export const on = (event, callback) => {
+    if (!app) {
+        throw new Error('TraceLog not initialized. Please call init() first.');
+    }
+    app.on(event, callback);
+};
+/**
+ * Unsubscribe from events emitted by TraceLog
+ * @param event - Event name to stop listening to
+ * @param callback - The same function reference that was used in on()
+ * @example
+ * // Remove a specific listener
+ * tracelog.off('realtime', myCallback);
+ */
+export const off = (event, callback) => {
+    if (!app) {
+        throw new Error('TraceLog not initialized. Please call init() first.');
     }
+    app.off(event, callback);
 };
 /**
  * Checks if the app has been initialized.
@@ -130,54 +124,47 @@ export const event = (name, metadata) => {
 export const isInitialized = () => {
     return app !== null;
 };
-/**
- * Gets the current initialization status for debugging purposes.
- * @returns Object with detailed initialization state
- */
-export const getInitializationStatus = () => {
-    return {
-        isInitialized: app !== null,
-        isInitializing: isInitializing,
-        hasInstance: app !== null,
-    };
-};
 /**
  * Destroys the current app instance and cleans up resources.
+ * @throws {Error} If not initialized or already destroying
  */
-export const destroy = () => {
+export const destroy = async () => {
+    // Check if app was never initialized
+    if (!app) {
+        throw new Error('App not initialized');
+    }
+    // Prevent concurrent destroy operations
+    if (isDestroying) {
+        throw new Error('Destroy operation already in progress');
+    }
+    isDestroying = true;
     try {
-        debugLog.info('API', 'Library cleanup initiated');
-        if (!app) {
-            debugLog.warn('API', 'Cleanup called but Library was not initialized');
-            throw new Error('App not initialized');
-        }
-        app.destroy();
+        debugLog.info('API', 'Destroying TraceLog instance');
+        await app.destroy();
         app = null;
         isInitializing = false;
-        debugLog.info('API', 'Library cleanup completed successfully');
+        debugLog.info('API', 'TraceLog destroyed successfully');
     }
     catch (error) {
-        debugLog.error('API', 'Cleanup failed', { error, hadApp: !!app, wasInitializing: isInitializing });
+        // Force cleanup even if destroy fails
+        app = null;
+        isInitializing = false;
+        debugLog.error('API', 'Error during destroy, forced cleanup', { error });
+        throw error;
+    }
+    finally {
+        isDestroying = false;
     }
 };
-class TestBridge extends App {
-    isInitializing() {
-        return isInitializing;
+// Auto-inject testing bridge in development environments
+if (process.env.NODE_ENV === 'dev' && typeof window !== 'undefined') {
+    const injectTestingBridge = () => {
+        window.__traceLogBridge = new TestBridge(isInitializing, isDestroying);
+    };
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', injectTestingBridge);
     }
-}
-// Auto-inject testing bridge only in development/testing environments
-if (process.env.NODE_ENV === 'dev') {
-    if (typeof window !== 'undefined') {
-        // Wait for DOM to be ready before injecting
-        const injectTestingBridge = () => {
-            window.__traceLogBridge = new TestBridge();
-        };
-        // Inject immediately if DOM is ready, otherwise wait
-        if (document.readyState === 'loading') {
-            document.addEventListener('DOMContentLoaded', injectTestingBridge);
-        }
-        else {
-            injectTestingBridge();
-        }
+    else {
+        injectTestingBridge();
     }
 }

package/dist/esm/app.constants.d.ts

@@ -1 +1,80 @@
-export { DEFAULT_SESSION_TIMEOUT_MS } from './constants';
+export declare const PERFORMANCE_CONFIG: {
+    readonly WEB_VITALS_THRESHOLDS: Record<import("./types").WebVitalType, number>;
+};
+export declare const DATA_PROTECTION: {
+    readonly PII_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+};
+export declare const ENGAGEMENT_THRESHOLDS: {
+    readonly LOW_ACTIVITY_EVENT_COUNT: 50;
+    readonly HIGH_ACTIVITY_EVENT_COUNT: 1000;
+    readonly MIN_EVENTS_FOR_DYNAMIC_CALCULATION: 100;
+    readonly MIN_EVENTS_FOR_TREND_ANALYSIS: 30;
+    readonly BOUNCE_RATE_SESSION_THRESHOLD: 1;
+    readonly MIN_ENGAGED_SESSION_DURATION_MS: number;
+    readonly MIN_SCROLL_DEPTH_ENGAGEMENT: 25;
+};
+export declare const SESSION_ANALYTICS: {
+    readonly INACTIVITY_TIMEOUT_MS: number;
+    readonly SHORT_SESSION_THRESHOLD_MS: number;
+    readonly MEDIUM_SESSION_THRESHOLD_MS: number;
+    readonly LONG_SESSION_THRESHOLD_MS: number;
+    readonly MAX_REALISTIC_SESSION_DURATION_MS: number;
+};
+export declare const DEVICE_ANALYTICS: {
+    readonly MOBILE_MAX_WIDTH: 768;
+    readonly TABLET_MAX_WIDTH: 1024;
+    readonly MOBILE_PERFORMANCE_FACTOR: 1.5;
+    readonly TABLET_PERFORMANCE_FACTOR: 1.2;
+};
+export declare const CONTENT_ANALYTICS: {
+    readonly MIN_TEXT_LENGTH_FOR_ANALYSIS: 10;
+    readonly MIN_CLICKS_FOR_HOT_ELEMENT: 10;
+    readonly MIN_SCROLL_COMPLETION_PERCENT: 80;
+    readonly MIN_TIME_ON_PAGE_FOR_READ_MS: number;
+};
+export declare const INSIGHT_THRESHOLDS: {
+    readonly SIGNIFICANT_CHANGE_PERCENT: 20;
+    readonly MAJOR_CHANGE_PERCENT: 50;
+    readonly MIN_EVENTS_FOR_INSIGHT: 100;
+    readonly MIN_SESSIONS_FOR_INSIGHT: 10;
+    readonly MIN_CORRELATION_STRENGTH: 0.7;
+    readonly LOW_ERROR_RATE_PERCENT: 1;
+    readonly HIGH_ERROR_RATE_PERCENT: 5;
+    readonly CRITICAL_ERROR_RATE_PERCENT: 10;
+};
+export declare const TEMPORAL_ANALYSIS: {
+    readonly SHORT_TERM_TREND_HOURS: 24;
+    readonly MEDIUM_TERM_TREND_DAYS: 7;
+    readonly LONG_TERM_TREND_DAYS: 30;
+    readonly MIN_DATA_POINTS_FOR_TREND: 5;
+    readonly WEEKLY_PATTERN_MIN_WEEKS: 4;
+    readonly DAILY_PATTERN_MIN_DAYS: 14;
+};
+export declare const SEGMENTATION_ANALYTICS: {
+    readonly MIN_SEGMENT_SIZE: 10;
+    readonly MIN_COHORT_SIZE: 5;
+    readonly COHORT_ANALYSIS_DAYS: readonly [1, 3, 7, 14, 30];
+    readonly MIN_FUNNEL_EVENTS: 20;
+};
+export declare const ANALYTICS_QUERY_LIMITS: {
+    readonly DEFAULT_EVENTS_LIMIT: 5;
+    readonly DEFAULT_SESSIONS_LIMIT: 5;
+    readonly DEFAULT_PAGES_LIMIT: 5;
+    readonly MAX_EVENTS_FOR_DEEP_ANALYSIS: 10000;
+    readonly MAX_TIME_RANGE_DAYS: 365;
+    readonly ANALYTICS_BATCH_SIZE: 1000;
+};
+export declare const ANOMALY_DETECTION: {
+    readonly ANOMALY_THRESHOLD_SIGMA: 2.5;
+    readonly STRONG_ANOMALY_THRESHOLD_SIGMA: 3;
+    readonly TRAFFIC_DROP_ALERT_PERCENT: -30;
+    readonly TRAFFIC_SPIKE_ALERT_PERCENT: 200;
+    readonly MIN_BASELINE_DAYS: 7;
+    readonly MIN_EVENTS_FOR_ANOMALY_DETECTION: 50;
+};
+export declare const SPECIAL_VALUES: {
+    readonly PAGE_URL_EXCLUDED: "excluded";
+    readonly PAGE_URL_UNKNOWN: "unknown";
+    readonly IPV6_IPV4_PREFIX: "::ffff:";
+};
+export declare const LOCAL_IP_ADDRESSES: readonly ["localhost", "127.0.0.1", "::1"];

package/dist/esm/app.constants.js

@@ -1 +1,89 @@
-export { DEFAULT_SESSION_TIMEOUT_MS } from './constants';
+// Solo importamos constantes con valor analítico real
+import { WEB_VITALS_THRESHOLDS } from './constants/performance.constants';
+import { PII_PATTERNS } from './constants/error.constants';
+// ============================================================================
+// PERFORMANCE ANALYTICS CONSTANTS
+// ============================================================================
+export const PERFORMANCE_CONFIG = {
+    WEB_VITALS_THRESHOLDS, // Umbrales de negocio para análisis de rendimiento
+};
+// ============================================================================
+// DATA PROTECTION CONSTANTS
+// ============================================================================
+export const DATA_PROTECTION = {
+    PII_PATTERNS, // Patrones para protección de datos sensibles
+};
+export const ENGAGEMENT_THRESHOLDS = {
+    LOW_ACTIVITY_EVENT_COUNT: 50,
+    HIGH_ACTIVITY_EVENT_COUNT: 1000,
+    MIN_EVENTS_FOR_DYNAMIC_CALCULATION: 100,
+    MIN_EVENTS_FOR_TREND_ANALYSIS: 30,
+    BOUNCE_RATE_SESSION_THRESHOLD: 1, // Sessions with 1 page view = bounce
+    MIN_ENGAGED_SESSION_DURATION_MS: 30 * 1000,
+    MIN_SCROLL_DEPTH_ENGAGEMENT: 25, // 25% scroll depth for engagement
+};
+export const SESSION_ANALYTICS = {
+    INACTIVITY_TIMEOUT_MS: 30 * 60 * 1000, // 30min for analytics (vs 15min client)
+    SHORT_SESSION_THRESHOLD_MS: 30 * 1000,
+    MEDIUM_SESSION_THRESHOLD_MS: 5 * 60 * 1000,
+    LONG_SESSION_THRESHOLD_MS: 30 * 60 * 1000,
+    MAX_REALISTIC_SESSION_DURATION_MS: 8 * 60 * 60 * 1000, // Filter outliers
+};
+export const DEVICE_ANALYTICS = {
+    MOBILE_MAX_WIDTH: 768,
+    TABLET_MAX_WIDTH: 1024,
+    MOBILE_PERFORMANCE_FACTOR: 1.5, // Mobile typically 1.5x slower
+    TABLET_PERFORMANCE_FACTOR: 1.2,
+};
+export const CONTENT_ANALYTICS = {
+    MIN_TEXT_LENGTH_FOR_ANALYSIS: 10,
+    MIN_CLICKS_FOR_HOT_ELEMENT: 10, // Popular element threshold
+    MIN_SCROLL_COMPLETION_PERCENT: 80, // Page consumption threshold
+    MIN_TIME_ON_PAGE_FOR_READ_MS: 15 * 1000,
+};
+export const INSIGHT_THRESHOLDS = {
+    SIGNIFICANT_CHANGE_PERCENT: 20,
+    MAJOR_CHANGE_PERCENT: 50,
+    MIN_EVENTS_FOR_INSIGHT: 100,
+    MIN_SESSIONS_FOR_INSIGHT: 10,
+    MIN_CORRELATION_STRENGTH: 0.7, // Strong correlation threshold
+    LOW_ERROR_RATE_PERCENT: 1,
+    HIGH_ERROR_RATE_PERCENT: 5,
+    CRITICAL_ERROR_RATE_PERCENT: 10,
+};
+export const TEMPORAL_ANALYSIS = {
+    SHORT_TERM_TREND_HOURS: 24,
+    MEDIUM_TERM_TREND_DAYS: 7,
+    LONG_TERM_TREND_DAYS: 30,
+    MIN_DATA_POINTS_FOR_TREND: 5,
+    WEEKLY_PATTERN_MIN_WEEKS: 4,
+    DAILY_PATTERN_MIN_DAYS: 14,
+};
+export const SEGMENTATION_ANALYTICS = {
+    MIN_SEGMENT_SIZE: 10,
+    MIN_COHORT_SIZE: 5,
+    COHORT_ANALYSIS_DAYS: [1, 3, 7, 14, 30],
+    MIN_FUNNEL_EVENTS: 20,
+};
+export const ANALYTICS_QUERY_LIMITS = {
+    DEFAULT_EVENTS_LIMIT: 5,
+    DEFAULT_SESSIONS_LIMIT: 5,
+    DEFAULT_PAGES_LIMIT: 5,
+    MAX_EVENTS_FOR_DEEP_ANALYSIS: 10000,
+    MAX_TIME_RANGE_DAYS: 365,
+    ANALYTICS_BATCH_SIZE: 1000, // For historical analysis
+};
+export const ANOMALY_DETECTION = {
+    ANOMALY_THRESHOLD_SIGMA: 2.5,
+    STRONG_ANOMALY_THRESHOLD_SIGMA: 3.0,
+    TRAFFIC_DROP_ALERT_PERCENT: -30,
+    TRAFFIC_SPIKE_ALERT_PERCENT: 200,
+    MIN_BASELINE_DAYS: 7,
+    MIN_EVENTS_FOR_ANOMALY_DETECTION: 50,
+};
+export const SPECIAL_VALUES = {
+    PAGE_URL_EXCLUDED: 'excluded',
+    PAGE_URL_UNKNOWN: 'unknown',
+    IPV6_IPV4_PREFIX: '::ffff:',
+};
+export const LOCAL_IP_ADDRESSES = ['localhost', '127.0.0.1', '::1'];

package/dist/esm/app.d.ts

@@ -1,59 +1,44 @@
 import { EventManager } from './managers/event.manager';
-import { AppConfig } from './types/config.types';
 import { StateManager } from './managers/state.manager';
 import { SessionHandler } from './handlers/session.handler';
 import { PageViewHandler } from './handlers/page-view.handler';
 import { ClickHandler } from './handlers/click.handler';
 import { ScrollHandler } from './handlers/scroll.handler';
+import { AppConfig, EmitterCallback, EmitterMap } from './types';
 import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
 import { StorageManager } from './managers/storage.manager';
 import { PerformanceHandler } from './handlers/performance.handler';
 import { ErrorHandler } from './handlers/error.handler';
-import { NetworkHandler } from './handlers/network.handler';
+/**
+ * Main application class for TraceLog analytics
+ * Orchestrates event tracking, session management, and integrations
+ */
 export declare class App extends StateManager {
-    protected isInitialized: boolean;
-    protected googleAnalytics: GoogleAnalyticsIntegration | null;
-    protected storageManager: StorageManager;
-    protected eventManager: EventManager;
-    protected sessionHandler: SessionHandler;
-    protected pageViewHandler: PageViewHandler;
-    protected clickHandler: ClickHandler;
-    protected scrollHandler: ScrollHandler;
-    protected performanceHandler: PerformanceHandler;
-    protected errorHandler: ErrorHandler;
-    protected networkHandler: NetworkHandler;
-    protected suppressNextScrollTimer: number | null;
-    /**
-     * Returns the initialization status of the app
-     * @returns true if the app is fully initialized, false otherwise
-     */
+    private isInitialized;
+    private suppressNextScrollTimer;
+    private readonly emitter;
+    protected managers: {
+        storage?: StorageManager;
+        event?: EventManager;
+    };
+    protected handlers: {
+        session?: SessionHandler;
+        pageView?: PageViewHandler;
+        click?: ClickHandler;
+        scroll?: ScrollHandler;
+        performance?: PerformanceHandler;
+        error?: ErrorHandler;
+    };
+    protected integrations: {
+        googleAnalytics?: GoogleAnalyticsIntegration;
+    };
     get initialized(): boolean;
     init(appConfig: AppConfig): Promise<void>;
-    /**
-     * 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
-     */
-    private validateAppReadiness;
     sendCustomEvent(name: string, metadata?: Record<string, unknown>): void;
-    destroy(): void;
-    private setState;
-    private setApiUrl;
-    private setConfig;
-    private setUserId;
-    private setDevice;
-    private setPageUrl;
-    private setIntegrations;
-    private initHandlers;
-    private initStorage;
-    private setEventManager;
-    private initSessionHandler;
-    private initPageViewHandler;
-    private onPageViewTrack;
-    private initClickHandler;
-    private initScrollHandler;
-    private initPerformanceHandler;
-    private initErrorHandler;
-    private initNetworkHandler;
+    on<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
+    off<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
+    destroy(force?: boolean): Promise<void>;
+    private setupState;
+    private setupIntegrations;
+    private initializeHandlers;
 }