@zaplier/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1204 @@
+/**
+ * Visitor-related types for SDK responses
+ */
+/**
+ * Visitor information returned by getVisitorInfo()
+ */
+interface VisitorInfo {
+    visitorId: string;
+    workspaceId: string;
+    location: {
+        country?: string;
+        countryCode?: string;
+        city?: string;
+    };
+    device: {
+        browser?: string;
+        os?: string;
+        deviceType?: string;
+        userAgent?: string;
+    };
+    stats: {
+        visitCount: number;
+        firstSeenAt: string;
+        lastSeenAt: string;
+        identificationScore?: number;
+    };
+    signals?: {
+        smartSignals?: any;
+        tlsFingerprint?: string | null;
+        cookieFingerprint?: string | null;
+    };
+}
+/**
+ * Visit history entry
+ */
+interface VisitHistoryEntry {
+    id: string;
+    timestamp: string;
+    location: string | null;
+    country?: string | null;
+    countryCode?: string | null;
+    city?: string | null;
+    ip: string | null;
+    browser: string | null;
+    os: string | null;
+    deviceType: string | null;
+    isIncognito: boolean;
+    vpnDetected: boolean;
+    suspectScore: number;
+}
+/**
+ * Visitor history response
+ */
+interface VisitorHistory {
+    visitorId: string;
+    visits: VisitHistoryEntry[];
+    summary: {
+        totalVisits: number;
+        uniqueIPs: number;
+        uniqueLocations: number;
+        incognitoSessions: number;
+    };
+}
+/**
+ * User data returned by getUserData()
+ */
+interface UserData {
+    sessionId: string;
+    visitorId?: string;
+    userId?: string;
+    location: {
+        city?: string;
+        country?: string;
+        coordinates?: {
+            lat: number;
+            lng: number;
+        };
+    };
+    device: {
+        userAgent: string;
+        language: string;
+        screen: {
+            width: number;
+            height: number;
+        };
+    };
+    journey: any[];
+    fingerprint?: string;
+}
+
+/**
+ * SDK Configuration Types
+ *
+ * 100% Cookieless tracking using fingerprinting only.
+ * No storage dependencies - fully GDPR/LGPD compliant.
+ */
+interface SDKConfig {
+    /** Workspace token (required) */
+    token: string;
+    /** Enable session replay recording (default: false) */
+    replay?: boolean;
+    /** Enable heatmap tracking (default: false) */
+    heatmap?: boolean;
+    /** Enable debug mode for development (default: false) */
+    debug?: boolean;
+    /** Allow tracking on localhost (default: false) */
+    allow_localhost?: boolean;
+    /** GDPR mode - limits invasive fingerprinting (default: false) */
+    gdprMode?: boolean;
+}
+/**
+ * Internal configuration with optimized defaults
+ * These settings are not exposed to the user but can be referenced internally
+ */
+interface InternalConfig extends SDKConfig {
+    apiEndpoint: string;
+    retryEnabled: boolean;
+    maxRetries: number;
+    retryDelays: number[];
+    autoTrack: boolean;
+    dedupeEnabled: boolean;
+    fingerprintEnabled: boolean;
+    presenceTracking: boolean;
+    heartbeatInterval: number;
+    scrollTracking: boolean;
+    scrollDepthTracking: boolean;
+    gdprCompliant: boolean;
+    enhancedTracking: 'ask' | 'true' | 'false';
+    replaySampling: number;
+    replayMaskInputs: boolean;
+}
+type ConfigKey = keyof SDKConfig;
+type InternalConfigKey = keyof InternalConfig;
+
+/**
+ * Event and Tracking Types
+ */
+interface BaseEventData {
+    eventType: string;
+    eventName?: string;
+    customData?: Record<string, any>;
+}
+interface PageViewEvent extends BaseEventData {
+    eventType: 'page_view';
+    url?: string;
+    pageTitle?: string;
+    referrer?: string;
+    spaNavigation?: boolean;
+    navigationType?: 'manual' | 'spa' | 'direct';
+}
+interface CustomEvent extends BaseEventData {
+    eventType: 'custom';
+    eventName: string;
+    metadata?: Record<string, any>;
+}
+interface ConversionEvent extends BaseEventData {
+    eventType: 'conversion';
+    eventName: string;
+    revenue?: number;
+    currency?: string;
+    metadata?: Record<string, any>;
+}
+interface EcommerceEvent extends BaseEventData {
+    eventType: 'purchase' | 'add_to_cart' | 'view_content' | 'initiate_checkout';
+    productId?: string;
+    productName?: string;
+    price?: number;
+    quantity?: number;
+    revenue?: number;
+    currency?: string;
+    orderId?: string;
+}
+interface IdentifyEvent extends BaseEventData {
+    eventType: 'identify';
+    email?: string;
+    phone?: string;
+    userData?: Record<string, any>;
+}
+type EventData = PageViewEvent | CustomEvent | ConversionEvent | EcommerceEvent | IdentifyEvent;
+/**
+ * Internal event payload sent to server
+ */
+interface EventPayload {
+    eventId: string;
+    eventType: string;
+    eventName?: string;
+    sessionId: string;
+    userId?: string;
+    timestamp: string;
+    url: string;
+    referrer?: string;
+    pageTitle?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+    utmContent?: string;
+    utmTerm?: string;
+    fbclid?: string;
+    gclid?: string;
+    ttclid?: string;
+    fbp?: string;
+    fbc?: string;
+    userAgent: string;
+    screenWidth: number;
+    screenHeight: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    fingerprint?: string;
+    fingerprintComponents?: FingerprintComponents;
+    botDetection?: BotDetectionResult$2;
+    incognitoDetection?: IncognitoDetectionResult$2;
+    gdprMode: boolean;
+    enhancedMode: boolean;
+    customData?: Record<string, any>;
+    revenue?: number;
+    currency?: string;
+    productId?: string;
+    productName?: string;
+    quantity?: number;
+    orderId?: string;
+}
+/**
+ * Fingerprinting component results
+ */
+interface FingerprintComponents {
+    canvas?: string;
+    webgl?: {
+        vendor: string;
+        renderer: string;
+        version: string;
+    };
+    audio?: string;
+    fonts?: string[];
+    screen: {
+        width: number;
+        height: number;
+        colorDepth: number;
+        pixelRatio: number;
+    };
+    timezone: number;
+    language: string;
+    platform: string;
+    hardwareConcurrency?: number;
+    deviceMemory?: number;
+}
+/**
+ * Bot detection result
+ */
+interface BotDetectionResult$2 {
+    isBot: boolean;
+    confidence: number;
+    detectors: {
+        webDriver: {
+            detected: boolean;
+            confidence: number;
+        };
+        headlessBrowser: {
+            detected: boolean;
+            confidence: number;
+        };
+        domBlockers: {
+            detected: boolean;
+            confidence: number;
+        };
+        canvasInconsistency: {
+            detected: boolean;
+            confidence: number;
+        };
+        webglAnomaly: {
+            detected: boolean;
+            confidence: number;
+        };
+        missingLanguages: {
+            detected: boolean;
+            confidence: number;
+        };
+        inconsistentEval: {
+            detected: boolean;
+            confidence: number;
+        };
+        automationTools: {
+            detected: boolean;
+            confidence: number;
+        };
+    };
+    userAgent?: {
+        suspicious: boolean;
+        patterns: string[];
+    };
+}
+/**
+ * Incognito mode detection result
+ */
+interface IncognitoDetectionResult$2 {
+    isIncognito: boolean;
+    confidence: number;
+    detectionMethods: {
+        localStorage: boolean | null;
+        indexedDB: boolean | null;
+        sessionStorage: boolean | null;
+        openDatabase: boolean | null;
+        permissions: boolean | null;
+        quotaManagement: boolean | null;
+        filesystem: boolean | null;
+        cookiesEnabled: boolean | null;
+    };
+}
+
+/**
+ * Method parameter types for SDK calls
+ */
+/**
+ * Parameters for trackPurchase()
+ */
+interface TrackPurchaseParams {
+    value?: number;
+    revenue?: number;
+    currency?: string;
+    quantity?: number;
+    productId?: string;
+    productName?: string;
+    orderId?: string;
+    customData?: Record<string, any>;
+}
+/**
+ * Parameters for trackAddToCart()
+ */
+interface TrackAddToCartParams {
+    productId?: string;
+    productName?: string;
+    price?: number;
+    quantity?: number;
+    customData?: Record<string, any>;
+}
+/**
+ * Parameters for trackViewContent()
+ */
+interface TrackViewContentParams {
+    productId?: string;
+    productName?: string;
+    category?: string;
+    customData?: Record<string, any>;
+}
+/**
+ * Parameters for trackInitiateCheckout()
+ */
+interface TrackInitiateCheckoutParams {
+    value?: number;
+    currency?: string;
+    numItems?: number;
+    customData?: Record<string, any>;
+}
+/**
+ * Parameters for trackConversion()
+ */
+interface TrackConversionParams {
+    eventName: string;
+    value?: number;
+    currency?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Parameters for identify()
+ */
+interface IdentifyParams {
+    email?: string;
+    phone?: string;
+    [key: string]: any;
+}
+/**
+ * Parameters for trackCustomEvent()
+ */
+interface TrackCustomEventParams {
+    eventName: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Response from trackConversion()
+ */
+interface ConversionLikelihoodResponse {
+    score: number;
+    factors: string[];
+}
+/**
+ * Response from getUserSegment()
+ */
+interface UserSegmentResponse {
+    type: "high_intent" | "medium_intent" | "exploring";
+    confidence: number;
+}
+
+/**
+ * Fingerprinting Types
+ * Based on FingerprintJS architecture with privacy-first approach
+ */
+/**
+ * Individual fingerprint component
+ */
+interface FingerprintComponent<T = any> {
+    value: T;
+    duration?: number;
+    error?: string;
+}
+/**
+ * Canvas fingerprinting result
+ */
+interface CanvasFingerprint {
+    text: string;
+    geometry: string;
+    winding: boolean;
+    isInconsistent?: boolean;
+}
+/**
+ * WebGL fingerprinting result
+ */
+interface WebGLFingerprint {
+    vendor: string;
+    renderer: string;
+    version: string;
+    extensions: string[];
+    parameters: Record<string, any>;
+    shaderPrecision: {
+        vertex: string;
+        fragment: string;
+    };
+}
+/**
+ * Audio fingerprinting result
+ */
+interface AudioFingerprint {
+    oscillator: string;
+    compressor: string;
+    sampleRate: number;
+    maxChannelCount: number;
+}
+/**
+ * Font detection result
+ */
+interface FontFingerprint {
+    available: string[];
+    method: "basic" | "advanced";
+    measurements?: Record<string, {
+        width: number;
+        height: number;
+    }>;
+}
+/**
+ * Screen and viewport information
+ */
+interface ScreenFingerprint {
+    width: number;
+    height: number;
+    colorDepth: number;
+    pixelRatio: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    availableWidth: number;
+    availableHeight: number;
+    orientation?: {
+        angle: number;
+        type: string;
+    };
+}
+/**
+ * Browser and system information
+ */
+interface BrowserFingerprint {
+    language: string;
+    languages: string[];
+    timezone: string;
+    timezoneOffset: number;
+    platform: string;
+    userAgent: string;
+    hardwareConcurrency: number;
+    deviceMemory?: number;
+    cookieEnabled: boolean;
+    doNotTrack: string | null;
+    plugins: {
+        length: number;
+        names: string[];
+    };
+    touchSupport: {
+        maxTouchPoints: number;
+        touchEvent: boolean;
+        touchStart: boolean;
+    };
+}
+/**
+ * Complete fingerprint data
+ */
+interface FingerprintData {
+    canvas?: FingerprintComponent<CanvasFingerprint>;
+    webgl?: FingerprintComponent<WebGLFingerprint>;
+    audio?: FingerprintComponent<AudioFingerprint>;
+    fonts?: FingerprintComponent<FontFingerprint>;
+    screen: FingerprintComponent<ScreenFingerprint>;
+    browser: FingerprintComponent<BrowserFingerprint>;
+    incognitoDetection?: {
+        isIncognito: boolean;
+        confidence: number;
+        detectionMethods: string[];
+        detectionTimestamp?: number;
+        sdkVersion?: string;
+        details?: {
+            localStorage?: boolean;
+            sessionStorage?: boolean;
+            indexedDB?: boolean;
+            cookiesEnabled?: boolean;
+            quota?: number | null;
+            permissions?: any;
+        };
+    };
+    hash: string;
+    stableCoreHash: string;
+    stableCoreVector?: Record<string, any>;
+    collectionTime: number;
+    gdprMode: boolean;
+    components: string[];
+}
+/**
+ * Fingerprint collection options
+ */
+interface FingerprintOptions {
+    gdprMode?: boolean;
+    includeInvasive?: boolean;
+    timeout?: number;
+    debug?: boolean;
+    excludeComponents?: FingerprintComponentType[];
+}
+/**
+ * Available fingerprint component types
+ */
+type FingerprintComponentType = "canvas" | "webgl" | "audio" | "fonts" | "screen" | "browser" | "incognito" | "hardware" | "system" | "storage" | "math" | "domBlockers" | "accessibility" | "browserApis" | "pluginsEnhanced" | "fontPreferences" | "dateTimeLocale" | "enhancedFonts" | "mathFingerprint" | "accessibilityEnhanced";
+/**
+ * Fingerprint collection result
+ */
+interface FingerprintResult {
+    success: boolean;
+    data?: FingerprintData;
+    error?: string;
+    collectedComponents: FingerprintComponentType[];
+    failedComponents: {
+        component: FingerprintComponentType;
+        error: string;
+    }[];
+    confidence?: any;
+}
+
+interface BotDetectionResult$1 {
+    isBot: boolean;
+    confidence: number;
+    riskLevel: "low" | "medium" | "high";
+}
+interface IncognitoDetectionResult$1 {
+    isIncognito: boolean;
+    confidence: number;
+    detectionMethods: string[];
+}
+interface UserAgentAnalysis$1 {
+    browser: string;
+    version: string;
+    engine: string;
+    os: string;
+    device: string;
+}
+/**
+ * Main SDK interface
+ */
+interface ZaplierSDK$1 {
+    track(eventType: string, eventData?: Record<string, any>): void;
+    trackCustomEvent(eventName: string, metadata?: Record<string, any>): boolean;
+    trackConversion(eventName: string, value?: number, currency?: string, metadata?: Record<string, any>): boolean;
+    trackPageView(data?: Partial<PageViewEvent>): void;
+    trackPurchase(data: TrackPurchaseParams): void;
+    trackAddToCart(data?: TrackAddToCartParams): void;
+    trackViewContent(data?: TrackViewContentParams): void;
+    trackInitiateCheckout(data?: TrackInitiateCheckoutParams): void;
+    trackLead(data?: Record<string, any>): void;
+    identify(userData: IdentifyParams): void;
+    trackSPANavigation(url?: string, title?: string): void;
+    resetScrollTracking(): void;
+    startPresenceTracking(): void;
+    stopPresenceTracking(): void;
+    heatmap: {
+        enable(): void;
+        disable(): void;
+    };
+    replay: {
+        enable(): void;
+        disable(): void;
+        addFunnelStep(stepData: Record<string, any>): void;
+        markConversion(data: Record<string, any>): void;
+    };
+    enableEnhancedTracking(): boolean;
+    disableEnhancedTracking(): void;
+    isEnhancedMode(): boolean;
+    getVisitorId(): string | null;
+    getVisitorInfo(): Promise<VisitorInfo | null>;
+    getVisitorHistory(): Promise<VisitorHistory | null>;
+    getUserData(): UserData;
+    getConversionLikelihood(): ConversionLikelihoodResponse;
+    getUserSegment(): UserSegmentResponse;
+    config: InternalConfig;
+    version: string;
+}
+/**
+ * Global window interface extension
+ */
+declare global {
+    interface Window {
+        Zaplier?: ZaplierSDK$1;
+        zaplier?: ZaplierSDK$1;
+        stalker?: {
+            config?: Partial<SDKConfig>;
+            q?: any[][];
+        } & ZaplierSDK$1;
+    }
+}
+
+/**
+ * Zaplier SDK v1.0.0
+ * 100% Cookieless Analytics Tracking
+ *
+ * Main SDK class for client-side tracking integration
+ */
+
+/**
+ * Main Zaplier SDK Class
+ */
+declare class ZaplierSDK implements ZaplierSDK$1 {
+    config: InternalConfig;
+    version: string;
+    private visitorId?;
+    private backendVisitorId?;
+    private sessionId?;
+    private fingerprint?;
+    private isInitialized;
+    private eventQueue;
+    private replayEngine?;
+    private heatmapEngine?;
+    private antiAdblockManager?;
+    constructor(userConfig: SDKConfig);
+    /**
+     * Initialize SDK
+     */
+    private initialize;
+    /**
+     * Initialize tracking engines (Session Replay & Heatmap)
+     */
+    private initializeTrackingEngines;
+    /**
+     * Generate session ID
+     */
+    private generateSessionId;
+    /**
+     * Initialize Anti-Adblock Manager
+     */
+    private initializeAntiAdblock;
+    /**
+     * Collect fingerprint and generate visitor ID (IMPROVED - 2024)
+     * Enhanced with better incognito detection
+     */
+    private collectFingerprint;
+    /**
+     * Check if running on localhost
+     */
+    private isLocalhost;
+    /**
+     * Send event to backend
+     */
+    private sendEvent;
+    /**
+     * Make HTTP request to backend using anti-adblock system
+     */
+    private makeRequest;
+    /**
+     * Process queued events
+     */
+    private processEventQueue;
+    /**
+     * Track generic event
+     */
+    track(eventType: string, eventData?: Record<string, any>): void;
+    /**
+     * Track custom event
+     */
+    trackCustomEvent(eventName: string, metadata?: Record<string, any>): boolean;
+    /**
+     * Track conversion event
+     */
+    trackConversion(eventName: string, value?: number, currency?: string, metadata?: Record<string, any>): boolean;
+    /**
+     * Track page view
+     */
+    trackPageView(data?: Partial<PageViewEvent>): void;
+    /**
+     * Track purchase
+     */
+    trackPurchase(data: {
+        value?: number;
+        revenue?: number;
+        currency?: string;
+        quantity?: number;
+        productId?: string;
+        productName?: string;
+        orderId?: string;
+        customData?: Record<string, any>;
+    }): void;
+    /**
+     * Track add to cart
+     */
+    trackAddToCart(data?: {
+        productId?: string;
+        productName?: string;
+        price?: number;
+        quantity?: number;
+        customData?: Record<string, any>;
+    }): void;
+    /**
+     * Track view content
+     */
+    trackViewContent(data?: {
+        productId?: string;
+        productName?: string;
+        category?: string;
+        customData?: Record<string, any>;
+    }): void;
+    /**
+     * Track initiate checkout
+     */
+    trackInitiateCheckout(data?: {
+        value?: number;
+        currency?: string;
+        numItems?: number;
+        customData?: Record<string, any>;
+    }): void;
+    /**
+     * Track lead
+     */
+    trackLead(data?: Record<string, any>): void;
+    /**
+     * Identify user
+     */
+    identify(userData: {
+        email?: string;
+        phone?: string;
+        [key: string]: any;
+    }): void;
+    /**
+     * Track SPA navigation
+     */
+    trackSPANavigation(url?: string, title?: string): void;
+    /**
+     * Reset scroll tracking
+     */
+    resetScrollTracking(): void;
+    /**
+     * Start presence tracking
+     */
+    startPresenceTracking(): void;
+    /**
+     * Stop presence tracking
+     */
+    stopPresenceTracking(): void;
+    /**
+     * Heatmap API
+     */
+    heatmap: {
+        enable: () => void;
+        disable: () => void;
+        enableMouseTracking: () => void;
+        disableMouseTracking: () => void;
+        getStats: () => {
+            clickCount: number;
+            maxScrollDepth: number;
+            isRecording: boolean;
+            mouseMovements: number;
+            rageClicks: number;
+        } | null;
+        isRecording: () => boolean;
+    };
+    /**
+     * Replay API
+     */
+    replay: {
+        enable: () => void;
+        disable: () => void;
+        start: () => boolean;
+        stop: () => void;
+        isRecording: () => boolean;
+        getEventCount: () => number;
+        addFunnelStep: (stepData: Record<string, any>) => void;
+        markConversion: (data: Record<string, any>) => void;
+    };
+    /**
+     * Enable enhanced tracking
+     */
+    enableEnhancedTracking(): boolean;
+    /**
+     * Disable enhanced tracking
+     */
+    disableEnhancedTracking(): void;
+    /**
+     * Check if enhanced mode is active
+     */
+    isEnhancedMode(): boolean;
+    /**
+     * Get visitor ID (real UUID from backend, or fallback)
+     */
+    getVisitorId(): string | null;
+    /**
+     * Get visitor information from backend
+     * Returns detailed visitor data including location, device info, and stats
+     *
+     * IMPORTANT: Only uses backendVisitorId (UUID), not the local visitorId with 'vis_' prefix
+     */
+    getVisitorInfo(): Promise<VisitorInfo | null>;
+    /**
+     * Get visitor history (visits/events)
+     * Returns visit history with location, IP, incognito, VPN detection
+     */
+    getVisitorHistory(): Promise<VisitorHistory | null>;
+    /**
+     * Get user data
+     */
+    getUserData(): UserData;
+    /**
+     * Get conversion likelihood (mock implementation)
+     */
+    getConversionLikelihood(): {
+        score: number;
+        factors: string[];
+    };
+    /**
+     * Get user segment (mock implementation)
+     */
+    getUserSegment(): {
+        type: "high_intent" | "medium_intent" | "exploring";
+        confidence: number;
+    };
+}
+
+/**
+ * Global Interface for Zaplier SDK
+ * Provides unified API for both Script tag and NPM usage
+ */
+
+/**
+ * Unified Zaplier interface
+ */
+declare const Zaplier: {
+    /**
+     * Initialize SDK
+     */
+    init: (config: SDKConfig) => ZaplierSDK;
+    /**
+     * Get current instance
+     */
+    getInstance: () => ZaplierSDK | null;
+    /**
+     * Track custom event
+     */
+    track: (eventType: string, eventData?: Record<string, any>) => void;
+    /**
+     * Track page view
+     */
+    trackPageView: (data?: any) => void;
+    /**
+     * Track custom event (alias for track)
+     */
+    trackEvent: (eventName: string, metadata?: Record<string, any>) => boolean;
+    /**
+     * Track conversion
+     */
+    trackConversion: (conversionType: string, value?: number, currency?: string, metadata?: Record<string, any>) => void;
+    /**
+     * Track purchase
+     */
+    trackPurchase: (data: {
+        value: number;
+        currency?: string;
+        items?: Array<{
+            id: string;
+            name: string;
+            category?: string;
+            quantity?: number;
+            price?: number;
+        }>;
+        orderId?: string;
+        coupon?: string;
+    }) => void;
+    /**
+     * Track add to cart
+     */
+    trackAddToCart: (data?: {
+        productId?: string;
+        productName?: string;
+        price?: number;
+        quantity?: number;
+        customData?: Record<string, any>;
+    }) => void;
+    /**
+     * Identify user
+     */
+    identify: (userData: {
+        email?: string;
+        name?: string;
+        id?: string;
+        properties?: Record<string, any>;
+    }) => void;
+    /**
+     * Get visitor ID
+     */
+    getVisitorId: () => string | null;
+    /**
+     * Get visitor info
+     */
+    getVisitorInfo: () => Promise<any>;
+    /**
+     * Get user data
+     */
+    getUserData: () => any;
+    /**
+     * Enable enhanced tracking
+     */
+    enableEnhancedTracking: () => boolean;
+    /**
+     * Disable enhanced tracking
+     */
+    disableEnhancedTracking: () => void;
+    /**
+     * Check if enhanced mode is active
+     */
+    isEnhancedMode: () => boolean;
+    /**
+     * Heatmap controls
+     */
+    heatmap: {
+        enable: () => void;
+        disable: () => void;
+        enableMouseTracking: () => void;
+        disableMouseTracking: () => void;
+        getStats: () => {
+            clickCount: number;
+            maxScrollDepth: number;
+            isRecording: boolean;
+            mouseMovements: number;
+            rageClicks: number;
+        } | null;
+        isRecording: () => boolean;
+    };
+    /**
+     * Session replay controls
+     */
+    replay: {
+        enable: () => void;
+        disable: () => void;
+        start: () => boolean;
+        stop: () => void;
+        isRecording: () => boolean;
+        getEventCount: () => number;
+        addFunnelStep: (stepData: Record<string, any>) => void;
+        markConversion: (data: Record<string, any>) => void;
+    };
+    /**
+     * Debug and utility functions
+     */
+    debug: {
+        getStats: () => any;
+        getSuccessRates: () => any;
+        testTransports: () => any;
+    };
+    /**
+     * Version info
+     */
+    version: string;
+};
+/**
+ * Auto-initialization from script tag data attributes
+ */
+declare function autoInitializeFromScript(): void;
+
+/**
+ * Fingerprint Orchestrator
+ * Main fingerprinting engine that coordinates all components
+ * Based on FingerprintJS architecture with privacy-first approach
+ */
+
+/**
+ * Main fingerprint collection function
+ */
+declare function collectFingerprint(options?: Partial<FingerprintOptions>): Promise<FingerprintResult>;
+/**
+ * Generate visitor ID from fingerprint
+ */
+declare function generateVisitorIdFromFingerprint(fingerprintData: FingerprintData): string;
+/**
+ * Get a lightweight fingerprint (GDPR-compliant)
+ */
+declare function getLightweightFingerprint(): Promise<FingerprintResult>;
+/**
+ * Get a complete fingerprint (enhanced mode)
+ */
+declare function getCompleteFingerprint(): Promise<FingerprintResult>;
+/**
+ * Clear session fingerprint cache (memory only)
+ */
+declare function clearFingerprintCache(): void;
+/**
+ * Check if fingerprinting is available
+ */
+declare function isFingerprintingAvailable(): boolean;
+/**
+ * Get available fingerprinting components
+ */
+declare function getAvailableComponents(): FingerprintComponentType[];
+
+/**
+ * Detection Types
+ *
+ * Types for bot detection and incognito detection functionality
+ */
+/**
+ * Generic detection result
+ */
+interface DetectionResult {
+    detected: boolean;
+    confidence: number;
+    method: string;
+    details?: Record<string, any>;
+}
+/**
+ * Bot detection result
+ */
+interface BotDetectionResult {
+    isBot: boolean;
+    confidence: number;
+    riskLevel: 'low' | 'medium' | 'high';
+    detectionMethods: string[];
+    detectors?: BotDetectionMethods;
+    userAgent?: UserAgentAnalysis;
+    details?: {
+        userAgent?: string;
+        suspiciousPatterns?: string[];
+        timing?: Record<string, number>;
+        capabilities?: Record<string, boolean>;
+    };
+}
+/**
+ * Bot detection methods interface
+ */
+interface BotDetectionMethods {
+    [key: string]: DetectionResult;
+}
+/**
+ * Incognito detection result
+ */
+interface IncognitoDetectionResult {
+    isIncognito: boolean;
+    confidence: number;
+    detectionMethods: string[];
+    details?: {
+        localStorage?: boolean | null;
+        sessionStorage?: boolean | null;
+        indexedDB?: boolean | null;
+        cookiesEnabled?: boolean | null;
+        quota?: number | null;
+        permissions?: Record<string, any>;
+    };
+}
+/**
+ * User agent analysis result
+ */
+interface UserAgentAnalysis {
+    browser: {
+        name: string;
+        version: string;
+        major: string;
+        engine: string;
+    };
+    os: {
+        name: string;
+        version: string;
+        family?: string;
+    };
+    device: {
+        type: string;
+        vendor?: string;
+        model?: string;
+    };
+    cpu?: {
+        architecture: string;
+    };
+    suspicious?: {
+        isBot: boolean;
+        patterns: string[];
+        category: string;
+    };
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isBot: boolean;
+    raw: string;
+}
+
+/**
+ * Bot Detection Module
+ * Comprehensive client-side bot detection based on multiple techniques
+ * Detects headless browsers, automation tools, and suspicious behavior
+ */
+
+/**
+ * Main bot detection function
+ */
+declare function detectBot(): Promise<BotDetectionResult>;
+/**
+ * Quick bot detection (faster, less comprehensive)
+ */
+declare function quickBotDetection(): Promise<boolean>;
+
+/**
+ * Incognito Mode Detection (Analytics Only)
+ *
+ * Detects private/incognito browsing mode for analytics purposes only.
+ * Does NOT use localStorage/sessionStorage for tracking or data persistence.
+ * Used only to enrich analytics data with browser context information.
+ */
+
+/**
+ * Main incognito detection function (IMPROVED - 2024)
+ *
+ * Enhanced with:
+ * - Weighted scoring system to reduce false positives
+ * - Browser-specific detection weights
+ * - Multi-signal validation requirements
+ * - Improved confidence thresholds
+ */
+declare function detectIncognitoMode(): Promise<IncognitoDetectionResult>;
+/**
+ * Quick incognito detection (less comprehensive but faster)
+ */
+declare function quickIncognitoDetection(): Promise<boolean>;
+
+/**
+ * Enhanced User Agent Parser
+ * Based on FingerprintJS browser detection with advanced engine and version parsing
+ */
+
+/**
+ * Browser engine detection (based on FingerprintJS)
+ */
+declare function isChromium(): boolean;
+declare function isWebKit(): boolean;
+declare function isGecko(): boolean;
+declare function isSamsungInternet(): boolean;
+declare function isIPad(): boolean;
+declare function isAndroid(): boolean;
+/**
+ * Enhanced user agent analysis
+ */
+declare function analyzeUserAgent(userAgent?: string): UserAgentAnalysis;
+/**
+ * Get browser engine type
+ */
+declare function getBrowserEngine(): 'chromium' | 'webkit' | 'gecko' | 'trident' | 'unknown';
+/**
+ * Check if running on mobile device
+ */
+declare function isMobile(): boolean;
+/**
+ * Check if running on tablet
+ */
+declare function isTablet(): boolean;
+/**
+ * Check if running on desktop
+ */
+declare function isDesktop(): boolean;
+
+/**
+ * MurmurHash3 x64 Implementation
+ * Based on FingerprintJS hashing utility for consistent fingerprint generation
+ *
+ * Provides 128-bit hash output using the x64 variant of MurmurHash3
+ */
+/**
+ * MurmurHash3 x64 128-bit hash function
+ * Returns a 128-bit hash as a hex string
+ */
+declare function x64hash128(input: string, seed?: number): string;
+/**
+ * Simple 32-bit hash for basic use cases
+ */
+declare function hash32(input: string): string;
+/**
+ * Hash fingerprint components into a stable identifier
+ */
+declare function hashFingerprint(components: Record<string, any>): string;
+/**
+ * Generate a visitor ID from fingerprint hash
+ */
+declare function generateVisitorId(fingerprintHash: string): string;
+
+export { Zaplier, ZaplierSDK, analyzeUserAgent, autoInitializeFromScript, clearFingerprintCache, collectFingerprint, ZaplierSDK as default, detectBot, detectIncognitoMode, generateVisitorId, generateVisitorIdFromFingerprint, getAvailableComponents, getBrowserEngine, getCompleteFingerprint, getLightweightFingerprint, hash32, hashFingerprint, isAndroid, isChromium, isDesktop, isFingerprintingAvailable, isGecko, isIPad, isMobile, isSamsungInternet, isTablet, isWebKit, quickBotDetection, quickIncognitoDetection, x64hash128 };
+export type { AudioFingerprint, BaseEventData, BotDetectionResult$1 as BotDetectionResult, BrowserFingerprint, CanvasFingerprint, ConfigKey, ConversionEvent, ConversionLikelihoodResponse, CustomEvent, EcommerceEvent, BotDetectionResult$2 as EventBotDetectionResult, EventData, IncognitoDetectionResult$2 as EventIncognitoDetectionResult, EventPayload, FingerprintComponent, FingerprintComponentType, FingerprintComponents, FingerprintData, FingerprintOptions, FingerprintResult, FontFingerprint, IdentifyEvent, IdentifyParams, IncognitoDetectionResult$1 as IncognitoDetectionResult, InternalConfig, InternalConfigKey, PageViewEvent, SDKConfig, ScreenFingerprint, TrackAddToCartParams, TrackConversionParams, TrackCustomEventParams, TrackInitiateCheckoutParams, TrackPurchaseParams, TrackViewContentParams, UserAgentAnalysis$1 as UserAgentAnalysis, UserData, UserSegmentResponse, VisitHistoryEntry, VisitorHistory, VisitorInfo, WebGLFingerprint };