@clianta/sdk 1.0.0

package/dist/clianta.esm.js

@@ -0,0 +1,1801 @@
+/*!
+ * Clianta SDK v1.0.0
+ * (c) 2026 Clianta
+ * Released under the MIT License.
+ */
+/**
+ * Clianta SDK - Configuration
+ * @version 1.0.0
+ */
+/** SDK Version */
+const SDK_VERSION = '1.0.0';
+/** Default API endpoint based on environment */
+const getDefaultApiEndpoint = () => {
+    if (typeof window === 'undefined')
+        return 'https://api.clianta.online';
+    const hostname = window.location.hostname;
+    if (hostname.includes('localhost') || hostname.includes('127.0.0.1')) {
+        return 'http://localhost:5000';
+    }
+    return 'https://api.clianta.online';
+};
+/** Core plugins enabled by default */
+const DEFAULT_PLUGINS = [
+    'pageView',
+    'forms',
+    'scroll',
+    'clicks',
+    'engagement',
+    'downloads',
+    'exitIntent',
+];
+/** Default configuration values */
+const DEFAULT_CONFIG = {
+    apiEndpoint: getDefaultApiEndpoint(),
+    debug: false,
+    autoPageView: true,
+    plugins: DEFAULT_PLUGINS,
+    sessionTimeout: 30 * 60 * 1000, // 30 minutes
+    batchSize: 10,
+    flushInterval: 5000, // 5 seconds
+    consent: {
+        defaultConsent: { analytics: true, marketing: false, personalization: false },
+        waitForConsent: false,
+        storageKey: 'mb_consent',
+    },
+    cookieDomain: '',
+    useCookies: false,
+};
+/** Storage keys */
+const STORAGE_KEYS = {
+    VISITOR_ID: 'mb_vid',
+    SESSION_ID: 'mb_sid',
+    SESSION_TIMESTAMP: 'mb_st',
+    CONSENT: 'mb_consent',
+    EVENT_QUEUE: 'mb_queue',
+};
+/** Scroll depth milestones to track */
+const SCROLL_MILESTONES = [25, 50, 75, 100];
+/** File extensions to track as downloads */
+const DOWNLOAD_EXTENSIONS = [
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.rar', '.tar', '.gz', '.7z',
+    '.csv', '.txt', '.json', '.xml',
+    '.mp3', '.mp4', '.wav', '.avi', '.mov',
+];
+/**
+ * Merge user config with defaults
+ */
+function mergeConfig(userConfig = {}) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...userConfig,
+        consent: {
+            ...DEFAULT_CONFIG.consent,
+            ...userConfig.consent,
+        },
+    };
+}
+
+/**
+ * MorrisB Tracking SDK - Debug Logger
+ * @version 3.0.0
+ */
+const LOG_PREFIX = '[Clianta]';
+const LOG_STYLES = {
+    debug: 'color: #6b7280; font-weight: normal;',
+    info: 'color: #3b82f6; font-weight: normal;',
+    warn: 'color: #f59e0b; font-weight: bold;',
+    error: 'color: #ef4444; font-weight: bold;',
+};
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+/**
+ * Create a logger instance
+ */
+function createLogger(enabled = false) {
+    let currentLevel = 'debug';
+    let isEnabled = enabled;
+    const shouldLog = (level) => {
+        if (!isEnabled)
+            return false;
+        return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+    };
+    const formatArgs = (level, args) => {
+        if (typeof console !== 'undefined' && typeof window !== 'undefined') {
+            // Browser with styled console
+            return [`%c${LOG_PREFIX}`, LOG_STYLES[level], ...args];
+        }
+        // Node.js or basic console
+        return [`${LOG_PREFIX} [${level.toUpperCase()}]`, ...args];
+    };
+    return {
+        get enabled() {
+            return isEnabled;
+        },
+        set enabled(value) {
+            isEnabled = value;
+        },
+        debug(...args) {
+            if (shouldLog('debug') && typeof console !== 'undefined') {
+                console.log(...formatArgs('debug', args));
+            }
+        },
+        info(...args) {
+            if (shouldLog('info') && typeof console !== 'undefined') {
+                console.info(...formatArgs('info', args));
+            }
+        },
+        warn(...args) {
+            if (shouldLog('warn') && typeof console !== 'undefined') {
+                console.warn(...formatArgs('warn', args));
+            }
+        },
+        error(...args) {
+            if (shouldLog('error') && typeof console !== 'undefined') {
+                console.error(...formatArgs('error', args));
+            }
+        },
+        setLevel(level) {
+            currentLevel = level;
+        },
+    };
+}
+/** Global logger instance */
+const logger = createLogger(false);
+
+/**
+ * MorrisB Tracking SDK - Transport Layer
+ * Handles sending events to the backend with retry logic
+ * @version 3.0.0
+ */
+const DEFAULT_TIMEOUT = 10000; // 10 seconds
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY = 1000; // 1 second
+/**
+ * Transport class for sending data to the backend
+ */
+class Transport {
+    constructor(config) {
+        this.config = {
+            apiEndpoint: config.apiEndpoint,
+            maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+            retryDelay: config.retryDelay ?? DEFAULT_RETRY_DELAY,
+            timeout: config.timeout ?? DEFAULT_TIMEOUT,
+        };
+    }
+    /**
+     * Send events to the tracking endpoint
+     */
+    async sendEvents(events) {
+        const url = `${this.config.apiEndpoint}/api/public/track/event`;
+        const payload = JSON.stringify({ events });
+        return this.send(url, payload);
+    }
+    /**
+     * Send identify request
+     */
+    async sendIdentify(data) {
+        const url = `${this.config.apiEndpoint}/api/public/track/identify`;
+        const payload = JSON.stringify(data);
+        return this.send(url, payload);
+    }
+    /**
+     * Send events synchronously (for page unload)
+     * Uses navigator.sendBeacon for reliability
+     */
+    sendBeacon(events) {
+        if (typeof navigator === 'undefined' || !navigator.sendBeacon) {
+            logger.warn('sendBeacon not available, events may be lost');
+            return false;
+        }
+        const url = `${this.config.apiEndpoint}/api/public/track/event`;
+        const payload = JSON.stringify({ events });
+        const blob = new Blob([payload], { type: 'application/json' });
+        try {
+            const success = navigator.sendBeacon(url, blob);
+            if (success) {
+                logger.debug(`Beacon sent ${events.length} events`);
+            }
+            else {
+                logger.warn('sendBeacon returned false');
+            }
+            return success;
+        }
+        catch (error) {
+            logger.error('sendBeacon error:', error);
+            return false;
+        }
+    }
+    /**
+     * Internal send with retry logic
+     */
+    async send(url, payload, attempt = 1) {
+        try {
+            const response = await this.fetchWithTimeout(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: payload,
+                keepalive: true,
+            });
+            if (response.ok) {
+                logger.debug('Request successful:', url);
+                return { success: true, status: response.status };
+            }
+            // Server error - may retry
+            if (response.status >= 500 && attempt < this.config.maxRetries) {
+                logger.warn(`Server error (${response.status}), retrying...`);
+                await this.delay(this.config.retryDelay * attempt);
+                return this.send(url, payload, attempt + 1);
+            }
+            // Client error - don't retry
+            logger.error(`Request failed with status ${response.status}`);
+            return { success: false, status: response.status };
+        }
+        catch (error) {
+            // Network error - retry if possible
+            if (attempt < this.config.maxRetries) {
+                logger.warn(`Network error, retrying (${attempt}/${this.config.maxRetries})...`);
+                await this.delay(this.config.retryDelay * attempt);
+                return this.send(url, payload, attempt + 1);
+            }
+            logger.error('Request failed after retries:', error);
+            return { success: false, error: error };
+        }
+    }
+    /**
+     * Fetch with timeout
+     */
+    async fetchWithTimeout(url, options) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal,
+            });
+            return response;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    /**
+     * Delay helper
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Utility Functions
+ * @version 3.0.0
+ */
+// ============================================
+// UUID GENERATION
+// ============================================
+/**
+ * Generate a UUID v4
+ */
+function generateUUID() {
+    // Use crypto.randomUUID if available (modern browsers)
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    // Fallback to manual generation
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+// ============================================
+// STORAGE UTILITIES
+// ============================================
+/**
+ * Safely get from localStorage
+ */
+function getLocalStorage(key) {
+    try {
+        if (typeof localStorage !== 'undefined') {
+            return localStorage.getItem(key);
+        }
+    }
+    catch {
+        // localStorage not available or blocked
+    }
+    return null;
+}
+/**
+ * Safely set to localStorage
+ */
+function setLocalStorage(key, value) {
+    try {
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(key, value);
+            return true;
+        }
+    }
+    catch {
+        // localStorage not available or blocked
+    }
+    return false;
+}
+/**
+ * Safely get from sessionStorage
+ */
+function getSessionStorage(key) {
+    try {
+        if (typeof sessionStorage !== 'undefined') {
+            return sessionStorage.getItem(key);
+        }
+    }
+    catch {
+        // sessionStorage not available or blocked
+    }
+    return null;
+}
+/**
+ * Safely set to sessionStorage
+ */
+function setSessionStorage(key, value) {
+    try {
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.setItem(key, value);
+            return true;
+        }
+    }
+    catch {
+        // sessionStorage not available or blocked
+    }
+    return false;
+}
+/**
+ * Get or set a cookie
+ */
+function cookie(name, value, days) {
+    if (typeof document === 'undefined')
+        return null;
+    // Get cookie
+    if (value === undefined) {
+        const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+        return match ? match[2] : null;
+    }
+    // Set cookie
+    let expires = '';
+    if (days) {
+        const date = new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+        expires = '; expires=' + date.toUTCString();
+    }
+    document.cookie = name + '=' + value + expires + '; path=/; SameSite=Lax';
+    return value;
+}
+// ============================================
+// VISITOR & SESSION MANAGEMENT
+// ============================================
+/**
+ * Get or create a persistent visitor ID
+ */
+function getOrCreateVisitorId(useCookies = false) {
+    const key = STORAGE_KEYS.VISITOR_ID;
+    // Try to get existing ID
+    let visitorId = null;
+    if (useCookies) {
+        visitorId = cookie(key);
+    }
+    else {
+        visitorId = getLocalStorage(key);
+    }
+    // Create new ID if not found
+    if (!visitorId) {
+        visitorId = generateUUID();
+        if (useCookies) {
+            cookie(key, visitorId, 365); // 1 year
+        }
+        else {
+            setLocalStorage(key, visitorId);
+        }
+    }
+    return visitorId;
+}
+/**
+ * Get or create a session ID (expires after timeout)
+ */
+function getOrCreateSessionId(timeout) {
+    const sidKey = STORAGE_KEYS.SESSION_ID;
+    const tsKey = STORAGE_KEYS.SESSION_TIMESTAMP;
+    let sessionId = getSessionStorage(sidKey);
+    const lastActivity = parseInt(getSessionStorage(tsKey) || '0', 10);
+    const now = Date.now();
+    // Check if session expired
+    if (!sessionId || now - lastActivity > timeout) {
+        sessionId = generateUUID();
+        setSessionStorage(sidKey, sessionId);
+    }
+    // Update last activity
+    setSessionStorage(tsKey, now.toString());
+    return sessionId;
+}
+/**
+ * Reset visitor and session IDs
+ */
+function resetIds(useCookies = false) {
+    const visitorKey = STORAGE_KEYS.VISITOR_ID;
+    if (useCookies) {
+        cookie(visitorKey, '', -1); // Delete cookie
+    }
+    else {
+        try {
+            localStorage.removeItem(visitorKey);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    try {
+        sessionStorage.removeItem(STORAGE_KEYS.SESSION_ID);
+        sessionStorage.removeItem(STORAGE_KEYS.SESSION_TIMESTAMP);
+    }
+    catch {
+        // Ignore
+    }
+}
+// ============================================
+// URL UTILITIES
+// ============================================
+/**
+ * Extract UTM parameters from URL
+ */
+function getUTMParams() {
+    if (typeof window === 'undefined')
+        return {};
+    try {
+        const params = new URLSearchParams(window.location.search);
+        return {
+            utmSource: params.get('utm_source') || undefined,
+            utmMedium: params.get('utm_medium') || undefined,
+            utmCampaign: params.get('utm_campaign') || undefined,
+            utmTerm: params.get('utm_term') || undefined,
+            utmContent: params.get('utm_content') || undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Check if URL is a download link
+ */
+function isDownloadUrl(url) {
+    const lowerUrl = url.toLowerCase();
+    return DOWNLOAD_EXTENSIONS.some((ext) => lowerUrl.includes(ext));
+}
+/**
+ * Extract filename from URL
+ */
+function getFilenameFromUrl(url) {
+    try {
+        return url.split('/').pop()?.split('?')[0] || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Extract file extension from URL
+ */
+function getFileExtension(url) {
+    const filename = getFilenameFromUrl(url);
+    const parts = filename.split('.');
+    return parts.length > 1 ? parts.pop() || 'unknown' : 'unknown';
+}
+// ============================================
+// DOM UTILITIES
+// ============================================
+/**
+ * Get text content from element (truncated)
+ */
+function getElementText(element, maxLength = 100) {
+    const text = element.innerText ||
+        element.textContent ||
+        element.value ||
+        '';
+    return text.trim().substring(0, maxLength);
+}
+/**
+ * Get element identification info
+ */
+function getElementInfo(element) {
+    return {
+        tag: element.tagName?.toLowerCase() || 'unknown',
+        id: element.id || '',
+        className: element.className || '',
+        text: getElementText(element, 50),
+    };
+}
+/**
+ * Check if element is a trackable click target
+ */
+function isTrackableClickElement(element) {
+    const trackableTags = ['BUTTON', 'A', 'INPUT'];
+    return (trackableTags.includes(element.tagName) ||
+        element.hasAttribute('data-track-click') ||
+        element.classList.contains('track-click'));
+}
+/**
+ * Check if device is mobile
+ */
+function isMobile() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+// ============================================
+// DEVICE INFO
+// ============================================
+/**
+ * Get current device information
+ */
+function getDeviceInfo() {
+    if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+        return {
+            userAgent: 'unknown',
+            screen: 'unknown',
+            language: 'unknown',
+            timezone: 'unknown',
+        };
+    }
+    return {
+        userAgent: navigator.userAgent,
+        screen: `${screen.width}x${screen.height}`,
+        language: navigator.language,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'unknown',
+    };
+}
+
+/**
+ * MorrisB Tracking SDK - Event Queue
+ * Handles batching and flushing of events
+ * @version 3.0.0
+ */
+const MAX_QUEUE_SIZE = 1000;
+/**
+ * Event queue with batching, persistence, and auto-flush
+ */
+class EventQueue {
+    constructor(transport, config = {}) {
+        this.queue = [];
+        this.flushTimer = null;
+        this.isFlushing = false;
+        this.transport = transport;
+        this.config = {
+            batchSize: config.batchSize ?? 10,
+            flushInterval: config.flushInterval ?? 5000,
+            maxQueueSize: config.maxQueueSize ?? MAX_QUEUE_SIZE,
+            storageKey: config.storageKey ?? STORAGE_KEYS.EVENT_QUEUE,
+        };
+        // Restore persisted queue
+        this.restoreQueue();
+        // Start auto-flush timer
+        this.startFlushTimer();
+        // Setup unload handlers
+        this.setupUnloadHandlers();
+    }
+    /**
+     * Add an event to the queue
+     */
+    push(event) {
+        // Don't exceed max queue size
+        if (this.queue.length >= this.config.maxQueueSize) {
+            logger.warn('Queue full, dropping oldest event');
+            this.queue.shift();
+        }
+        this.queue.push(event);
+        logger.debug('Event queued:', event.eventName, `(${this.queue.length} in queue)`);
+        // Flush if batch size reached
+        if (this.queue.length >= this.config.batchSize) {
+            this.flush();
+        }
+    }
+    /**
+     * Flush the queue (send all events)
+     */
+    async flush() {
+        if (this.isFlushing || this.queue.length === 0) {
+            return;
+        }
+        this.isFlushing = true;
+        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([]);
+            // Send to backend
+            const result = await this.transport.sendEvents(events);
+            if (!result.success) {
+                // Re-queue events on failure (at the front)
+                logger.warn('Flush failed, re-queuing events');
+                this.queue.unshift(...events);
+                this.persistQueue(this.queue);
+            }
+            else {
+                logger.debug('Flush successful');
+            }
+        }
+        catch (error) {
+            logger.error('Flush error:', error);
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    /**
+     * Flush synchronously using sendBeacon (for page unload)
+     */
+    flushSync() {
+        if (this.queue.length === 0)
+            return;
+        const events = this.queue.splice(0, this.queue.length);
+        logger.debug(`Sync flushing ${events.length} events via beacon`);
+        const success = this.transport.sendBeacon(events);
+        if (!success) {
+            // Re-queue and persist for next page load
+            this.queue.unshift(...events);
+            this.persistQueue(this.queue);
+        }
+    }
+    /**
+     * Get current queue length
+     */
+    get length() {
+        return this.queue.length;
+    }
+    /**
+     * Clear the queue
+     */
+    clear() {
+        this.queue = [];
+        this.persistQueue([]);
+    }
+    /**
+     * Stop the flush timer
+     */
+    destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    /**
+     * Start auto-flush timer
+     */
+    startFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flushTimer = setInterval(() => {
+            this.flush();
+        }, this.config.flushInterval);
+    }
+    /**
+     * Setup page unload handlers
+     */
+    setupUnloadHandlers() {
+        if (typeof window === 'undefined')
+            return;
+        // Flush on page unload
+        window.addEventListener('beforeunload', () => {
+            this.flushSync();
+        });
+        // Flush when page becomes hidden
+        window.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                this.flushSync();
+            }
+        });
+        // Flush on page hide (iOS Safari)
+        window.addEventListener('pagehide', () => {
+            this.flushSync();
+        });
+    }
+    /**
+     * Persist queue to localStorage
+     */
+    persistQueue(events) {
+        try {
+            setLocalStorage(this.config.storageKey, JSON.stringify(events));
+        }
+        catch {
+            // Ignore storage errors
+        }
+    }
+    /**
+     * Restore queue from localStorage
+     */
+    restoreQueue() {
+        try {
+            const stored = getLocalStorage(this.config.storageKey);
+            if (stored) {
+                const events = JSON.parse(stored);
+                if (Array.isArray(events) && events.length > 0) {
+                    this.queue = events;
+                    logger.debug(`Restored ${events.length} events from storage`);
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Plugin Base
+ * @version 3.0.0
+ */
+/**
+ * Base class for plugins
+ */
+class BasePlugin {
+    constructor() {
+        this.tracker = null;
+    }
+    init(tracker) {
+        this.tracker = tracker;
+    }
+    destroy() {
+        this.tracker = null;
+    }
+    track(eventType, eventName, properties) {
+        if (this.tracker) {
+            this.tracker.track(eventType, eventName, properties);
+        }
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Page View Plugin
+ * @version 3.0.0
+ */
+/**
+ * Page View Plugin - Tracks page views
+ */
+class PageViewPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'pageView';
+    }
+    init(tracker) {
+        super.init(tracker);
+        // Track initial page view
+        this.trackPageView();
+        // Track SPA navigation (History API)
+        if (typeof window !== 'undefined') {
+            // Intercept pushState and replaceState
+            const originalPushState = history.pushState;
+            const originalReplaceState = history.replaceState;
+            history.pushState = (...args) => {
+                originalPushState.apply(history, args);
+                this.trackPageView();
+            };
+            history.replaceState = (...args) => {
+                originalReplaceState.apply(history, args);
+                this.trackPageView();
+            };
+            // Handle back/forward navigation
+            window.addEventListener('popstate', () => {
+                this.trackPageView();
+            });
+        }
+    }
+    trackPageView() {
+        if (typeof window === 'undefined' || typeof document === 'undefined')
+            return;
+        this.track('page_view', 'Page Viewed', {
+            title: document.title,
+            path: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash,
+            referrer: document.referrer || 'direct',
+            viewport: `${window.innerWidth}x${window.innerHeight}`,
+        });
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Scroll Depth Plugin
+ * @version 3.0.0
+ */
+/**
+ * Scroll Depth Plugin - Tracks scroll milestones
+ */
+class ScrollPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'scroll';
+        this.milestonesReached = new Set();
+        this.maxScrollDepth = 0;
+        this.pageLoadTime = 0;
+        this.scrollTimeout = null;
+        this.boundHandler = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        this.pageLoadTime = Date.now();
+        if (typeof window !== 'undefined') {
+            this.boundHandler = this.handleScroll.bind(this);
+            window.addEventListener('scroll', this.boundHandler, { passive: true });
+        }
+    }
+    destroy() {
+        if (this.boundHandler && typeof window !== 'undefined') {
+            window.removeEventListener('scroll', this.boundHandler);
+        }
+        if (this.scrollTimeout) {
+            clearTimeout(this.scrollTimeout);
+        }
+        super.destroy();
+    }
+    handleScroll() {
+        // Debounce scroll tracking
+        if (this.scrollTimeout) {
+            clearTimeout(this.scrollTimeout);
+        }
+        this.scrollTimeout = setTimeout(() => this.trackScrollDepth(), 150);
+    }
+    trackScrollDepth() {
+        if (typeof window === 'undefined' || typeof document === 'undefined')
+            return;
+        const windowHeight = window.innerHeight;
+        const documentHeight = document.documentElement.scrollHeight;
+        const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+        const scrollPercent = Math.floor((scrollTop / (documentHeight - windowHeight)) * 100);
+        // Clamp to valid range
+        const clampedPercent = Math.max(0, Math.min(100, scrollPercent));
+        // Update max scroll depth
+        if (clampedPercent > this.maxScrollDepth) {
+            this.maxScrollDepth = clampedPercent;
+        }
+        // Track milestones
+        for (const milestone of SCROLL_MILESTONES) {
+            if (clampedPercent >= milestone && !this.milestonesReached.has(milestone)) {
+                this.milestonesReached.add(milestone);
+                this.track('scroll_depth', `Scrolled ${milestone}%`, {
+                    depth: milestone,
+                    maxDepth: this.maxScrollDepth,
+                    timeToReach: Date.now() - this.pageLoadTime,
+                });
+            }
+        }
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Form Tracking Plugin
+ * @version 3.0.0
+ */
+/**
+ * Form Tracking Plugin - Auto-tracks form views, interactions, and submissions
+ */
+class FormsPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'forms';
+        this.trackedForms = new WeakSet();
+        this.formInteractions = new Set();
+        this.observer = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        if (typeof document === 'undefined')
+            return;
+        // Track existing forms
+        this.trackAllForms();
+        // Watch for dynamically added forms
+        if (typeof MutationObserver !== 'undefined') {
+            this.observer = new MutationObserver(() => this.trackAllForms());
+            this.observer.observe(document.body, { childList: true, subtree: true });
+        }
+    }
+    destroy() {
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+        super.destroy();
+    }
+    trackAllForms() {
+        document.querySelectorAll('form').forEach((form) => {
+            this.setupFormTracking(form);
+        });
+    }
+    setupFormTracking(form) {
+        if (this.trackedForms.has(form))
+            return;
+        this.trackedForms.add(form);
+        const formId = form.id || form.name || `form-${Math.random().toString(36).substr(2, 9)}`;
+        // Track form view
+        this.track('form_view', 'Form Viewed', {
+            formId,
+            action: form.action,
+            method: form.method,
+            fieldCount: form.elements.length,
+        });
+        // Track field interactions
+        Array.from(form.elements).forEach((field) => {
+            if (field instanceof HTMLInputElement ||
+                field instanceof HTMLSelectElement ||
+                field instanceof HTMLTextAreaElement) {
+                if (!field.name || field.type === 'submit' || field.type === 'button')
+                    return;
+                ['focus', 'blur', 'change'].forEach((eventType) => {
+                    field.addEventListener(eventType, () => {
+                        const key = `${formId}-${field.name}-${eventType}`;
+                        if (!this.formInteractions.has(key)) {
+                            this.formInteractions.add(key);
+                            this.track('form_interaction', 'Form Field Interaction', {
+                                formId,
+                                fieldName: field.name,
+                                fieldType: field.type,
+                                interactionType: eventType,
+                            });
+                        }
+                    });
+                });
+            }
+        });
+        // Track form submission
+        form.addEventListener('submit', () => {
+            this.track('form_submit', 'Form Submitted', {
+                formId,
+                action: form.action,
+                method: form.method,
+            });
+            // Auto-identify if email field found
+            this.autoIdentify(form);
+        });
+    }
+    autoIdentify(form) {
+        const emailField = form.querySelector('input[type="email"], input[name*="email"]');
+        if (!emailField?.value || !this.tracker)
+            return;
+        const email = emailField.value;
+        const traits = {};
+        // Capture common fields
+        const firstNameField = form.querySelector('[name*="first"], [name*="fname"]');
+        const lastNameField = form.querySelector('[name*="last"], [name*="lname"]');
+        const companyField = form.querySelector('[name*="company"], [name*="organization"]');
+        const phoneField = form.querySelector('[type="tel"], [name*="phone"]');
+        if (firstNameField?.value)
+            traits.firstName = firstNameField.value;
+        if (lastNameField?.value)
+            traits.lastName = lastNameField.value;
+        if (companyField?.value)
+            traits.company = companyField.value;
+        if (phoneField?.value)
+            traits.phone = phoneField.value;
+        this.tracker.identify(email, traits);
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Click Tracking Plugin
+ * @version 3.0.0
+ */
+/**
+ * Click Tracking Plugin - Tracks button and CTA clicks
+ */
+class ClicksPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'clicks';
+        this.boundHandler = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        if (typeof document !== 'undefined') {
+            this.boundHandler = this.handleClick.bind(this);
+            document.addEventListener('click', this.boundHandler, true);
+        }
+    }
+    destroy() {
+        if (this.boundHandler && typeof document !== 'undefined') {
+            document.removeEventListener('click', this.boundHandler, true);
+        }
+        super.destroy();
+    }
+    handleClick(e) {
+        const target = e.target;
+        if (!target || !isTrackableClickElement(target))
+            return;
+        const buttonText = getElementText(target, 100);
+        const elementInfo = getElementInfo(target);
+        this.track('button_click', 'Button Clicked', {
+            buttonText,
+            elementType: target.tagName.toLowerCase(),
+            elementId: elementInfo.id,
+            elementClass: elementInfo.className,
+            href: target.href || undefined,
+        });
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Engagement Plugin
+ * @version 3.0.0
+ */
+/**
+ * Engagement Plugin - Tracks user engagement and time on page
+ */
+class EngagementPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'engagement';
+        this.pageLoadTime = 0;
+        this.engagementStartTime = 0;
+        this.isEngaged = false;
+        this.engagementTimeout = null;
+        this.boundMarkEngaged = null;
+        this.boundTrackTimeOnPage = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        this.pageLoadTime = Date.now();
+        this.engagementStartTime = Date.now();
+        if (typeof document === 'undefined' || typeof window === 'undefined')
+            return;
+        // 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', () => {
+            if (document.visibilityState === 'hidden') {
+                this.trackTimeOnPage();
+            }
+            else {
+                // Reset engagement timer when page becomes visible again
+                this.engagementStartTime = Date.now();
+            }
+        });
+    }
+    destroy() {
+        if (this.boundMarkEngaged && typeof document !== 'undefined') {
+            ['mousemove', 'keydown', 'touchstart', 'scroll'].forEach((event) => {
+                document.removeEventListener(event, this.boundMarkEngaged);
+            });
+        }
+        if (this.boundTrackTimeOnPage && typeof window !== 'undefined') {
+            window.removeEventListener('beforeunload', this.boundTrackTimeOnPage);
+        }
+        if (this.engagementTimeout) {
+            clearTimeout(this.engagementTimeout);
+        }
+        super.destroy();
+    }
+    markEngaged() {
+        if (!this.isEngaged) {
+            this.isEngaged = true;
+            this.track('engagement', 'User Engaged', {
+                timeToEngage: Date.now() - this.pageLoadTime,
+            });
+        }
+        // Reset engagement timeout
+        if (this.engagementTimeout) {
+            clearTimeout(this.engagementTimeout);
+        }
+        this.engagementTimeout = setTimeout(() => {
+            this.isEngaged = false;
+        }, 30000); // 30 seconds of inactivity
+    }
+    trackTimeOnPage() {
+        const timeSpent = Math.floor((Date.now() - this.engagementStartTime) / 1000);
+        if (timeSpent > 0) {
+            this.track('time_on_page', 'Time Spent', {
+                seconds: timeSpent,
+                engaged: this.isEngaged,
+            });
+        }
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Downloads Plugin
+ * @version 3.0.0
+ */
+/**
+ * Downloads Plugin - Tracks file downloads
+ */
+class DownloadsPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'downloads';
+        this.trackedDownloads = new Set();
+        this.boundHandler = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        if (typeof document !== 'undefined') {
+            this.boundHandler = this.handleClick.bind(this);
+            document.addEventListener('click', this.boundHandler, true);
+        }
+    }
+    destroy() {
+        if (this.boundHandler && typeof document !== 'undefined') {
+            document.removeEventListener('click', this.boundHandler, true);
+        }
+        super.destroy();
+    }
+    handleClick(e) {
+        const link = e.target.closest('a');
+        if (!link || !link.href)
+            return;
+        const url = link.href;
+        // Check if it's a download link
+        if (!isDownloadUrl(url))
+            return;
+        // Avoid tracking the same download multiple times
+        if (this.trackedDownloads.has(url))
+            return;
+        this.trackedDownloads.add(url);
+        this.track('download', 'File Download', {
+            url,
+            filename: getFilenameFromUrl(url),
+            fileType: getFileExtension(url),
+            linkText: getElementText(link, 100),
+        });
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Exit Intent Plugin
+ * @version 3.0.0
+ */
+/**
+ * Exit Intent Plugin - Detects when user intends to leave the page
+ */
+class ExitIntentPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'exitIntent';
+        this.exitIntentShown = false;
+        this.pageLoadTime = 0;
+        this.boundHandler = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        this.pageLoadTime = Date.now();
+        // Skip on mobile (no mouse events)
+        if (isMobile())
+            return;
+        if (typeof document !== 'undefined') {
+            this.boundHandler = this.handleMouseLeave.bind(this);
+            document.addEventListener('mouseleave', this.boundHandler);
+        }
+    }
+    destroy() {
+        if (this.boundHandler && typeof document !== 'undefined') {
+            document.removeEventListener('mouseleave', this.boundHandler);
+        }
+        super.destroy();
+    }
+    handleMouseLeave(e) {
+        // Only trigger when mouse leaves from the top of the page
+        if (e.clientY > 0 || this.exitIntentShown)
+            return;
+        this.exitIntentShown = true;
+        this.track('exit_intent', 'Exit Intent Detected', {
+            timeOnPage: Date.now() - this.pageLoadTime,
+        });
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Error Tracking Plugin
+ * @version 3.0.0
+ */
+/**
+ * Error Tracking Plugin - Tracks JavaScript errors
+ */
+class ErrorsPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'errors';
+        this.boundErrorHandler = null;
+        this.boundRejectionHandler = null;
+    }
+    init(tracker) {
+        super.init(tracker);
+        if (typeof window !== 'undefined') {
+            this.boundErrorHandler = this.handleError.bind(this);
+            this.boundRejectionHandler = this.handleRejection.bind(this);
+            window.addEventListener('error', this.boundErrorHandler);
+            window.addEventListener('unhandledrejection', this.boundRejectionHandler);
+        }
+    }
+    destroy() {
+        if (typeof window !== 'undefined') {
+            if (this.boundErrorHandler) {
+                window.removeEventListener('error', this.boundErrorHandler);
+            }
+            if (this.boundRejectionHandler) {
+                window.removeEventListener('unhandledrejection', this.boundRejectionHandler);
+            }
+        }
+        super.destroy();
+    }
+    handleError(e) {
+        this.track('error', 'JavaScript Error', {
+            message: e.message,
+            filename: e.filename,
+            line: e.lineno,
+            column: e.colno,
+            stack: e.error?.stack?.substring(0, 500),
+        });
+    }
+    handleRejection(e) {
+        this.track('error', 'Unhandled Promise Rejection', {
+            reason: String(e.reason).substring(0, 200),
+        });
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Performance Plugin
+ * @version 3.0.0
+ */
+/**
+ * Performance Plugin - Tracks page performance and Web Vitals
+ */
+class PerformancePlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'performance';
+    }
+    init(tracker) {
+        super.init(tracker);
+        if (typeof window !== 'undefined') {
+            // Track performance after page load
+            window.addEventListener('load', () => {
+                // Delay to ensure all metrics are available
+                setTimeout(() => this.trackPerformance(), 100);
+            });
+        }
+    }
+    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,
+        });
+        // Track Web Vitals if available
+        this.trackWebVitals();
+    }
+    trackWebVitals() {
+        // LCP (Largest Contentful Paint)
+        if ('PerformanceObserver' in window) {
+            try {
+                const lcpObserver = new PerformanceObserver((entryList) => {
+                    const entries = entryList.getEntries();
+                    const lastEntry = entries[entries.length - 1];
+                    if (lastEntry) {
+                        this.track('performance', 'Web Vital - LCP', {
+                            metric: 'LCP',
+                            value: Math.round(lastEntry.startTime),
+                        });
+                    }
+                });
+                lcpObserver.observe({ type: 'largest-contentful-paint', buffered: true });
+            }
+            catch {
+                // LCP not supported
+            }
+            // FID (First Input Delay)
+            try {
+                const fidObserver = new PerformanceObserver((entryList) => {
+                    const entries = entryList.getEntries();
+                    const firstEntry = entries[0];
+                    if (firstEntry) {
+                        this.track('performance', 'Web Vital - FID', {
+                            metric: 'FID',
+                            value: Math.round(firstEntry.processingStart - firstEntry.startTime),
+                        });
+                    }
+                });
+                fidObserver.observe({ type: 'first-input', buffered: true });
+            }
+            catch {
+                // FID not supported
+            }
+            // CLS (Cumulative Layout Shift)
+            try {
+                let clsValue = 0;
+                const clsObserver = new PerformanceObserver((entryList) => {
+                    const entries = entryList.getEntries();
+                    entries.forEach((entry) => {
+                        if (!entry.hadRecentInput) {
+                            clsValue += entry.value || 0;
+                        }
+                    });
+                });
+                clsObserver.observe({ type: 'layout-shift', buffered: true });
+                // Report CLS after page is hidden
+                window.addEventListener('visibilitychange', () => {
+                    if (document.visibilityState === 'hidden' && clsValue > 0) {
+                        this.track('performance', 'Web Vital - CLS', {
+                            metric: 'CLS',
+                            value: Math.round(clsValue * 1000) / 1000,
+                        });
+                    }
+                }, { once: true });
+            }
+            catch {
+                // CLS not supported
+            }
+        }
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Plugins Index
+ * @version 3.0.0
+ */
+/**
+ * Get plugin instance by name
+ */
+function getPlugin(name) {
+    switch (name) {
+        case 'pageView':
+            return new PageViewPlugin();
+        case 'scroll':
+            return new ScrollPlugin();
+        case 'forms':
+            return new FormsPlugin();
+        case 'clicks':
+            return new ClicksPlugin();
+        case 'engagement':
+            return new EngagementPlugin();
+        case 'downloads':
+            return new DownloadsPlugin();
+        case 'exitIntent':
+            return new ExitIntentPlugin();
+        case 'errors':
+            return new ErrorsPlugin();
+        case 'performance':
+            return new PerformancePlugin();
+        default:
+            throw new Error(`Unknown plugin: ${name}`);
+    }
+}
+
+/**
+ * MorrisB Tracking SDK - Main Tracker Class
+ * @version 3.0.0
+ */
+/**
+ * Main MorrisB Tracker Class
+ */
+class Tracker {
+    constructor(workspaceId, userConfig = {}) {
+        this.plugins = [];
+        this.isInitialized = false;
+        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 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
+        this.visitorId = getOrCreateVisitorId(this.config.useCookies);
+        this.sessionId = getOrCreateSessionId(this.config.sessionTimeout);
+        logger.debug('IDs created', { visitorId: this.visitorId, sessionId: this.sessionId });
+        // Initialize plugins
+        this.initPlugins();
+        this.isInitialized = true;
+        logger.info('SDK initialized successfully');
+    }
+    /**
+     * Initialize enabled plugins
+     */
+    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);
+                plugin.init(this);
+                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,
+            device: getDeviceInfo(),
+            utm: getUTMParams(),
+            timestamp: new Date().toISOString(),
+            sdkVersion: SDK_VERSION,
+        };
+        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
+     */
+    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);
+        }
+    }
+    /**
+     * Update consent state
+     */
+    consent(state) {
+        logger.info('Consent updated:', state);
+        // TODO: Implement consent management
+        // - Store consent state
+        // - Enable/disable tracking based on consent
+        // - Notify plugins
+    }
+    /**
+     * 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.queue.flush();
+    }
+    /**
+     * Reset visitor and session (for logout)
+     */
+    reset() {
+        logger.info('Resetting visitor data');
+        resetIds(this.config.useCookies);
+        this.visitorId = getOrCreateVisitorId(this.config.useCookies);
+        this.sessionId = getOrCreateSessionId(this.config.sessionTimeout);
+        this.queue.clear();
+    }
+    /**
+     * Destroy tracker and cleanup
+     */
+    destroy() {
+        logger.info('Destroying tracker');
+        // Flush any remaining events
+        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;
+    }
+}
+
+/**
+ * Clianta SDK - CRM API Client
+ * @version 1.0.0
+ */
+/**
+ * CRM API Client for managing contacts and opportunities
+ */
+class CRMClient {
+    constructor(apiEndpoint, workspaceId, authToken) {
+        this.apiEndpoint = apiEndpoint;
+        this.workspaceId = workspaceId;
+        this.authToken = authToken;
+    }
+    /**
+     * Set authentication token for API requests
+     */
+    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}`;
+        }
+        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) {
+        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) {
+        return this.request(`/api/workspaces/${this.workspaceId}/contacts/${contactId}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates),
+        });
+    }
+    /**
+     * Delete a contact
+     */
+    async deleteContact(contactId) {
+        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 }),
+        });
+    }
+}
+
+/**
+ * Clianta SDK
+ * Professional CRM and tracking SDK for lead generation
+ * @version 1.0.0
+ */
+// Global instance cache
+let globalInstance = null;
+/**
+ * Initialize or get the Clianta tracker instance
+ *
+ * @example
+ * // Simple initialization
+ * const tracker = clianta('your-workspace-id');
+ *
+ * @example
+ * // With configuration
+ * const tracker = clianta('your-workspace-id', {
+ *   debug: true,
+ *   plugins: ['pageView', 'forms', 'scroll'],
+ * });
+ */
+function clianta(workspaceId, config) {
+    // Return existing instance if same workspace
+    if (globalInstance && globalInstance.getWorkspaceId() === workspaceId) {
+        return globalInstance;
+    }
+    // Destroy existing instance if workspace changed
+    if (globalInstance) {
+        globalInstance.destroy();
+    }
+    // Create new instance
+    globalInstance = new Tracker(workspaceId, config);
+    return globalInstance;
+}
+// Attach to window for <script> usage
+if (typeof window !== 'undefined') {
+    window.clianta = clianta;
+    window.Clianta = {
+        clianta,
+        Tracker,
+        CRMClient,
+    };
+}
+
+export { CRMClient, SDK_VERSION, Tracker, clianta, clianta as default };
+//# sourceMappingURL=clianta.esm.js.map