@clianta/sdk 1.1.1 → 1.3.0

package/dist/clianta.umd.js

@@ -1,5 +1,5 @@
 /*!
- * Clianta SDK v1.1.1
+ * Clianta SDK v1.3.0
  * (c) 2026 Clianta
  * Released under the MIT License.
  */
@@ -14,7 +14,7 @@
      * @see SDK_VERSION in core/config.ts
      */
     /** SDK Version */
-    const SDK_VERSION = '1.1.0';
+    const SDK_VERSION = '1.3.0';
     /** Default API endpoint based on environment */
     const getDefaultApiEndpoint = () => {
         if (typeof window === 'undefined')
@@ -34,7 +34,6 @@
         'engagement',
         'downloads',
         'exitIntent',
-        'popupForms',
     ];
     /** Default configuration values */
     const DEFAULT_CONFIG = {
@@ -578,14 +577,24 @@
      * @see SDK_VERSION in core/config.ts
      */
     const MAX_QUEUE_SIZE = 1000;
+    /** Rate limit: max events per window */
+    const RATE_LIMIT_MAX_EVENTS = 100;
+    /** Rate limit window in ms (1 minute) */
+    const RATE_LIMIT_WINDOW_MS = 60000;
     /**
-     * Event queue with batching, persistence, and auto-flush
+     * Event queue with batching, persistence, rate limiting, and auto-flush
      */
     class EventQueue {
         constructor(transport, config = {}) {
             this.queue = [];
             this.flushTimer = null;
             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,
@@ -604,6 +613,11 @@
          * Add an event to the queue
          */
         push(event) {
+            // Rate limiting check
+            if (!this.checkRateLimit()) {
+                logger.warn('Rate limit exceeded, event dropped:', event.eventName);
+                return;
+            }
             // Don't exceed max queue size
             if (this.queue.length >= this.config.maxQueueSize) {
                 logger.warn('Queue full, dropping oldest event');
@@ -616,6 +630,22 @@
                 this.flush();
             }
         }
+        /**
+         * Check and enforce rate limiting
+         * @returns true if event is allowed, false if rate limited
+         */
+        checkRateLimit() {
+            const now = Date.now();
+            // Remove timestamps outside the window
+            this.eventTimestamps = this.eventTimestamps.filter(ts => now - ts < RATE_LIMIT_WINDOW_MS);
+            // Check if under limit
+            if (this.eventTimestamps.length >= RATE_LIMIT_MAX_EVENTS) {
+                return false;
+            }
+            // Record this event
+            this.eventTimestamps.push(now);
+            return true;
+        }
         /**
          * Flush the queue (send all events)
          */
@@ -624,9 +654,10 @@
                 return;
             }
             this.isFlushing = true;
+            // Atomically take snapshot of current queue length to avoid race condition
+            const count = this.queue.length;
+            const events = this.queue.splice(0, count);
             try {
-                // Take all events from queue
-                const events = this.queue.splice(0, this.queue.length);
                 logger.debug(`Flushing ${events.length} events`);
                 // Clear persisted queue
                 this.persistQueue([]);
@@ -678,13 +709,25 @@
             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
@@ -704,19 +747,18 @@
             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
@@ -784,6 +826,9 @@
         constructor() {
             super(...arguments);
             this.name = 'pageView';
+            this.originalPushState = null;
+            this.originalReplaceState = null;
+            this.popstateHandler = null;
         }
         init(tracker) {
             super.init(tracker);
@@ -791,22 +836,40 @@
             this.trackPageView();
             // Track SPA navigation (History API)
             if (typeof window !== 'undefined') {
+                // Store originals for cleanup
+                this.originalPushState = history.pushState;
+                this.originalReplaceState = history.replaceState;
                 // Intercept pushState and replaceState
-                const originalPushState = history.pushState;
-                const originalReplaceState = history.replaceState;
-                history.pushState = (...args) => {
-                    originalPushState.apply(history, args);
-                    this.trackPageView();
+                const self = this;
+                history.pushState = function (...args) {
+                    self.originalPushState.apply(history, args);
+                    self.trackPageView();
                 };
-                history.replaceState = (...args) => {
-                    originalReplaceState.apply(history, args);
-                    this.trackPageView();
+                history.replaceState = function (...args) {
+                    self.originalReplaceState.apply(history, args);
+                    self.trackPageView();
                 };
                 // Handle back/forward navigation
-                window.addEventListener('popstate', () => {
-                    this.trackPageView();
-                });
+                this.popstateHandler = () => this.trackPageView();
+                window.addEventListener('popstate', this.popstateHandler);
+            }
+        }
+        destroy() {
+            // 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();
         }
         trackPageView() {
             if (typeof window === 'undefined' || typeof document === 'undefined')
@@ -838,6 +901,10 @@
             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);
@@ -845,6 +912,8 @@
             if (typeof window !== 'undefined') {
                 this.boundHandler = this.handleScroll.bind(this);
                 window.addEventListener('scroll', this.boundHandler, { passive: true });
+                // Setup SPA navigation reset
+                this.setupNavigationReset();
             }
         }
         destroy() {
@@ -854,8 +923,53 @@
             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) {
@@ -869,7 +983,11 @@
             const windowHeight = window.innerHeight;
             const documentHeight = document.documentElement.scrollHeight;
             const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
-            const scrollPercent = Math.floor((scrollTop / (documentHeight - windowHeight)) * 100);
+            const scrollableHeight = documentHeight - windowHeight;
+            // Guard against divide-by-zero on short pages
+            if (scrollableHeight <= 0)
+                return;
+            const scrollPercent = Math.floor((scrollTop / scrollableHeight) * 100);
             // Clamp to valid range
             const clampedPercent = Math.max(0, Math.min(100, scrollPercent));
             // Update max scroll depth
@@ -904,6 +1022,7 @@
             this.trackedForms = new WeakSet();
             this.formInteractions = new Set();
             this.observer = null;
+            this.listeners = [];
         }
         init(tracker) {
             super.init(tracker);
@@ -922,8 +1041,20 @@
                 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);
@@ -949,7 +1080,7 @@
                     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);
@@ -960,12 +1091,13 @@
                                     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,
@@ -973,7 +1105,8 @@
                 });
                 // 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"]');
@@ -1057,6 +1190,7 @@
             this.engagementTimeout = null;
             this.boundMarkEngaged = null;
             this.boundTrackTimeOnPage = null;
+            this.boundVisibilityHandler = null;
         }
         init(tracker) {
             super.init(tracker);
@@ -1067,12 +1201,7 @@
             // 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();
                 }
@@ -1080,7 +1209,13 @@
                     // 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') {
@@ -1091,6 +1226,9 @@
             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);
             }
@@ -1135,20 +1273,69 @@
             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)
@@ -1274,34 +1461,72 @@
         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')
                 return;
-            // Use Navigation Timing API
-            const timing = performance.timing;
-            if (!timing)
-                return;
-            const loadTime = timing.loadEventEnd - timing.navigationStart;
-            const domReady = timing.domContentLoadedEventEnd - timing.navigationStart;
-            const ttfb = timing.responseStart - timing.navigationStart;
-            const domInteractive = timing.domInteractive - timing.navigationStart;
-            this.track('performance', 'Page Performance', {
-                loadTime,
-                domReady,
-                ttfb, // Time to First Byte
-                domInteractive,
-            });
+            // Use modern Navigation Timing API (PerformanceNavigationTiming)
+            const entries = performance.getEntriesByType('navigation');
+            if (entries.length > 0) {
+                const navTiming = entries[0];
+                const loadTime = Math.round(navTiming.loadEventEnd - navTiming.startTime);
+                const domReady = Math.round(navTiming.domContentLoadedEventEnd - navTiming.startTime);
+                const ttfb = Math.round(navTiming.responseStart - navTiming.requestStart);
+                const domInteractive = Math.round(navTiming.domInteractive - navTiming.startTime);
+                this.track('performance', 'Page Performance', {
+                    loadTime,
+                    domReady,
+                    ttfb, // Time to First Byte
+                    domInteractive,
+                    // Additional modern metrics
+                    dns: Math.round(navTiming.domainLookupEnd - navTiming.domainLookupStart),
+                    connection: Math.round(navTiming.connectEnd - navTiming.connectStart),
+                    transferSize: navTiming.transferSize,
+                });
+            }
+            else {
+                // Fallback for older browsers using deprecated API
+                const timing = performance.timing;
+                if (!timing)
+                    return;
+                const loadTime = timing.loadEventEnd - timing.navigationStart;
+                const domReady = timing.domContentLoadedEventEnd - timing.navigationStart;
+                const ttfb = timing.responseStart - timing.navigationStart;
+                const domInteractive = timing.domInteractive - timing.navigationStart;
+                this.track('performance', 'Page Performance', {
+                    loadTime,
+                    domReady,
+                    ttfb,
+                    domInteractive,
+                });
+            }
             // Track Web Vitals if available
             this.trackWebVitals();
         }
@@ -1320,6 +1545,7 @@
                         }
                     });
                     lcpObserver.observe({ type: 'largest-contentful-paint', buffered: true });
+                    this.observers.push(lcpObserver);
                 }
                 catch {
                     // LCP not supported
@@ -1337,6 +1563,7 @@
                         }
                     });
                     fidObserver.observe({ type: 'first-input', buffered: true });
+                    this.observers.push(fidObserver);
                 }
                 catch {
                     // FID not supported
@@ -1353,15 +1580,17 @@
                         });
                     });
                     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
@@ -1578,8 +1807,8 @@
             opacity: 0;
             transition: all 0.3s ease;
         `;
-            // Build form HTML
-            container.innerHTML = this.buildFormHTML(form);
+            // Build form using safe DOM APIs (no innerHTML for user content)
+            this.buildFormDOM(form, container);
             overlay.appendChild(container);
             document.body.appendChild(overlay);
             // Animate in
@@ -1591,95 +1820,162 @@
             // Setup event listeners
             this.setupFormEvents(form, overlay, container);
         }
-        buildFormHTML(form) {
+        /**
+         * Escape HTML to prevent XSS - used only for static structure
+         */
+        escapeHTML(str) {
+            const div = document.createElement('div');
+            div.textContent = str;
+            return div.innerHTML;
+        }
+        /**
+         * Build form using safe DOM APIs (prevents XSS)
+         */
+        buildFormDOM(form, container) {
             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>
-                `;
+            // Close button
+            const closeBtn = document.createElement('button');
+            closeBtn.id = 'clianta-form-close';
+            closeBtn.style.cssText = `
+            position: absolute;
+            top: 12px;
+            right: 12px;
+            background: none;
+            border: none;
+            font-size: 20px;
+            cursor: pointer;
+            color: #71717A;
+            padding: 4px;
+        `;
+            closeBtn.textContent = '×';
+            container.appendChild(closeBtn);
+            // Headline
+            const headline = document.createElement('h2');
+            headline.style.cssText = `font-size: 20px; font-weight: 700; margin-bottom: 8px; color: ${this.escapeHTML(textColor)};`;
+            headline.textContent = form.headline || 'Stay in touch';
+            container.appendChild(headline);
+            // Subheadline
+            const subheadline = document.createElement('p');
+            subheadline.style.cssText = 'font-size: 14px; color: #71717A; margin-bottom: 16px;';
+            subheadline.textContent = form.subheadline || 'Get the latest updates';
+            container.appendChild(subheadline);
+            // Form element
+            const formElement = document.createElement('form');
+            formElement.id = 'clianta-form-element';
+            // Build fields
+            form.fields.forEach(field => {
+                const fieldWrapper = document.createElement('div');
+                fieldWrapper.style.marginBottom = '12px';
+                if (field.type === 'checkbox') {
+                    // Checkbox layout
+                    const label = document.createElement('label');
+                    label.style.cssText = `display: flex; align-items: center; gap: 8px; font-size: 14px; color: ${this.escapeHTML(textColor)}; cursor: pointer;`;
+                    const input = document.createElement('input');
+                    input.type = 'checkbox';
+                    input.name = field.name;
+                    if (field.required)
+                        input.required = true;
+                    input.style.cssText = 'width: 16px; height: 16px;';
+                    label.appendChild(input);
+                    const labelText = document.createTextNode(field.label + ' ');
+                    label.appendChild(labelText);
+                    if (field.required) {
+                        const requiredMark = document.createElement('span');
+                        requiredMark.style.color = '#EF4444';
+                        requiredMark.textContent = '*';
+                        label.appendChild(requiredMark);
+                    }
+                    fieldWrapper.appendChild(label);
                 }
                 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>
-                `;
+                    // Label
+                    const label = document.createElement('label');
+                    label.style.cssText = `display: block; font-size: 14px; font-weight: 500; margin-bottom: 4px; color: ${this.escapeHTML(textColor)};`;
+                    label.textContent = field.label + ' ';
+                    if (field.required) {
+                        const requiredMark = document.createElement('span');
+                        requiredMark.style.color = '#EF4444';
+                        requiredMark.textContent = '*';
+                        label.appendChild(requiredMark);
+                    }
+                    fieldWrapper.appendChild(label);
+                    // Input/Textarea/Select
+                    if (field.type === 'textarea') {
+                        const textarea = document.createElement('textarea');
+                        textarea.name = field.name;
+                        if (field.placeholder)
+                            textarea.placeholder = field.placeholder;
+                        if (field.required)
+                            textarea.required = true;
+                        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;
+                        input.name = field.name;
+                        if (field.placeholder)
+                            input.placeholder = field.placeholder;
+                        if (field.required)
+                            input.required = true;
+                        input.style.cssText = 'width: 100%; padding: 8px 12px; border: 1px solid #E4E4E7; border-radius: 6px; font-size: 14px; box-sizing: border-box;';
+                        fieldWrapper.appendChild(input);
+                    }
                 }
-            }).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>
+                formElement.appendChild(fieldWrapper);
+            });
+            // Submit button
+            const submitBtn = document.createElement('button');
+            submitBtn.type = 'submit';
+            submitBtn.style.cssText = `
+            width: 100%;
+            padding: 10px 16px;
+            background: ${this.escapeHTML(primaryColor)};
+            color: white;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            margin-top: 8px;
         `;
+            submitBtn.textContent = form.submitButtonText || 'Subscribe';
+            formElement.appendChild(submitBtn);
+            container.appendChild(formElement);
         }
         setupFormEvents(form, overlay, container) {
             // Close button
@@ -1740,19 +2036,29 @@
                 });
                 const result = await response.json();
                 if (result.success) {
-                    // Show success message
-                    container.innerHTML = `
-                    <div style="text-align: center; padding: 20px;">
-                        <div style="width: 48px; height: 48px; background: #10B981; border-radius: 50%; margin: 0 auto 16px; display: flex; align-items: center; justify-content: center;">
-                            <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="white" stroke-width="2">
-                                <polyline points="20 6 9 17 4 12"></polyline>
-                            </svg>
-                        </div>
-                        <p style="font-size: 16px; font-weight: 500; color: #18181B;">
-                            ${form.successMessage || 'Thank you!'}
-                        </p>
-                    </div>
-                `;
+                    // Show success message using safe DOM APIs
+                    container.innerHTML = '';
+                    const successWrapper = document.createElement('div');
+                    successWrapper.style.cssText = 'text-align: center; padding: 20px;';
+                    const iconWrapper = document.createElement('div');
+                    iconWrapper.style.cssText = 'width: 48px; height: 48px; background: #10B981; border-radius: 50%; margin: 0 auto 16px; display: flex; align-items: center; justify-content: center;';
+                    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+                    svg.setAttribute('width', '24');
+                    svg.setAttribute('height', '24');
+                    svg.setAttribute('viewBox', '0 0 24 24');
+                    svg.setAttribute('fill', 'none');
+                    svg.setAttribute('stroke', 'white');
+                    svg.setAttribute('stroke-width', '2');
+                    const polyline = document.createElementNS('http://www.w3.org/2000/svg', 'polyline');
+                    polyline.setAttribute('points', '20 6 9 17 4 12');
+                    svg.appendChild(polyline);
+                    iconWrapper.appendChild(svg);
+                    const message = document.createElement('p');
+                    message.style.cssText = 'font-size: 16px; font-weight: 500; color: #18181B;';
+                    message.textContent = form.successMessage || 'Thank you!';
+                    successWrapper.appendChild(iconWrapper);
+                    successWrapper.appendChild(message);
+                    container.appendChild(successWrapper);
                     // Track identify
                     if (data.email) {
                         this.tracker?.identify(data.email, data);
@@ -1889,6 +2195,8 @@
      * Manages consent state and event buffering for GDPR/CCPA compliance
      * @see SDK_VERSION in core/config.ts
      */
+    /** Maximum events to buffer while waiting for consent */
+    const MAX_BUFFER_SIZE = 100;
     /**
      * Manages user consent state for tracking
      */
@@ -2005,6 +2313,11 @@
          * Buffer an event (for waitForConsent mode)
          */
         bufferEvent(event) {
+            // Prevent unbounded buffer growth
+            if (this.eventBuffer.length >= MAX_BUFFER_SIZE) {
+                logger.warn('Consent event buffer full, dropping oldest event');
+                this.eventBuffer.shift();
+            }
             this.eventBuffer.push(event);
             logger.debug('Event buffered (waiting for consent):', event.eventName);
         }
@@ -2064,6 +2377,8 @@
         constructor(workspaceId, userConfig = {}) {
             this.plugins = [];
             this.isInitialized = false;
+            /** Pending identify retry on next flush */
+            this.pendingIdentify = null;
             if (!workspaceId) {
                 throw new Error('[Clianta] Workspace ID is required');
             }
@@ -2149,6 +2464,7 @@
         }
         /**
          * Initialize enabled plugins
+         * Handles both sync and async plugin init methods
          */
         initPlugins() {
             const pluginsToLoad = this.config.plugins;
@@ -2159,7 +2475,13 @@
             for (const pluginName of filteredPlugins) {
                 try {
                     const plugin = getPlugin(pluginName);
-                    plugin.init(this);
+                    // 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}`);
                 }
@@ -2186,7 +2508,7 @@
                 referrer: typeof document !== 'undefined' ? document.referrer || undefined : undefined,
                 properties,
                 device: getDeviceInfo(),
-                utm: getUTMParams(),
+                ...getUTMParams(),
                 timestamp: new Date().toISOString(),
                 sdkVersion: SDK_VERSION,
             };
@@ -2231,11 +2553,24 @@
             });
             if (result.success) {
                 logger.info('Visitor identified successfully');
+                this.pendingIdentify = null;
             }
             else {
                 logger.error('Failed to identify visitor:', result.error);
+                // Store for retry on next flush
+                this.pendingIdentify = { email, traits };
             }
         }
+        /**
+         * 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
          */
@@ -2283,6 +2618,7 @@
          * Force flush event queue
          */
         async flush() {
+            await this.retryPendingIdentify();
             await this.queue.flush();
         }
         /**
@@ -2337,10 +2673,10 @@
         /**
          * Destroy tracker and cleanup
          */
-        destroy() {
+        async destroy() {
             logger.info('Destroying tracker');
-            // Flush any remaining events
-            this.queue.flush();
+            // Flush any remaining events (await to ensure completion)
+            await this.queue.flush();
             // Destroy plugins
             for (const plugin of this.plugins) {
                 if (plugin.destroy) {
@@ -2355,20 +2691,28 @@
     }
 
     /**
-     * Clianta SDK - CRM API Client
-     * @see SDK_VERSION in core/config.ts
+     * Clianta SDK - Event Triggers Manager
+     * Manages event-driven automation and email notifications
      */
     /**
-     * CRM API Client for managing contacts and opportunities
+     * 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 CRMClient {
+    class EventTriggersManager {
         constructor(apiEndpoint, workspaceId, authToken) {
+            this.triggers = new Map();
+            this.listeners = new Map();
             this.apiEndpoint = apiEndpoint;
             this.workspaceId = workspaceId;
             this.authToken = authToken;
         }
         /**
-         * Set authentication token for API requests
+         * Set authentication token
          */
         setAuthToken(token) {
             this.authToken = token;
@@ -2413,120 +2757,942 @@
             }
         }
         // ============================================
-        // CONTACTS API
+        // TRIGGER MANAGEMENT
         // ============================================
         /**
-         * Get all contacts with pagination
+         * Get all event triggers
          */
-        async getContacts(params) {
-            const queryParams = new URLSearchParams();
-            if (params?.page)
-                queryParams.set('page', params.page.toString());
-            if (params?.limit)
-                queryParams.set('limit', params.limit.toString());
-            if (params?.search)
-                queryParams.set('search', params.search);
-            if (params?.status)
-                queryParams.set('status', params.status);
-            const query = queryParams.toString();
-            const endpoint = `/api/workspaces/${this.workspaceId}/contacts${query ? `?${query}` : ''}`;
-            return this.request(endpoint);
+        async getTriggers() {
+            return this.request(`/api/workspaces/${this.workspaceId}/triggers`);
         }
         /**
-         * Get a single contact by ID
+         * Get a single trigger by ID
          */
-        async getContact(contactId) {
-            return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`);
+        async getTrigger(triggerId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/triggers/${triggerId}`);
         }
         /**
-         * Create a new contact
+         * Create a new event trigger
          */
-        async createContact(contact) {
-            return this.request(`/api/workspaces/${this.workspaceId}/contacts`, {
+        async createTrigger(trigger) {
+            const result = await this.request(`/api/workspaces/${this.workspaceId}/triggers`, {
                 method: 'POST',
-                body: JSON.stringify(contact),
+                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;
         }
         /**
-         * Update an existing contact
+         * Update an existing trigger
          */
-        async updateContact(contactId, updates) {
-            return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
+        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;
         }
         /**
-         * Delete a contact
+         * Delete a trigger
          */
-        async deleteContact(contactId) {
-            return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
+        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);
+            }
+            return result;
+        }
+        /**
+         * Activate a trigger
+         */
+        async activateTrigger(triggerId) {
+            return this.updateTrigger(triggerId, { isActive: true });
+        }
+        /**
+         * Deactivate a trigger
+         */
+        async deactivateTrigger(triggerId) {
+            return this.updateTrigger(triggerId, { isActive: false });
         }
         // ============================================
-        // OPPORTUNITIES API
+        // EVENT HANDLING (CLIENT-SIDE)
         // ============================================
         /**
-         * Get all opportunities with pagination
+         * Register a local event listener for client-side triggers
+         * This allows immediate client-side reactions to events
          */
-        async getOpportunities(params) {
-            const queryParams = new URLSearchParams();
-            if (params?.page)
-                queryParams.set('page', params.page.toString());
-            if (params?.limit)
-                queryParams.set('limit', params.limit.toString());
-            if (params?.pipelineId)
-                queryParams.set('pipelineId', params.pipelineId);
-            if (params?.stageId)
-                queryParams.set('stageId', params.stageId);
-            const query = queryParams.toString();
-            const endpoint = `/api/workspaces/${this.workspaceId}/opportunities${query ? `?${query}` : ''}`;
-            return this.request(endpoint);
+        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 a single opportunity by ID
+         * Remove an event listener
          */
-        async getOpportunity(opportunityId) {
-            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}`);
+        off(eventType, callback) {
+            const listeners = this.listeners.get(eventType);
+            if (listeners) {
+                listeners.delete(callback);
+            }
         }
         /**
-         * Create a new opportunity
+         * Emit an event (client-side only)
+         * This will trigger any registered local listeners
          */
-        async createOpportunity(opportunity) {
-            return this.request(`/api/workspaces/${this.workspaceId}/opportunities`, {
+        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);
+                    }
+                });
+            }
+        }
+        /**
+         * 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;
+                }
+            });
+        }
+        /**
+         * Execute actions for a triggered event (client-side preview)
+         * Note: Actual execution happens on the backend
+         */
+        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);
+                }
+            }
+        }
+        /**
+         * 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(opportunity),
+                body: JSON.stringify(payload),
             });
         }
         /**
-         * Update an existing opportunity
+         * Execute webhook action
          */
-        async updateOpportunity(opportunityId, updates) {
-            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}`, {
+        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,
+            });
+        }
+        /**
+         * Execute create task action
+         */
+        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,
+                }),
+            });
+        }
+        /**
+         * Execute update contact action
+         */
+        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(updates),
+                body: JSON.stringify(action.updates),
             });
         }
         /**
-         * Delete an opportunity
+         * Replace variables in a string template
+         * Supports syntax like {{contact.email}}, {{opportunity.value}}
          */
-        async deleteOpportunity(opportunityId) {
-            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}`, {
-                method: 'DELETE',
+        replaceVariables(template, data) {
+            return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+                const value = this.getNestedValue(data, path.trim());
+                return value !== undefined ? String(value) : match;
             });
         }
         /**
-         * Move opportunity to a different stage
+         * Get nested value from object using dot notation
+         * Supports dynamic field access including custom fields
          */
-        async moveOpportunity(opportunityId, stageId) {
-            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}/move`, {
-                method: 'POST',
-                body: JSON.stringify({ stageId }),
+        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);
+                }
+            }
+            return fields;
+        }
+        /**
+         * 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
+         */
+        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,
             });
         }
     }
 
+    /**
+     * Clianta SDK - CRM API Client
+     * @see SDK_VERSION in core/config.ts
+     */
+    /**
+     * CRM API Client for managing contacts and opportunities
+     */
+    class CRMClient {
+        constructor(apiEndpoint, workspaceId, authToken) {
+            this.apiEndpoint = apiEndpoint;
+            this.workspaceId = workspaceId;
+            this.authToken = authToken;
+            this.triggers = new EventTriggersManager(apiEndpoint, workspaceId, authToken);
+        }
+        /**
+         * Set authentication token for API requests
+         */
+        setAuthToken(token) {
+            this.authToken = token;
+            this.triggers.setAuthToken(token);
+        }
+        /**
+         * 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
+         */
+        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}`;
+            }
+            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 {
+                    success: true,
+                    data: data.data || data,
+                    status: response.status,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Network error',
+                    status: 0,
+                };
+            }
+        }
+        // ============================================
+        // CONTACTS API
+        // ============================================
+        /**
+         * Get all contacts with pagination
+         */
+        async getContacts(params) {
+            const queryParams = new URLSearchParams();
+            if (params?.page)
+                queryParams.set('page', params.page.toString());
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.search)
+                queryParams.set('search', params.search);
+            if (params?.status)
+                queryParams.set('status', params.status);
+            const query = queryParams.toString();
+            const endpoint = `/api/workspaces/${this.workspaceId}/contacts${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Get a single contact by ID
+         */
+        async getContact(contactId) {
+            this.validateRequired('contactId', contactId, 'getContact');
+            return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`);
+        }
+        /**
+         * Create a new contact
+         */
+        async createContact(contact) {
+            return this.request(`/api/workspaces/${this.workspaceId}/contacts`, {
+                method: 'POST',
+                body: JSON.stringify(contact),
+            });
+        }
+        /**
+         * 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),
+            });
+        }
+        /**
+         * Delete a contact
+         */
+        async deleteContact(contactId) {
+            this.validateRequired('contactId', contactId, 'deleteContact');
+            return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
+                method: 'DELETE',
+            });
+        }
+        // ============================================
+        // OPPORTUNITIES API
+        // ============================================
+        /**
+         * Get all opportunities with pagination
+         */
+        async getOpportunities(params) {
+            const queryParams = new URLSearchParams();
+            if (params?.page)
+                queryParams.set('page', params.page.toString());
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.pipelineId)
+                queryParams.set('pipelineId', params.pipelineId);
+            if (params?.stageId)
+                queryParams.set('stageId', params.stageId);
+            const query = queryParams.toString();
+            const endpoint = `/api/workspaces/${this.workspaceId}/opportunities${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Get a single opportunity by ID
+         */
+        async getOpportunity(opportunityId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}`);
+        }
+        /**
+         * Create a new opportunity
+         */
+        async createOpportunity(opportunity) {
+            return this.request(`/api/workspaces/${this.workspaceId}/opportunities`, {
+                method: 'POST',
+                body: JSON.stringify(opportunity),
+            });
+        }
+        /**
+         * Update an existing opportunity
+         */
+        async updateOpportunity(opportunityId, updates) {
+            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}`, {
+                method: 'PUT',
+                body: JSON.stringify(updates),
+            });
+        }
+        /**
+         * Delete an opportunity
+         */
+        async deleteOpportunity(opportunityId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}`, {
+                method: 'DELETE',
+            });
+        }
+        /**
+         * Move opportunity to a different stage
+         */
+        async moveOpportunity(opportunityId, stageId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}/move`, {
+                method: 'POST',
+                body: JSON.stringify({ stageId }),
+            });
+        }
+        // ============================================
+        // COMPANIES API
+        // ============================================
+        /**
+         * Get all companies with pagination
+         */
+        async getCompanies(params) {
+            const queryParams = new URLSearchParams();
+            if (params?.page)
+                queryParams.set('page', params.page.toString());
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.search)
+                queryParams.set('search', params.search);
+            if (params?.status)
+                queryParams.set('status', params.status);
+            if (params?.industry)
+                queryParams.set('industry', params.industry);
+            const query = queryParams.toString();
+            const endpoint = `/api/workspaces/${this.workspaceId}/companies${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Get a single company by ID
+         */
+        async getCompany(companyId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/companies/${companyId}`);
+        }
+        /**
+         * Create a new company
+         */
+        async createCompany(company) {
+            return this.request(`/api/workspaces/${this.workspaceId}/companies`, {
+                method: 'POST',
+                body: JSON.stringify(company),
+            });
+        }
+        /**
+         * Update an existing company
+         */
+        async updateCompany(companyId, updates) {
+            return this.request(`/api/workspaces/${this.workspaceId}/companies/${companyId}`, {
+                method: 'PUT',
+                body: JSON.stringify(updates),
+            });
+        }
+        /**
+         * Delete a company
+         */
+        async deleteCompany(companyId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/companies/${companyId}`, {
+                method: 'DELETE',
+            });
+        }
+        /**
+         * Get contacts belonging to a company
+         */
+        async getCompanyContacts(companyId, 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}/companies/${companyId}/contacts${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Get deals/opportunities belonging to a company
+         */
+        async getCompanyDeals(companyId, 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}/companies/${companyId}/deals${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        // ============================================
+        // PIPELINES API
+        // ============================================
+        /**
+         * Get all pipelines
+         */
+        async getPipelines() {
+            return this.request(`/api/workspaces/${this.workspaceId}/pipelines`);
+        }
+        /**
+         * Get a single pipeline by ID
+         */
+        async getPipeline(pipelineId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/pipelines/${pipelineId}`);
+        }
+        /**
+         * Create a new pipeline
+         */
+        async createPipeline(pipeline) {
+            return this.request(`/api/workspaces/${this.workspaceId}/pipelines`, {
+                method: 'POST',
+                body: JSON.stringify(pipeline),
+            });
+        }
+        /**
+         * Update an existing pipeline
+         */
+        async updatePipeline(pipelineId, updates) {
+            return this.request(`/api/workspaces/${this.workspaceId}/pipelines/${pipelineId}`, {
+                method: 'PUT',
+                body: JSON.stringify(updates),
+            });
+        }
+        /**
+         * Delete a pipeline
+         */
+        async deletePipeline(pipelineId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/pipelines/${pipelineId}`, {
+                method: 'DELETE',
+            });
+        }
+        // ============================================
+        // TASKS API
+        // ============================================
+        /**
+         * Get all tasks with pagination
+         */
+        async getTasks(params) {
+            const queryParams = new URLSearchParams();
+            if (params?.page)
+                queryParams.set('page', params.page.toString());
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.status)
+                queryParams.set('status', params.status);
+            if (params?.priority)
+                queryParams.set('priority', params.priority);
+            if (params?.contactId)
+                queryParams.set('contactId', params.contactId);
+            if (params?.companyId)
+                queryParams.set('companyId', params.companyId);
+            if (params?.opportunityId)
+                queryParams.set('opportunityId', params.opportunityId);
+            const query = queryParams.toString();
+            const endpoint = `/api/workspaces/${this.workspaceId}/tasks${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Get a single task by ID
+         */
+        async getTask(taskId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/tasks/${taskId}`);
+        }
+        /**
+         * Create a new task
+         */
+        async createTask(task) {
+            return this.request(`/api/workspaces/${this.workspaceId}/tasks`, {
+                method: 'POST',
+                body: JSON.stringify(task),
+            });
+        }
+        /**
+         * Update an existing task
+         */
+        async updateTask(taskId, updates) {
+            return this.request(`/api/workspaces/${this.workspaceId}/tasks/${taskId}`, {
+                method: 'PUT',
+                body: JSON.stringify(updates),
+            });
+        }
+        /**
+         * Mark a task as completed
+         */
+        async completeTask(taskId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/tasks/${taskId}/complete`, {
+                method: 'PATCH',
+            });
+        }
+        /**
+         * Delete a task
+         */
+        async deleteTask(taskId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/tasks/${taskId}`, {
+                method: 'DELETE',
+            });
+        }
+        // ============================================
+        // ACTIVITIES API
+        // ============================================
+        /**
+         * Get activities for a contact
+         */
+        async getContactActivities(contactId, params) {
+            const queryParams = new URLSearchParams();
+            if (params?.page)
+                queryParams.set('page', params.page.toString());
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.type)
+                queryParams.set('type', params.type);
+            const query = queryParams.toString();
+            const endpoint = `/api/workspaces/${this.workspaceId}/contacts/${contactId}/activities${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Get activities for an opportunity/deal
+         */
+        async getOpportunityActivities(opportunityId, params) {
+            const queryParams = new URLSearchParams();
+            if (params?.page)
+                queryParams.set('page', params.page.toString());
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.type)
+                queryParams.set('type', params.type);
+            const query = queryParams.toString();
+            const endpoint = `/api/workspaces/${this.workspaceId}/opportunities/${opportunityId}/activities${query ? `?${query}` : ''}`;
+            return this.request(endpoint);
+        }
+        /**
+         * Create a new activity
+         */
+        async createActivity(activity) {
+            // Determine the correct endpoint based on related entity
+            let endpoint;
+            if (activity.opportunityId) {
+                endpoint = `/api/workspaces/${this.workspaceId}/opportunities/${activity.opportunityId}/activities`;
+            }
+            else if (activity.contactId) {
+                endpoint = `/api/workspaces/${this.workspaceId}/contacts/${activity.contactId}/activities`;
+            }
+            else {
+                endpoint = `/api/workspaces/${this.workspaceId}/activities`;
+            }
+            return this.request(endpoint, {
+                method: 'POST',
+                body: JSON.stringify(activity),
+            });
+        }
+        /**
+         * Update an existing activity
+         */
+        async updateActivity(activityId, updates) {
+            return this.request(`/api/workspaces/${this.workspaceId}/activities/${activityId}`, {
+                method: 'PATCH',
+                body: JSON.stringify(updates),
+            });
+        }
+        /**
+         * Delete an activity
+         */
+        async deleteActivity(activityId) {
+            return this.request(`/api/workspaces/${this.workspaceId}/activities/${activityId}`, {
+                method: 'DELETE',
+            });
+        }
+        /**
+         * Log a call activity
+         */
+        async logCall(data) {
+            return this.createActivity({
+                type: 'call',
+                title: `${data.direction === 'inbound' ? 'Inbound' : 'Outbound'} Call`,
+                direction: data.direction,
+                duration: data.duration,
+                outcome: data.outcome,
+                description: data.notes,
+                contactId: data.contactId,
+                opportunityId: data.opportunityId,
+            });
+        }
+        /**
+         * Log a meeting activity
+         */
+        async logMeeting(data) {
+            return this.createActivity({
+                type: 'meeting',
+                title: data.title,
+                duration: data.duration,
+                outcome: data.outcome,
+                description: data.notes,
+                contactId: data.contactId,
+                opportunityId: data.opportunityId,
+            });
+        }
+        /**
+         * Add a note to a contact or opportunity
+         */
+        async addNote(data) {
+            return this.createActivity({
+                type: 'note',
+                title: 'Note',
+                description: data.content,
+                contactId: data.contactId,
+                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
      * Professional CRM and tracking SDK for lead generation
@@ -2579,11 +3745,13 @@
             Tracker,
             CRMClient,
             ConsentManager,
+            EventTriggersManager,
         };
     }
 
     exports.CRMClient = CRMClient;
     exports.ConsentManager = ConsentManager;
+    exports.EventTriggersManager = EventTriggersManager;
     exports.SDK_VERSION = SDK_VERSION;
     exports.Tracker = Tracker;
     exports.clianta = clianta;