@clianta/sdk 1.2.0 → 1.4.0

package/dist/clianta.esm.js

@@ -1,5 +1,5 @@
 /*!
- * Clianta SDK v1.2.0
+ * Clianta SDK v1.4.0
  * (c) 2026 Clianta
  * Released under the MIT License.
  */
@@ -8,7 +8,7 @@
  * @see SDK_VERSION in core/config.ts
  */
 /** SDK Version */
-const SDK_VERSION = '1.2.0';
+const SDK_VERSION = '1.4.0';
 /** Default API endpoint based on environment */
 const getDefaultApiEndpoint = () => {
     if (typeof window === 'undefined')
@@ -28,13 +28,13 @@ const DEFAULT_PLUGINS = [
     'engagement',
     'downloads',
     'exitIntent',
-    'popupForms',
 ];
 /** Default configuration values */
 const DEFAULT_CONFIG = {
     projectId: '',
     apiEndpoint: getDefaultApiEndpoint(),
     authToken: '',
+    apiKey: '',
     debug: false,
     autoPageView: true,
     plugins: DEFAULT_PLUGINS,
@@ -182,12 +182,39 @@ class Transport {
         return this.send(url, payload);
     }
     /**
-     * Send identify request
+     * Send identify request.
+     * Returns contactId from the server response so the Tracker can store it.
      */
     async sendIdentify(data) {
         const url = `${this.config.apiEndpoint}/api/public/track/identify`;
-        const payload = JSON.stringify(data);
-        return this.send(url, payload);
+        try {
+            const response = await this.fetchWithTimeout(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(data),
+                keepalive: true,
+            });
+            const body = await response.json().catch(() => ({}));
+            if (response.ok) {
+                logger.debug('Identify successful, contactId:', body.contactId);
+                return {
+                    success: true,
+                    status: response.status,
+                    contactId: body.contactId ?? undefined,
+                };
+            }
+            if (response.status >= 500) {
+                logger.warn(`Identify server error (${response.status})`);
+            }
+            else {
+                logger.error(`Identify failed with status ${response.status}:`, body.message);
+            }
+            return { success: false, status: response.status };
+        }
+        catch (error) {
+            logger.error('Identify request failed:', error);
+            return { success: false, error: error };
+        }
     }
     /**
      * Send events synchronously (for page unload)
@@ -586,6 +613,10 @@ class EventQueue {
         this.isFlushing = false;
         /** Rate limiting: timestamps of recent events */
         this.eventTimestamps = [];
+        /** Unload handler references for cleanup */
+        this.boundBeforeUnload = null;
+        this.boundVisibilityChange = null;
+        this.boundPageHide = null;
         this.transport = transport;
         this.config = {
             batchSize: config.batchSize ?? 10,
@@ -700,13 +731,25 @@ class EventQueue {
         this.persistQueue([]);
     }
     /**
-     * Stop the flush timer
+     * Stop the flush timer and cleanup handlers
      */
     destroy() {
         if (this.flushTimer) {
             clearInterval(this.flushTimer);
             this.flushTimer = null;
         }
+        // Remove unload handlers
+        if (typeof window !== 'undefined') {
+            if (this.boundBeforeUnload) {
+                window.removeEventListener('beforeunload', this.boundBeforeUnload);
+            }
+            if (this.boundVisibilityChange) {
+                window.removeEventListener('visibilitychange', this.boundVisibilityChange);
+            }
+            if (this.boundPageHide) {
+                window.removeEventListener('pagehide', this.boundPageHide);
+            }
+        }
     }
     /**
      * Start auto-flush timer
@@ -726,19 +769,18 @@ class EventQueue {
         if (typeof window === 'undefined')
             return;
         // Flush on page unload
-        window.addEventListener('beforeunload', () => {
-            this.flushSync();
-        });
+        this.boundBeforeUnload = () => this.flushSync();
+        window.addEventListener('beforeunload', this.boundBeforeUnload);
         // Flush when page becomes hidden
-        window.addEventListener('visibilitychange', () => {
+        this.boundVisibilityChange = () => {
             if (document.visibilityState === 'hidden') {
                 this.flushSync();
             }
-        });
+        };
+        window.addEventListener('visibilitychange', this.boundVisibilityChange);
         // Flush on page hide (iOS Safari)
-        window.addEventListener('pagehide', () => {
-            this.flushSync();
-        });
+        this.boundPageHide = () => this.flushSync();
+        window.addEventListener('pagehide', this.boundPageHide);
     }
     /**
      * Persist queue to localStorage
@@ -881,6 +923,10 @@ class ScrollPlugin extends BasePlugin {
         this.pageLoadTime = 0;
         this.scrollTimeout = null;
         this.boundHandler = null;
+        /** SPA navigation support */
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+        this.popstateHandler = null;
     }
     init(tracker) {
         super.init(tracker);
@@ -888,6 +934,8 @@ class ScrollPlugin extends BasePlugin {
         if (typeof window !== 'undefined') {
             this.boundHandler = this.handleScroll.bind(this);
             window.addEventListener('scroll', this.boundHandler, { passive: true });
+            // Setup SPA navigation reset
+            this.setupNavigationReset();
         }
     }
     destroy() {
@@ -897,8 +945,53 @@ class ScrollPlugin extends BasePlugin {
         if (this.scrollTimeout) {
             clearTimeout(this.scrollTimeout);
         }
+        // Restore original history methods
+        if (this.originalPushState) {
+            history.pushState = this.originalPushState;
+            this.originalPushState = null;
+        }
+        if (this.originalReplaceState) {
+            history.replaceState = this.originalReplaceState;
+            this.originalReplaceState = null;
+        }
+        // Remove popstate listener
+        if (this.popstateHandler && typeof window !== 'undefined') {
+            window.removeEventListener('popstate', this.popstateHandler);
+            this.popstateHandler = null;
+        }
         super.destroy();
     }
+    /**
+     * Reset scroll tracking for SPA navigation
+     */
+    resetForNavigation() {
+        this.milestonesReached.clear();
+        this.maxScrollDepth = 0;
+        this.pageLoadTime = Date.now();
+    }
+    /**
+     * Setup History API interception for SPA navigation
+     */
+    setupNavigationReset() {
+        if (typeof window === 'undefined')
+            return;
+        // Store originals for cleanup
+        this.originalPushState = history.pushState;
+        this.originalReplaceState = history.replaceState;
+        // Intercept pushState and replaceState
+        const self = this;
+        history.pushState = function (...args) {
+            self.originalPushState.apply(history, args);
+            self.resetForNavigation();
+        };
+        history.replaceState = function (...args) {
+            self.originalReplaceState.apply(history, args);
+            self.resetForNavigation();
+        };
+        // Handle back/forward navigation
+        this.popstateHandler = () => this.resetForNavigation();
+        window.addEventListener('popstate', this.popstateHandler);
+    }
     handleScroll() {
         // Debounce scroll tracking
         if (this.scrollTimeout) {
@@ -951,6 +1044,7 @@ class FormsPlugin extends BasePlugin {
         this.trackedForms = new WeakSet();
         this.formInteractions = new Set();
         this.observer = null;
+        this.listeners = [];
     }
     init(tracker) {
         super.init(tracker);
@@ -969,8 +1063,20 @@ class FormsPlugin extends BasePlugin {
             this.observer.disconnect();
             this.observer = null;
         }
+        // Remove all tracked event listeners
+        for (const { element, event, handler } of this.listeners) {
+            element.removeEventListener(event, handler);
+        }
+        this.listeners = [];
         super.destroy();
     }
+    /**
+     * Track event listener for cleanup
+     */
+    addListener(element, event, handler) {
+        element.addEventListener(event, handler);
+        this.listeners.push({ element, event, handler });
+    }
     trackAllForms() {
         document.querySelectorAll('form').forEach((form) => {
             this.setupFormTracking(form);
@@ -996,7 +1102,7 @@ class FormsPlugin extends BasePlugin {
                 if (!field.name || field.type === 'submit' || field.type === 'button')
                     return;
                 ['focus', 'blur', 'change'].forEach((eventType) => {
-                    field.addEventListener(eventType, () => {
+                    const handler = () => {
                         const key = `${formId}-${field.name}-${eventType}`;
                         if (!this.formInteractions.has(key)) {
                             this.formInteractions.add(key);
@@ -1007,12 +1113,13 @@ class FormsPlugin extends BasePlugin {
                                 interactionType: eventType,
                             });
                         }
-                    });
+                    };
+                    this.addListener(field, eventType, handler);
                 });
             }
         });
         // Track form submission
-        form.addEventListener('submit', () => {
+        const submitHandler = () => {
             this.track('form_submit', 'Form Submitted', {
                 formId,
                 action: form.action,
@@ -1020,7 +1127,8 @@ class FormsPlugin extends BasePlugin {
             });
             // Auto-identify if email field found
             this.autoIdentify(form);
-        });
+        };
+        this.addListener(form, 'submit', submitHandler);
     }
     autoIdentify(form) {
         const emailField = form.querySelector('input[type="email"], input[name*="email"]');
@@ -1104,6 +1212,7 @@ class EngagementPlugin extends BasePlugin {
         this.engagementTimeout = null;
         this.boundMarkEngaged = null;
         this.boundTrackTimeOnPage = null;
+        this.boundVisibilityHandler = null;
     }
     init(tracker) {
         super.init(tracker);
@@ -1114,12 +1223,7 @@ class EngagementPlugin extends BasePlugin {
         // Setup engagement detection
         this.boundMarkEngaged = this.markEngaged.bind(this);
         this.boundTrackTimeOnPage = this.trackTimeOnPage.bind(this);
-        ['mousemove', 'keydown', 'touchstart', 'scroll'].forEach((event) => {
-            document.addEventListener(event, this.boundMarkEngaged, { passive: true });
-        });
-        // Track time on page before unload
-        window.addEventListener('beforeunload', this.boundTrackTimeOnPage);
-        window.addEventListener('visibilitychange', () => {
+        this.boundVisibilityHandler = () => {
             if (document.visibilityState === 'hidden') {
                 this.trackTimeOnPage();
             }
@@ -1127,7 +1231,13 @@ class EngagementPlugin extends BasePlugin {
                 // Reset engagement timer when page becomes visible again
                 this.engagementStartTime = Date.now();
             }
+        };
+        ['mousemove', 'keydown', 'touchstart', 'scroll'].forEach((event) => {
+            document.addEventListener(event, this.boundMarkEngaged, { passive: true });
         });
+        // Track time on page before unload
+        window.addEventListener('beforeunload', this.boundTrackTimeOnPage);
+        document.addEventListener('visibilitychange', this.boundVisibilityHandler);
     }
     destroy() {
         if (this.boundMarkEngaged && typeof document !== 'undefined') {
@@ -1138,6 +1248,9 @@ class EngagementPlugin extends BasePlugin {
         if (this.boundTrackTimeOnPage && typeof window !== 'undefined') {
             window.removeEventListener('beforeunload', this.boundTrackTimeOnPage);
         }
+        if (this.boundVisibilityHandler && typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', this.boundVisibilityHandler);
+        }
         if (this.engagementTimeout) {
             clearTimeout(this.engagementTimeout);
         }
@@ -1182,20 +1295,69 @@ class DownloadsPlugin extends BasePlugin {
         this.name = 'downloads';
         this.trackedDownloads = new Set();
         this.boundHandler = null;
+        /** SPA navigation support */
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+        this.popstateHandler = null;
     }
     init(tracker) {
         super.init(tracker);
         if (typeof document !== 'undefined') {
             this.boundHandler = this.handleClick.bind(this);
             document.addEventListener('click', this.boundHandler, true);
+            // Setup SPA navigation reset
+            this.setupNavigationReset();
         }
     }
     destroy() {
         if (this.boundHandler && typeof document !== 'undefined') {
             document.removeEventListener('click', this.boundHandler, true);
         }
+        // Restore original history methods
+        if (this.originalPushState) {
+            history.pushState = this.originalPushState;
+            this.originalPushState = null;
+        }
+        if (this.originalReplaceState) {
+            history.replaceState = this.originalReplaceState;
+            this.originalReplaceState = null;
+        }
+        // Remove popstate listener
+        if (this.popstateHandler && typeof window !== 'undefined') {
+            window.removeEventListener('popstate', this.popstateHandler);
+            this.popstateHandler = null;
+        }
         super.destroy();
     }
+    /**
+     * Reset download tracking for SPA navigation
+     */
+    resetForNavigation() {
+        this.trackedDownloads.clear();
+    }
+    /**
+     * Setup History API interception for SPA navigation
+     */
+    setupNavigationReset() {
+        if (typeof window === 'undefined')
+            return;
+        // Store originals for cleanup
+        this.originalPushState = history.pushState;
+        this.originalReplaceState = history.replaceState;
+        // Intercept pushState and replaceState
+        const self = this;
+        history.pushState = function (...args) {
+            self.originalPushState.apply(history, args);
+            self.resetForNavigation();
+        };
+        history.replaceState = function (...args) {
+            self.originalReplaceState.apply(history, args);
+            self.resetForNavigation();
+        };
+        // Handle back/forward navigation
+        this.popstateHandler = () => this.resetForNavigation();
+        window.addEventListener('popstate', this.popstateHandler);
+    }
     handleClick(e) {
         const link = e.target.closest('a');
         if (!link || !link.href)
@@ -1321,16 +1483,33 @@ class PerformancePlugin extends BasePlugin {
     constructor() {
         super(...arguments);
         this.name = 'performance';
+        this.boundLoadHandler = null;
+        this.observers = [];
+        this.boundClsVisibilityHandler = null;
     }
     init(tracker) {
         super.init(tracker);
         if (typeof window !== 'undefined') {
             // Track performance after page load
-            window.addEventListener('load', () => {
+            this.boundLoadHandler = () => {
                 // Delay to ensure all metrics are available
                 setTimeout(() => this.trackPerformance(), 100);
-            });
+            };
+            window.addEventListener('load', this.boundLoadHandler);
+        }
+    }
+    destroy() {
+        if (this.boundLoadHandler && typeof window !== 'undefined') {
+            window.removeEventListener('load', this.boundLoadHandler);
         }
+        for (const observer of this.observers) {
+            observer.disconnect();
+        }
+        this.observers = [];
+        if (this.boundClsVisibilityHandler && typeof window !== 'undefined') {
+            window.removeEventListener('visibilitychange', this.boundClsVisibilityHandler);
+        }
+        super.destroy();
     }
     trackPerformance() {
         if (typeof performance === 'undefined')
@@ -1388,6 +1567,7 @@ class PerformancePlugin extends BasePlugin {
                     }
                 });
                 lcpObserver.observe({ type: 'largest-contentful-paint', buffered: true });
+                this.observers.push(lcpObserver);
             }
             catch {
                 // LCP not supported
@@ -1405,6 +1585,7 @@ class PerformancePlugin extends BasePlugin {
                     }
                 });
                 fidObserver.observe({ type: 'first-input', buffered: true });
+                this.observers.push(fidObserver);
             }
             catch {
                 // FID not supported
@@ -1421,15 +1602,17 @@ class PerformancePlugin extends BasePlugin {
                     });
                 });
                 clsObserver.observe({ type: 'layout-shift', buffered: true });
+                this.observers.push(clsObserver);
                 // Report CLS after page is hidden
-                window.addEventListener('visibilitychange', () => {
+                this.boundClsVisibilityHandler = () => {
                     if (document.visibilityState === 'hidden' && clsValue > 0) {
                         this.track('performance', 'Web Vital - CLS', {
                             metric: 'CLS',
                             value: Math.round(clsValue * 1000) / 1000,
                         });
                     }
-                }, { once: true });
+                };
+                window.addEventListener('visibilitychange', this.boundClsVisibilityHandler, { once: true });
             }
             catch {
                 // CLS not supported
@@ -1740,7 +1923,7 @@ class PopupFormsPlugin extends BasePlugin {
                     label.appendChild(requiredMark);
                 }
                 fieldWrapper.appendChild(label);
-                // Input/Textarea
+                // Input/Textarea/Select
                 if (field.type === 'textarea') {
                     const textarea = document.createElement('textarea');
                     textarea.name = field.name;
@@ -1751,6 +1934,38 @@ class PopupFormsPlugin extends BasePlugin {
                     textarea.style.cssText = 'width: 100%; padding: 8px 12px; border: 1px solid #E4E4E7; border-radius: 6px; font-size: 14px; resize: vertical; min-height: 80px; box-sizing: border-box;';
                     fieldWrapper.appendChild(textarea);
                 }
+                else if (field.type === 'select') {
+                    const select = document.createElement('select');
+                    select.name = field.name;
+                    if (field.required)
+                        select.required = true;
+                    select.style.cssText = 'width: 100%; padding: 8px 12px; border: 1px solid #E4E4E7; border-radius: 6px; font-size: 14px; box-sizing: border-box; background: white; cursor: pointer;';
+                    // Add placeholder option
+                    if (field.placeholder) {
+                        const placeholderOption = document.createElement('option');
+                        placeholderOption.value = '';
+                        placeholderOption.textContent = field.placeholder;
+                        placeholderOption.disabled = true;
+                        placeholderOption.selected = true;
+                        select.appendChild(placeholderOption);
+                    }
+                    // Add options from field.options array if provided
+                    if (field.options && Array.isArray(field.options)) {
+                        field.options.forEach((opt) => {
+                            const option = document.createElement('option');
+                            if (typeof opt === 'string') {
+                                option.value = opt;
+                                option.textContent = opt;
+                            }
+                            else {
+                                option.value = opt.value;
+                                option.textContent = opt.label;
+                            }
+                            select.appendChild(option);
+                        });
+                    }
+                    fieldWrapper.appendChild(select);
+                }
                 else {
                     const input = document.createElement('input');
                     input.type = field.type;
@@ -1784,96 +1999,6 @@ class PopupFormsPlugin extends BasePlugin {
         formElement.appendChild(submitBtn);
         container.appendChild(formElement);
     }
-    buildFormHTML(form) {
-        const style = form.style || {};
-        const primaryColor = style.primaryColor || '#10B981';
-        const textColor = style.textColor || '#18181B';
-        let fieldsHTML = form.fields.map(field => {
-            const requiredMark = field.required ? '<span style="color: #EF4444;">*</span>' : '';
-            if (field.type === 'textarea') {
-                return `
-                    <div style="margin-bottom: 12px;">
-                        <label style="display: block; font-size: 14px; font-weight: 500; margin-bottom: 4px; color: ${textColor};">
-                            ${field.label} ${requiredMark}
-                        </label>
-                        <textarea
-                            name="${field.name}"
-                            placeholder="${field.placeholder || ''}"
-                            ${field.required ? 'required' : ''}
-                            style="width: 100%; padding: 8px 12px; border: 1px solid #E4E4E7; border-radius: 6px; font-size: 14px; resize: vertical; min-height: 80px;"
-                        ></textarea>
-                    </div>
-                `;
-            }
-            else if (field.type === 'checkbox') {
-                return `
-                    <div style="margin-bottom: 12px;">
-                        <label style="display: flex; align-items: center; gap: 8px; font-size: 14px; color: ${textColor}; cursor: pointer;">
-                            <input
-                                type="checkbox"
-                                name="${field.name}"
-                                ${field.required ? 'required' : ''}
-                                style="width: 16px; height: 16px;"
-                            />
-                            ${field.label} ${requiredMark}
-                        </label>
-                    </div>
-                `;
-            }
-            else {
-                return `
-                    <div style="margin-bottom: 12px;">
-                        <label style="display: block; font-size: 14px; font-weight: 500; margin-bottom: 4px; color: ${textColor};">
-                            ${field.label} ${requiredMark}
-                        </label>
-                        <input
-                            type="${field.type}"
-                            name="${field.name}"
-                            placeholder="${field.placeholder || ''}"
-                            ${field.required ? 'required' : ''}
-                            style="width: 100%; padding: 8px 12px; border: 1px solid #E4E4E7; border-radius: 6px; font-size: 14px; box-sizing: border-box;"
-                        />
-                    </div>
-                `;
-            }
-        }).join('');
-        return `
-            <button id="clianta-form-close" style="
-                position: absolute;
-                top: 12px;
-                right: 12px;
-                background: none;
-                border: none;
-                font-size: 20px;
-                cursor: pointer;
-                color: #71717A;
-                padding: 4px;
-            ">&times;</button>
-            <h2 style="font-size: 20px; font-weight: 700; margin-bottom: 8px; color: ${textColor};">
-                ${form.headline || 'Stay in touch'}
-            </h2>
-            <p style="font-size: 14px; color: #71717A; margin-bottom: 16px;">
-                ${form.subheadline || 'Get the latest updates'}
-            </p>
-            <form id="clianta-form-element">
-                ${fieldsHTML}
-                <button type="submit" style="
-                    width: 100%;
-                    padding: 10px 16px;
-                    background: ${primaryColor};
-                    color: white;
-                    border: none;
-                    border-radius: 6px;
-                    font-size: 14px;
-                    font-weight: 500;
-                    cursor: pointer;
-                    margin-top: 8px;
-                ">
-                    ${form.submitButtonText || 'Subscribe'}
-                </button>
-            </form>
-        `;
-    }
     setupFormEvents(form, overlay, container) {
         // Close button
         const closeBtn = container.querySelector('#clianta-form-close');
@@ -2264,310 +2389,436 @@ class ConsentManager {
 }
 
 /**
- * Clianta SDK - Main Tracker Class
- * @see SDK_VERSION in core/config.ts
+ * Clianta SDK - Event Triggers Manager
+ * Manages event-driven automation and email notifications
  */
 /**
- * Main Clianta Tracker Class
+ * Event Triggers Manager
+ * Handles event-driven automation based on CRM actions
+ *
+ * Similar to:
+ * - Salesforce: Process Builder, Flow Automation
+ * - HubSpot: Workflows, Email Sequences
+ * - Pipedrive: Workflow Automation
  */
-class Tracker {
-    constructor(workspaceId, userConfig = {}) {
-        this.plugins = [];
-        this.isInitialized = false;
-        if (!workspaceId) {
-            throw new Error('[Clianta] Workspace ID is required');
-        }
+class EventTriggersManager {
+    constructor(apiEndpoint, workspaceId, authToken) {
+        this.triggers = new Map();
+        this.listeners = new Map();
+        this.apiEndpoint = apiEndpoint;
         this.workspaceId = workspaceId;
-        this.config = mergeConfig(userConfig);
-        // Setup debug mode
-        logger.enabled = this.config.debug;
-        logger.info(`Initializing SDK v${SDK_VERSION}`, { workspaceId });
-        // Initialize consent manager
-        this.consentManager = new ConsentManager({
-            ...this.config.consent,
-            onConsentChange: (state, previous) => {
-                this.onConsentChange(state, previous);
-            },
-        });
-        // Initialize transport and queue
-        this.transport = new Transport({ apiEndpoint: this.config.apiEndpoint });
-        this.queue = new EventQueue(this.transport, {
-            batchSize: this.config.batchSize,
-            flushInterval: this.config.flushInterval,
-        });
-        // Get or create visitor and session IDs based on mode
-        this.visitorId = this.createVisitorId();
-        this.sessionId = this.createSessionId();
-        logger.debug('IDs created', { visitorId: this.visitorId, sessionId: this.sessionId });
-        // Initialize plugins
-        this.initPlugins();
-        this.isInitialized = true;
-        logger.info('SDK initialized successfully');
+        this.authToken = authToken;
     }
     /**
-     * Create visitor ID based on storage mode
+     * Set authentication token
      */
-    createVisitorId() {
-        // Anonymous mode: use temporary ID until consent
-        if (this.config.consent.anonymousMode && !this.consentManager.hasExplicit()) {
-            const key = STORAGE_KEYS.VISITOR_ID + '_anon';
-            let anonId = getSessionStorage(key);
-            if (!anonId) {
-                anonId = 'anon_' + generateUUID();
-                setSessionStorage(key, anonId);
-            }
-            return anonId;
+    setAuthToken(token) {
+        this.authToken = token;
+    }
+    /**
+     * Make authenticated API request
+     */
+    async request(endpoint, options = {}) {
+        const url = `${this.apiEndpoint}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(options.headers || {}),
+        };
+        if (this.authToken) {
+            headers['Authorization'] = `Bearer ${this.authToken}`;
         }
-        // Cookie-less mode: use sessionStorage only
-        if (this.config.cookielessMode) {
-            let visitorId = getSessionStorage(STORAGE_KEYS.VISITOR_ID);
-            if (!visitorId) {
-                visitorId = generateUUID();
-                setSessionStorage(STORAGE_KEYS.VISITOR_ID, visitorId);
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: data.message || 'Request failed',
+                    status: response.status,
+                };
             }
-            return visitorId;
+            return {
+                success: true,
+                data: data.data || data,
+                status: response.status,
+            };
         }
-        // Normal mode
-        return getOrCreateVisitorId(this.config.useCookies);
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Network error',
+                status: 0,
+            };
+        }
+    }
+    // ============================================
+    // TRIGGER MANAGEMENT
+    // ============================================
+    /**
+     * Get all event triggers
+     */
+    async getTriggers() {
+        return this.request(`/api/workspaces/${this.workspaceId}/triggers`);
     }
     /**
-     * Create session ID
+     * Get a single trigger by ID
      */
-    createSessionId() {
-        return getOrCreateSessionId(this.config.sessionTimeout);
+    async getTrigger(triggerId) {
+        return this.request(`/api/workspaces/${this.workspaceId}/triggers/${triggerId}`);
     }
     /**
-     * Handle consent state changes
+     * Create a new event trigger
      */
-    onConsentChange(state, previous) {
-        logger.debug('Consent changed:', { from: previous, to: state });
-        // If analytics consent was just granted
-        if (state.analytics && !previous.analytics) {
-            // Upgrade from anonymous ID to persistent ID
-            if (this.config.consent.anonymousMode) {
-                this.visitorId = getOrCreateVisitorId(this.config.useCookies);
-                logger.info('Upgraded from anonymous to persistent visitor ID');
-            }
-            // Flush buffered events
-            const buffered = this.consentManager.flushBuffer();
-            for (const event of buffered) {
-                // Update event with new visitor ID
-                event.visitorId = this.visitorId;
-                this.queue.push(event);
-            }
+    async createTrigger(trigger) {
+        const result = await this.request(`/api/workspaces/${this.workspaceId}/triggers`, {
+            method: 'POST',
+            body: JSON.stringify(trigger),
+        });
+        // Cache the trigger locally if successful
+        if (result.success && result.data?._id) {
+            this.triggers.set(result.data._id, result.data);
         }
+        return result;
     }
     /**
-     * Initialize enabled plugins
-     * Handles both sync and async plugin init methods
+     * Update an existing trigger
      */
-    initPlugins() {
-        const pluginsToLoad = this.config.plugins;
-        // Skip pageView plugin if autoPageView is disabled
-        const filteredPlugins = this.config.autoPageView
-            ? pluginsToLoad
-            : pluginsToLoad.filter((p) => p !== 'pageView');
-        for (const pluginName of filteredPlugins) {
-            try {
-                const plugin = getPlugin(pluginName);
-                // Handle both sync and async init (fire-and-forget for async)
-                const result = plugin.init(this);
-                if (result instanceof Promise) {
-                    result.catch((error) => {
-                        logger.error(`Async plugin init failed: ${pluginName}`, error);
-                    });
-                }
-                this.plugins.push(plugin);
-                logger.debug(`Plugin loaded: ${pluginName}`);
-            }
-            catch (error) {
-                logger.error(`Failed to load plugin: ${pluginName}`, error);
-            }
+    async updateTrigger(triggerId, updates) {
+        const result = await this.request(`/api/workspaces/${this.workspaceId}/triggers/${triggerId}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+        // Update cache if successful
+        if (result.success && result.data?._id) {
+            this.triggers.set(result.data._id, result.data);
         }
+        return result;
     }
     /**
-     * Track a custom event
+     * Delete a trigger
      */
-    track(eventType, eventName, properties = {}) {
-        if (!this.isInitialized) {
-            logger.warn('SDK not initialized, event dropped');
-            return;
-        }
-        const event = {
-            workspaceId: this.workspaceId,
-            visitorId: this.visitorId,
-            sessionId: this.sessionId,
-            eventType: eventType,
-            eventName,
-            url: typeof window !== 'undefined' ? window.location.href : '',
-            referrer: typeof document !== 'undefined' ? document.referrer || undefined : undefined,
-            properties,
-            device: getDeviceInfo(),
-            utm: getUTMParams(),
-            timestamp: new Date().toISOString(),
-            sdkVersion: SDK_VERSION,
-        };
-        // Check consent before tracking
-        if (!this.consentManager.canTrack()) {
-            // Buffer event for later if waitForConsent is enabled
-            if (this.config.consent.waitForConsent) {
-                this.consentManager.bufferEvent(event);
-                return;
-            }
-            // Otherwise drop the event
-            logger.debug('Event dropped (no consent):', eventName);
-            return;
+    async deleteTrigger(triggerId) {
+        const result = await this.request(`/api/workspaces/${this.workspaceId}/triggers/${triggerId}`, {
+            method: 'DELETE',
+        });
+        // Remove from cache if successful
+        if (result.success) {
+            this.triggers.delete(triggerId);
         }
-        this.queue.push(event);
-        logger.debug('Event tracked:', eventName, properties);
+        return result;
     }
     /**
-     * Track a page view
+     * Activate a trigger
      */
-    page(name, properties = {}) {
-        const pageName = name || (typeof document !== 'undefined' ? document.title : 'Page View');
-        this.track('page_view', pageName, {
-            ...properties,
-            path: typeof window !== 'undefined' ? window.location.pathname : '',
-        });
+    async activateTrigger(triggerId) {
+        return this.updateTrigger(triggerId, { isActive: true });
     }
     /**
-     * Identify a visitor
+     * Deactivate a trigger
      */
-    async identify(email, traits = {}) {
-        if (!email) {
-            logger.warn('Email is required for identification');
-            return;
-        }
-        logger.info('Identifying visitor:', email);
-        const result = await this.transport.sendIdentify({
-            workspaceId: this.workspaceId,
-            visitorId: this.visitorId,
-            email,
-            properties: traits,
-        });
-        if (result.success) {
-            logger.info('Visitor identified successfully');
-        }
-        else {
-            logger.error('Failed to identify visitor:', result.error);
-        }
+    async deactivateTrigger(triggerId) {
+        return this.updateTrigger(triggerId, { isActive: false });
     }
+    // ============================================
+    // EVENT HANDLING (CLIENT-SIDE)
+    // ============================================
     /**
-     * Update consent state
+     * Register a local event listener for client-side triggers
+     * This allows immediate client-side reactions to events
      */
-    consent(state) {
-        this.consentManager.update(state);
+    on(eventType, callback) {
+        if (!this.listeners.has(eventType)) {
+            this.listeners.set(eventType, new Set());
+        }
+        this.listeners.get(eventType).add(callback);
+        logger.debug(`Event listener registered: ${eventType}`);
     }
     /**
-     * Get current consent state
+     * Remove an event listener
      */
-    getConsentState() {
-        return this.consentManager.getState();
+    off(eventType, callback) {
+        const listeners = this.listeners.get(eventType);
+        if (listeners) {
+            listeners.delete(callback);
+        }
     }
     /**
-     * Toggle debug mode
+     * Emit an event (client-side only)
+     * This will trigger any registered local listeners
      */
-    debug(enabled) {
-        logger.enabled = enabled;
-        logger.info(`Debug mode ${enabled ? 'enabled' : 'disabled'}`);
+    emit(eventType, data) {
+        logger.debug(`Event emitted: ${eventType}`, data);
+        const listeners = this.listeners.get(eventType);
+        if (listeners) {
+            listeners.forEach(callback => {
+                try {
+                    callback(data);
+                }
+                catch (error) {
+                    logger.error(`Error in event listener for ${eventType}:`, error);
+                }
+            });
+        }
     }
     /**
-     * Get visitor ID
-     */
-    getVisitorId() {
-        return this.visitorId;
+     * Check if conditions are met for a trigger
+     * Supports dynamic field evaluation including custom fields and nested paths
+     */
+    evaluateConditions(conditions, data) {
+        if (!conditions || conditions.length === 0) {
+            return true; // No conditions means always fire
+        }
+        return conditions.every(condition => {
+            // Support dot notation for nested fields (e.g., 'customFields.industry')
+            const fieldValue = condition.field.includes('.')
+                ? this.getNestedValue(data, condition.field)
+                : data[condition.field];
+            const targetValue = condition.value;
+            switch (condition.operator) {
+                case 'equals':
+                    return fieldValue === targetValue;
+                case 'not_equals':
+                    return fieldValue !== targetValue;
+                case 'contains':
+                    return String(fieldValue).includes(String(targetValue));
+                case 'greater_than':
+                    return Number(fieldValue) > Number(targetValue);
+                case 'less_than':
+                    return Number(fieldValue) < Number(targetValue);
+                case 'in':
+                    return Array.isArray(targetValue) && targetValue.includes(fieldValue);
+                case 'not_in':
+                    return Array.isArray(targetValue) && !targetValue.includes(fieldValue);
+                default:
+                    return false;
+            }
+        });
     }
     /**
-     * Get session ID
+     * Execute actions for a triggered event (client-side preview)
+     * Note: Actual execution happens on the backend
      */
-    getSessionId() {
-        return this.sessionId;
+    async executeActions(trigger, data) {
+        logger.info(`Executing actions for trigger: ${trigger.name}`);
+        for (const action of trigger.actions) {
+            try {
+                await this.executeAction(action, data);
+            }
+            catch (error) {
+                logger.error(`Failed to execute action:`, error);
+            }
+        }
     }
     /**
-     * Get workspace ID
-     */
-    getWorkspaceId() {
-        return this.workspaceId;
+     * Execute a single action
+     */
+    async executeAction(action, data) {
+        switch (action.type) {
+            case 'send_email':
+                await this.executeSendEmail(action, data);
+                break;
+            case 'webhook':
+                await this.executeWebhook(action, data);
+                break;
+            case 'create_task':
+                await this.executeCreateTask(action, data);
+                break;
+            case 'update_contact':
+                await this.executeUpdateContact(action, data);
+                break;
+            default:
+                logger.warn(`Unknown action type:`, action);
+        }
+    }
+    /**
+     * Execute send email action (via backend API)
+     */
+    async executeSendEmail(action, data) {
+        logger.debug('Sending email:', action);
+        const payload = {
+            to: this.replaceVariables(action.to, data),
+            subject: action.subject ? this.replaceVariables(action.subject, data) : undefined,
+            body: action.body ? this.replaceVariables(action.body, data) : undefined,
+            templateId: action.templateId,
+            cc: action.cc,
+            bcc: action.bcc,
+            from: action.from,
+            delayMinutes: action.delayMinutes,
+        };
+        await this.request(`/api/workspaces/${this.workspaceId}/emails/send`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
     }
     /**
-     * Get current configuration
+     * Execute webhook action
      */
-    getConfig() {
-        return { ...this.config };
+    async executeWebhook(action, data) {
+        logger.debug('Calling webhook:', action.url);
+        const body = action.body ? this.replaceVariables(action.body, data) : JSON.stringify(data);
+        await fetch(action.url, {
+            method: action.method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...action.headers,
+            },
+            body,
+        });
     }
     /**
-     * Force flush event queue
+     * Execute create task action
      */
-    async flush() {
-        await this.queue.flush();
+    async executeCreateTask(action, data) {
+        logger.debug('Creating task:', action.title);
+        const dueDate = action.dueDays
+            ? new Date(Date.now() + action.dueDays * 24 * 60 * 60 * 1000).toISOString()
+            : undefined;
+        await this.request(`/api/workspaces/${this.workspaceId}/tasks`, {
+            method: 'POST',
+            body: JSON.stringify({
+                title: this.replaceVariables(action.title, data),
+                description: action.description ? this.replaceVariables(action.description, data) : undefined,
+                priority: action.priority,
+                dueDate,
+                assignedTo: action.assignedTo,
+                relatedContactId: typeof data.contactId === 'string' ? data.contactId : undefined,
+            }),
+        });
     }
     /**
-     * Reset visitor and session (for logout)
+     * Execute update contact action
      */
-    reset() {
-        logger.info('Resetting visitor data');
-        resetIds(this.config.useCookies);
-        this.visitorId = this.createVisitorId();
-        this.sessionId = this.createSessionId();
-        this.queue.clear();
+    async executeUpdateContact(action, data) {
+        const contactId = data.contactId || data._id;
+        if (!contactId) {
+            logger.warn('Cannot update contact: no contactId in data');
+            return;
+        }
+        logger.debug('Updating contact:', contactId);
+        await this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
+            method: 'PUT',
+            body: JSON.stringify(action.updates),
+        });
     }
     /**
-     * Delete all stored user data (GDPR right-to-erasure)
+     * Replace variables in a string template
+     * Supports syntax like {{contact.email}}, {{opportunity.value}}
      */
-    deleteData() {
-        logger.info('Deleting all user data (GDPR request)');
-        // Clear queue
-        this.queue.clear();
-        // Reset consent
-        this.consentManager.reset();
-        // Clear all stored IDs
-        resetIds(this.config.useCookies);
-        // Clear session storage items
-        if (typeof sessionStorage !== 'undefined') {
-            try {
-                sessionStorage.removeItem(STORAGE_KEYS.VISITOR_ID);
-                sessionStorage.removeItem(STORAGE_KEYS.VISITOR_ID + '_anon');
-                sessionStorage.removeItem(STORAGE_KEYS.SESSION_ID);
-                sessionStorage.removeItem(STORAGE_KEYS.SESSION_TIMESTAMP);
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        // Clear localStorage items
-        if (typeof localStorage !== 'undefined') {
-            try {
-                localStorage.removeItem(STORAGE_KEYS.VISITOR_ID);
-                localStorage.removeItem(STORAGE_KEYS.CONSENT);
-                localStorage.removeItem(STORAGE_KEYS.EVENT_QUEUE);
-            }
-            catch {
-                // Ignore errors
+    replaceVariables(template, data) {
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+            const value = this.getNestedValue(data, path.trim());
+            return value !== undefined ? String(value) : match;
+        });
+    }
+    /**
+     * Get nested value from object using dot notation
+     * Supports dynamic field access including custom fields
+     */
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            return current !== null && current !== undefined && typeof current === 'object'
+                ? current[key]
+                : undefined;
+        }, obj);
+    }
+    /**
+     * Extract all available field paths from a data object
+     * Useful for dynamic field discovery based on platform-specific attributes
+     * @param obj - The data object to extract fields from
+     * @param prefix - Internal use for nested paths
+     * @param maxDepth - Maximum depth to traverse (default: 3)
+     * @returns Array of field paths (e.g., ['email', 'contact.firstName', 'customFields.industry'])
+     */
+    extractAvailableFields(obj, prefix = '', maxDepth = 3) {
+        if (maxDepth <= 0)
+            return [];
+        const fields = [];
+        for (const key in obj) {
+            if (!obj.hasOwnProperty(key))
+                continue;
+            const value = obj[key];
+            const fieldPath = prefix ? `${prefix}.${key}` : key;
+            fields.push(fieldPath);
+            // Recursively traverse nested objects
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                const nestedFields = this.extractAvailableFields(value, fieldPath, maxDepth - 1);
+                fields.push(...nestedFields);
             }
         }
-        // Generate new IDs
-        this.visitorId = this.createVisitorId();
-        this.sessionId = this.createSessionId();
-        logger.info('All user data deleted');
+        return fields;
     }
     /**
-     * Destroy tracker and cleanup
+     * Get available fields from sample data
+     * Helps with dynamic field detection for platform-specific attributes
+     * @param sampleData - Sample data object to analyze
+     * @returns Array of available field paths
      */
-    async destroy() {
-        logger.info('Destroying tracker');
-        // Flush any remaining events (await to ensure completion)
-        await this.queue.flush();
-        // Destroy plugins
-        for (const plugin of this.plugins) {
-            if (plugin.destroy) {
-                plugin.destroy();
-            }
-        }
-        this.plugins = [];
-        // Destroy queue
-        this.queue.destroy();
-        this.isInitialized = false;
+    getAvailableFields(sampleData) {
+        return this.extractAvailableFields(sampleData);
+    }
+    // ============================================
+    // HELPER METHODS FOR COMMON PATTERNS
+    // ============================================
+    /**
+     * Create a simple email trigger
+     * Helper method for common use case
+     */
+    async createEmailTrigger(config) {
+        return this.createTrigger({
+            name: config.name,
+            eventType: config.eventType,
+            conditions: config.conditions,
+            actions: [
+                {
+                    type: 'send_email',
+                    to: config.to,
+                    subject: config.subject,
+                    body: config.body,
+                },
+            ],
+            isActive: true,
+        });
+    }
+    /**
+     * Create a task creation trigger
+     */
+    async createTaskTrigger(config) {
+        return this.createTrigger({
+            name: config.name,
+            eventType: config.eventType,
+            conditions: config.conditions,
+            actions: [
+                {
+                    type: 'create_task',
+                    title: config.taskTitle,
+                    description: config.taskDescription,
+                    priority: config.priority,
+                    dueDays: config.dueDays,
+                },
+            ],
+            isActive: true,
+        });
+    }
+    /**
+     * Create a webhook trigger
+     */
+    async createWebhookTrigger(config) {
+        return this.createTrigger({
+            name: config.name,
+            eventType: config.eventType,
+            conditions: config.conditions,
+            actions: [
+                {
+                    type: 'webhook',
+                    url: config.webhookUrl,
+                    method: config.method || 'POST',
+                },
+            ],
+            isActive: true,
+        });
     }
 }
 
@@ -2579,16 +2830,37 @@ class Tracker {
  * CRM API Client for managing contacts and opportunities
  */
 class CRMClient {
-    constructor(apiEndpoint, workspaceId, authToken) {
+    constructor(apiEndpoint, workspaceId, authToken, apiKey) {
         this.apiEndpoint = apiEndpoint;
         this.workspaceId = workspaceId;
         this.authToken = authToken;
+        this.apiKey = apiKey;
+        this.triggers = new EventTriggersManager(apiEndpoint, workspaceId, authToken);
     }
     /**
-     * Set authentication token for API requests
+     * Set authentication token for API requests (user JWT)
      */
     setAuthToken(token) {
         this.authToken = token;
+        this.apiKey = undefined;
+        this.triggers.setAuthToken(token);
+    }
+    /**
+     * Set workspace API key for server-to-server requests.
+     * Use this instead of setAuthToken when integrating from an external app.
+     */
+    setApiKey(key) {
+        this.apiKey = key;
+        this.authToken = undefined;
+    }
+    /**
+     * Validate required parameter exists
+     * @throws {Error} if value is null/undefined or empty string
+     */
+    validateRequired(param, value, methodName) {
+        if (value === null || value === undefined || value === '') {
+            throw new Error(`[CRMClient.${methodName}] ${param} is required`);
+        }
     }
     /**
      * Make authenticated API request
@@ -2599,7 +2871,10 @@ class CRMClient {
             'Content-Type': 'application/json',
             ...(options.headers || {}),
         };
-        if (this.authToken) {
+        if (this.apiKey) {
+            headers['X-Api-Key'] = this.apiKey;
+        }
+        else if (this.authToken) {
             headers['Authorization'] = `Bearer ${this.authToken}`;
         }
         try {
@@ -2630,6 +2905,65 @@ class CRMClient {
         }
     }
     // ============================================
+    // INBOUND EVENTS API (API-key authenticated)
+    // ============================================
+    /**
+     * Send an inbound event from an external app (e.g. user signup on client website).
+     * Requires the client to be initialized with an API key via setApiKey() or the constructor.
+     *
+     * The contact is upserted in the CRM and matching workflow automations fire automatically.
+     *
+     * @example
+     * const crm = new CRMClient('https://api.clianta.online', 'WORKSPACE_ID');
+     * crm.setApiKey('mm_live_...');
+     *
+     * await crm.sendEvent({
+     *   event: 'user.registered',
+     *   contact: { email: 'alice@example.com', firstName: 'Alice' },
+     *   data: { plan: 'free', signupSource: 'homepage' },
+     * });
+     */
+    async sendEvent(payload) {
+        const url = `${this.apiEndpoint}/api/public/events`;
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey) {
+            headers['X-Api-Key'] = this.apiKey;
+        }
+        else if (this.authToken) {
+            headers['Authorization'] = `Bearer ${this.authToken}`;
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    success: false,
+                    contactCreated: false,
+                    event: payload.event,
+                    error: data.error || 'Request failed',
+                };
+            }
+            return {
+                success: data.success,
+                contactCreated: data.contactCreated,
+                contactId: data.contactId,
+                event: data.event,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                contactCreated: false,
+                event: payload.event,
+                error: error instanceof Error ? error.message : 'Network error',
+            };
+        }
+    }
+    // ============================================
     // CONTACTS API
     // ============================================
     /**
@@ -2653,6 +2987,7 @@ class CRMClient {
      * Get a single contact by ID
      */
     async getContact(contactId) {
+        this.validateRequired('contactId', contactId, 'getContact');
         return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`);
     }
     /**
@@ -2668,6 +3003,7 @@ class CRMClient {
      * Update an existing contact
      */
     async updateContact(contactId, updates) {
+        this.validateRequired('contactId', contactId, 'updateContact');
         return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
             method: 'PUT',
             body: JSON.stringify(updates),
@@ -2677,6 +3013,7 @@ class CRMClient {
      * Delete a contact
      */
     async deleteContact(contactId) {
+        this.validateRequired('contactId', contactId, 'deleteContact');
         return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
             method: 'DELETE',
         });
@@ -3040,6 +3377,442 @@ class CRMClient {
             opportunityId: data.opportunityId,
         });
     }
+    // ============================================
+    // EMAIL TEMPLATES API
+    // ============================================
+    /**
+     * Get all email templates
+     */
+    async getEmailTemplates(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.page)
+            queryParams.set('page', params.page.toString());
+        if (params?.limit)
+            queryParams.set('limit', params.limit.toString());
+        const query = queryParams.toString();
+        const endpoint = `/api/workspaces/${this.workspaceId}/email-templates${query ? `?${query}` : ''}`;
+        return this.request(endpoint);
+    }
+    /**
+     * Get a single email template by ID
+     */
+    async getEmailTemplate(templateId) {
+        return this.request(`/api/workspaces/${this.workspaceId}/email-templates/${templateId}`);
+    }
+    /**
+     * Create a new email template
+     */
+    async createEmailTemplate(template) {
+        return this.request(`/api/workspaces/${this.workspaceId}/email-templates`, {
+            method: 'POST',
+            body: JSON.stringify(template),
+        });
+    }
+    /**
+     * Update an email template
+     */
+    async updateEmailTemplate(templateId, updates) {
+        return this.request(`/api/workspaces/${this.workspaceId}/email-templates/${templateId}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+    }
+    /**
+     * Delete an email template
+     */
+    async deleteEmailTemplate(templateId) {
+        return this.request(`/api/workspaces/${this.workspaceId}/email-templates/${templateId}`, {
+            method: 'DELETE',
+        });
+    }
+    /**
+     * Send an email using a template
+     */
+    async sendEmail(data) {
+        return this.request(`/api/workspaces/${this.workspaceId}/emails/send`, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    // ============================================
+    // EVENT TRIGGERS API (delegated to triggers manager)
+    // ============================================
+    /**
+     * Get all event triggers
+     */
+    async getEventTriggers() {
+        return this.triggers.getTriggers();
+    }
+    /**
+     * Create a new event trigger
+     */
+    async createEventTrigger(trigger) {
+        return this.triggers.createTrigger(trigger);
+    }
+    /**
+     * Update an event trigger
+     */
+    async updateEventTrigger(triggerId, updates) {
+        return this.triggers.updateTrigger(triggerId, updates);
+    }
+    /**
+     * Delete an event trigger
+     */
+    async deleteEventTrigger(triggerId) {
+        return this.triggers.deleteTrigger(triggerId);
+    }
+}
+
+/**
+ * Clianta SDK - Main Tracker Class
+ * @see SDK_VERSION in core/config.ts
+ */
+/**
+ * Main Clianta Tracker Class
+ */
+class Tracker {
+    constructor(workspaceId, userConfig = {}) {
+        this.plugins = [];
+        this.isInitialized = false;
+        /** contactId after a successful identify() call */
+        this.contactId = null;
+        /** Pending identify retry on next flush */
+        this.pendingIdentify = null;
+        if (!workspaceId) {
+            throw new Error('[Clianta] Workspace ID is required');
+        }
+        this.workspaceId = workspaceId;
+        this.config = mergeConfig(userConfig);
+        // Setup debug mode
+        logger.enabled = this.config.debug;
+        logger.info(`Initializing SDK v${SDK_VERSION}`, { workspaceId });
+        // Initialize consent manager
+        this.consentManager = new ConsentManager({
+            ...this.config.consent,
+            onConsentChange: (state, previous) => {
+                this.onConsentChange(state, previous);
+            },
+        });
+        // Initialize transport and queue
+        this.transport = new Transport({ apiEndpoint: this.config.apiEndpoint });
+        this.queue = new EventQueue(this.transport, {
+            batchSize: this.config.batchSize,
+            flushInterval: this.config.flushInterval,
+        });
+        // Get or create visitor and session IDs based on mode
+        this.visitorId = this.createVisitorId();
+        this.sessionId = this.createSessionId();
+        logger.debug('IDs created', { visitorId: this.visitorId, sessionId: this.sessionId });
+        // Initialize plugins
+        this.initPlugins();
+        this.isInitialized = true;
+        logger.info('SDK initialized successfully');
+    }
+    /**
+     * Create visitor ID based on storage mode
+     */
+    createVisitorId() {
+        // Anonymous mode: use temporary ID until consent
+        if (this.config.consent.anonymousMode && !this.consentManager.hasExplicit()) {
+            const key = STORAGE_KEYS.VISITOR_ID + '_anon';
+            let anonId = getSessionStorage(key);
+            if (!anonId) {
+                anonId = 'anon_' + generateUUID();
+                setSessionStorage(key, anonId);
+            }
+            return anonId;
+        }
+        // Cookie-less mode: use sessionStorage only
+        if (this.config.cookielessMode) {
+            let visitorId = getSessionStorage(STORAGE_KEYS.VISITOR_ID);
+            if (!visitorId) {
+                visitorId = generateUUID();
+                setSessionStorage(STORAGE_KEYS.VISITOR_ID, visitorId);
+            }
+            return visitorId;
+        }
+        // Normal mode
+        return getOrCreateVisitorId(this.config.useCookies);
+    }
+    /**
+     * Create session ID
+     */
+    createSessionId() {
+        return getOrCreateSessionId(this.config.sessionTimeout);
+    }
+    /**
+     * Handle consent state changes
+     */
+    onConsentChange(state, previous) {
+        logger.debug('Consent changed:', { from: previous, to: state });
+        // If analytics consent was just granted
+        if (state.analytics && !previous.analytics) {
+            // Upgrade from anonymous ID to persistent ID
+            if (this.config.consent.anonymousMode) {
+                this.visitorId = getOrCreateVisitorId(this.config.useCookies);
+                logger.info('Upgraded from anonymous to persistent visitor ID');
+            }
+            // Flush buffered events
+            const buffered = this.consentManager.flushBuffer();
+            for (const event of buffered) {
+                // Update event with new visitor ID
+                event.visitorId = this.visitorId;
+                this.queue.push(event);
+            }
+        }
+    }
+    /**
+     * Initialize enabled plugins
+     * Handles both sync and async plugin init methods
+     */
+    initPlugins() {
+        const pluginsToLoad = this.config.plugins;
+        // Skip pageView plugin if autoPageView is disabled
+        const filteredPlugins = this.config.autoPageView
+            ? pluginsToLoad
+            : pluginsToLoad.filter((p) => p !== 'pageView');
+        for (const pluginName of filteredPlugins) {
+            try {
+                const plugin = getPlugin(pluginName);
+                // Handle both sync and async init (fire-and-forget for async)
+                const result = plugin.init(this);
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        logger.error(`Async plugin init failed: ${pluginName}`, error);
+                    });
+                }
+                this.plugins.push(plugin);
+                logger.debug(`Plugin loaded: ${pluginName}`);
+            }
+            catch (error) {
+                logger.error(`Failed to load plugin: ${pluginName}`, error);
+            }
+        }
+    }
+    /**
+     * Track a custom event
+     */
+    track(eventType, eventName, properties = {}) {
+        if (!this.isInitialized) {
+            logger.warn('SDK not initialized, event dropped');
+            return;
+        }
+        const event = {
+            workspaceId: this.workspaceId,
+            visitorId: this.visitorId,
+            sessionId: this.sessionId,
+            eventType: eventType,
+            eventName,
+            url: typeof window !== 'undefined' ? window.location.href : '',
+            referrer: typeof document !== 'undefined' ? document.referrer || undefined : undefined,
+            properties: {
+                ...properties,
+                eventId: generateUUID(), // Unique ID for deduplication on retry
+            },
+            device: getDeviceInfo(),
+            ...getUTMParams(),
+            timestamp: new Date().toISOString(),
+            sdkVersion: SDK_VERSION,
+        };
+        // Attach contactId if known (from a prior identify() call)
+        if (this.contactId) {
+            event.contactId = this.contactId;
+        }
+        // Check consent before tracking
+        if (!this.consentManager.canTrack()) {
+            // Buffer event for later if waitForConsent is enabled
+            if (this.config.consent.waitForConsent) {
+                this.consentManager.bufferEvent(event);
+                return;
+            }
+            // Otherwise drop the event
+            logger.debug('Event dropped (no consent):', eventName);
+            return;
+        }
+        this.queue.push(event);
+        logger.debug('Event tracked:', eventName, properties);
+    }
+    /**
+     * Track a page view
+     */
+    page(name, properties = {}) {
+        const pageName = name || (typeof document !== 'undefined' ? document.title : 'Page View');
+        this.track('page_view', pageName, {
+            ...properties,
+            path: typeof window !== 'undefined' ? window.location.pathname : '',
+        });
+    }
+    /**
+     * Identify a visitor.
+     * Links the anonymous visitorId to a CRM contact and returns the contactId.
+     * All subsequent track() calls will include the contactId automatically.
+     */
+    async identify(email, traits = {}) {
+        if (!email) {
+            logger.warn('Email is required for identification');
+            return null;
+        }
+        logger.info('Identifying visitor:', email);
+        const result = await this.transport.sendIdentify({
+            workspaceId: this.workspaceId,
+            visitorId: this.visitorId,
+            email,
+            properties: traits,
+        });
+        if (result.success) {
+            logger.info('Visitor identified successfully, contactId:', result.contactId);
+            // Store contactId so all future track() calls include it
+            this.contactId = result.contactId ?? null;
+            this.pendingIdentify = null;
+            return this.contactId;
+        }
+        else {
+            logger.error('Failed to identify visitor:', result.error);
+            // Store for retry on next flush
+            this.pendingIdentify = { email, traits };
+            return null;
+        }
+    }
+    /**
+     * Send a server-side inbound event via the API key endpoint.
+     * Convenience proxy to CRMClient.sendEvent() — requires apiKey in config.
+     */
+    async sendEvent(payload) {
+        const apiKey = this.config.apiKey;
+        if (!apiKey) {
+            logger.error('sendEvent() requires an apiKey in the SDK config');
+            return { success: false, contactCreated: false, event: payload.event, error: 'No API key configured' };
+        }
+        const client = new CRMClient(this.config.apiEndpoint, this.workspaceId, undefined, apiKey);
+        return client.sendEvent(payload);
+    }
+    /**
+     * Retry pending identify call
+     */
+    async retryPendingIdentify() {
+        if (!this.pendingIdentify)
+            return;
+        const { email, traits } = this.pendingIdentify;
+        this.pendingIdentify = null;
+        await this.identify(email, traits);
+    }
+    /**
+     * Update consent state
+     */
+    consent(state) {
+        this.consentManager.update(state);
+    }
+    /**
+     * Get current consent state
+     */
+    getConsentState() {
+        return this.consentManager.getState();
+    }
+    /**
+     * Toggle debug mode
+     */
+    debug(enabled) {
+        logger.enabled = enabled;
+        logger.info(`Debug mode ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    /**
+     * Get visitor ID
+     */
+    getVisitorId() {
+        return this.visitorId;
+    }
+    /**
+     * Get session ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get workspace ID
+     */
+    getWorkspaceId() {
+        return this.workspaceId;
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Force flush event queue
+     */
+    async flush() {
+        await this.retryPendingIdentify();
+        await this.queue.flush();
+    }
+    /**
+     * Reset visitor and session (for logout)
+     */
+    reset() {
+        logger.info('Resetting visitor data');
+        resetIds(this.config.useCookies);
+        this.visitorId = this.createVisitorId();
+        this.sessionId = this.createSessionId();
+        this.queue.clear();
+    }
+    /**
+     * Delete all stored user data (GDPR right-to-erasure)
+     */
+    deleteData() {
+        logger.info('Deleting all user data (GDPR request)');
+        // Clear queue
+        this.queue.clear();
+        // Reset consent
+        this.consentManager.reset();
+        // Clear all stored IDs
+        resetIds(this.config.useCookies);
+        // Clear session storage items
+        if (typeof sessionStorage !== 'undefined') {
+            try {
+                sessionStorage.removeItem(STORAGE_KEYS.VISITOR_ID);
+                sessionStorage.removeItem(STORAGE_KEYS.VISITOR_ID + '_anon');
+                sessionStorage.removeItem(STORAGE_KEYS.SESSION_ID);
+                sessionStorage.removeItem(STORAGE_KEYS.SESSION_TIMESTAMP);
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // Clear localStorage items
+        if (typeof localStorage !== 'undefined') {
+            try {
+                localStorage.removeItem(STORAGE_KEYS.VISITOR_ID);
+                localStorage.removeItem(STORAGE_KEYS.CONSENT);
+                localStorage.removeItem(STORAGE_KEYS.EVENT_QUEUE);
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // Generate new IDs
+        this.visitorId = this.createVisitorId();
+        this.sessionId = this.createSessionId();
+        logger.info('All user data deleted');
+    }
+    /**
+     * Destroy tracker and cleanup
+     */
+    async destroy() {
+        logger.info('Destroying tracker');
+        // Flush any remaining events (await to ensure completion)
+        await this.queue.flush();
+        // Destroy plugins
+        for (const plugin of this.plugins) {
+            if (plugin.destroy) {
+                plugin.destroy();
+            }
+        }
+        this.plugins = [];
+        // Destroy queue
+        this.queue.destroy();
+        this.isInitialized = false;
+    }
 }
 
 /**
@@ -3094,8 +3867,9 @@ if (typeof window !== 'undefined') {
         Tracker,
         CRMClient,
         ConsentManager,
+        EventTriggersManager,
     };
 }
 
-export { CRMClient, ConsentManager, SDK_VERSION, Tracker, clianta, clianta as default };
+export { CRMClient, ConsentManager, EventTriggersManager, SDK_VERSION, Tracker, clianta, clianta as default };
 //# sourceMappingURL=clianta.esm.js.map