@supsis/supsis-js 1.0.0

package/dist/supsis.js

@@ -0,0 +1,4075 @@
+/**
+ * Supsis JS SDK v1.0.0
+ * Supsis API SDK - Browser ve Node.js için omnichannel messaging, chatbot, automation, task, ticket ve voice agent entegrasyonu
+ * 
+ * @license MIT
+ * @author Supsis <info@supsis.com>
+ * @see https://supsis.com
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SupsisJS = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Supsis API ortam URL'leri
+     * @readonly
+     * @enum {string}
+     */
+    const ENVIRONMENTS = {
+        /** Production API - api.supsis.live */
+        production: 'https://api.supsis.live',
+        /** Stage/Beta API - beta-api.supsis.live */
+        stage: 'https://beta-api.supsis.live',
+        /** Local development API */
+        local: 'https://tablet-api-local.supsis.live'
+    };
+
+    /**
+     * Varsayılan SDK konfigürasyonu
+     * @type {SupsisConfig}
+     */
+    const DEFAULT_CONFIG = {
+        /** Varsayılan ortam (production) */
+        env: 'production',
+        /** Custom API adresi (null ise env'den alınır) - OnPrem kurulumları için */
+        baseApiAddress: null,
+        /** HTTP istek timeout süresi (ms) */
+        timeout: 30000,
+        /** Başarısız isteklerde retry sayısı */
+        retryCount: 3,
+        /** Retry'lar arası bekleme süresi (ms) */
+        retryDelay: 1000
+    };
+
+    /**
+     * HTTP Status kodları
+     * @readonly
+     * @enum {number}
+     */
+    const HTTP_STATUS = {
+        UNAUTHORIZED: 401,
+        FORBIDDEN: 403};
+
+    /**
+     * SDK Versiyon bilgisi
+     */
+    const SDK_VERSION = '1.0.0';
+
+    /**
+     * Supsis API hatası
+     * @class SupsisAPIError
+     * @extends Error
+     */
+    class SupsisAPIError extends Error {
+        /**
+         * @param {string} message - Hata mesajı
+         * @param {number} statusCode - HTTP status kodu
+         * @param {Object} [response] - API yanıtı
+         */
+        constructor(message, statusCode, response) {
+            super(message);
+            this.name = 'SupsisAPIError';
+            this.statusCode = statusCode;
+            this.response = response;
+        }
+    }
+
+    /**
+     * HTTP isteklerini yöneten client sınıfı
+     * Browser ve Node.js ortamlarında çalışır
+     * @class HttpClient
+     */
+    class HttpClient {
+        /**
+         * HttpClient oluşturur
+         * @param {Object} config - Konfigürasyon
+         * @param {string} [config.env='production'] - Ortam (production, stage, local)
+         * @param {string} [config.baseApiAddress] - Custom API adresi (OnPrem için)
+         * @param {string} [config.siteId] - Site ID (multi-tenant)
+         * @param {number} [config.timeout=30000] - İstek timeout süresi (ms)
+         * @param {number} [config.retryCount=3] - Retry sayısı
+         * @param {number} [config.retryDelay=1000] - Retry arası bekleme (ms)
+         */
+        constructor(config) {
+            this.config = Object.assign({}, DEFAULT_CONFIG, config);
+            this.baseUrl = this._resolveBaseUrl();
+            this.token = null;
+            this.siteId = config.siteId || null;
+        }
+
+        /**
+         * API base URL'sini çözümler
+         * @private
+         * @returns {string} Base URL
+         */
+        _resolveBaseUrl() {
+            // Custom baseApiAddress varsa onu kullan (OnPrem)
+            if (this.config.baseApiAddress) {
+                return this.config.baseApiAddress.replace(/\/$/, ''); // Trailing slash temizle
+            }
+            // Yoksa env'e göre belirle
+            return ENVIRONMENTS[this.config.env] || ENVIRONMENTS.production;
+        }
+
+        /**
+         * Authorization token'ı ayarlar
+         * @param {string} token - JWT token
+         */
+        setToken(token) {
+            this.token = token;
+        }
+
+        /**
+         * Site ID'yi ayarlar
+         * @param {string} siteId - Site ID
+         */
+        setSiteId(siteId) {
+            this.siteId = siteId;
+        }
+
+        /**
+         * HTTP isteği yapar
+         * @param {string} method - HTTP metodu (GET, POST, PUT, DELETE, PATCH)
+         * @param {string} endpoint - API endpoint'i
+         * @param {Object} [options] - İstek seçenekleri
+         * @param {Object} [options.body] - İstek body'si
+         * @param {Object} [options.query] - Query parametreleri
+         * @param {Object} [options.headers] - Ek header'lar
+         * @param {boolean} [options.skipAuth=false] - Auth header'ı atla
+         * @returns {Promise<Object>} API yanıtı
+         * @throws {SupsisAPIError} API hatası
+         */
+        async request(method, endpoint, options) {
+            options = options || {};
+            const url = this._buildUrl(endpoint, options.query);
+            const headers = this._buildHeaders(options.headers, options.skipAuth);
+            
+            const fetchOptions = {
+                method: method.toUpperCase(),
+                headers: headers
+            };
+
+            if (options.body && method.toUpperCase() !== 'GET') {
+                fetchOptions.body = JSON.stringify(options.body);
+            }
+
+            let lastError;
+            const retryCount = options.retryCount !== undefined ? options.retryCount : this.config.retryCount;
+
+            for (let attempt = 0; attempt <= retryCount; attempt++) {
+                try {
+                    const response = await this._fetchWithTimeout(url, fetchOptions);
+                    return await this._handleResponse(response);
+                } catch (error) {
+                    lastError = error;
+                    
+                    // Auth hatalarında retry yapma
+                    if (error.statusCode === HTTP_STATUS.UNAUTHORIZED || 
+                        error.statusCode === HTTP_STATUS.FORBIDDEN) {
+                        throw error;
+                    }
+                    
+                    // Son deneme değilse bekle ve tekrar dene
+                    if (attempt < retryCount) {
+                        await this._sleep(this.config.retryDelay * (attempt + 1));
+                    }
+                }
+            }
+
+            throw lastError;
+        }
+
+        /**
+         * Timeout'lu fetch işlemi
+         * @private
+         */
+        async _fetchWithTimeout(url, options) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(function() {
+                controller.abort();
+            }, this.config.timeout);
+
+            try {
+                const response = await fetch(url, Object.assign({}, options, {
+                    signal: controller.signal
+                }));
+                clearTimeout(timeoutId);
+                return response;
+            } catch (error) {
+                clearTimeout(timeoutId);
+                if (error.name === 'AbortError') {
+                    throw new SupsisAPIError('Request timeout', 408);
+                }
+                throw error;
+            }
+        }
+
+        /**
+         * URL oluşturur
+         * @private
+         */
+        _buildUrl(endpoint, query) {
+            let url = this.baseUrl + endpoint;
+            
+            if (query && Object.keys(query).length > 0) {
+                const params = new URLSearchParams();
+                Object.keys(query).forEach(function(key) {
+                    if (query[key] !== undefined && query[key] !== null) {
+                        params.append(key, query[key]);
+                    }
+                });
+                url = url + '?' + params.toString();
+            }
+            
+            return url;
+        }
+
+        /**
+         * Header'ları oluşturur
+         * @private
+         */
+        _buildHeaders(customHeaders, skipAuth) {
+            const headers = {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            };
+
+            // Site ID header'ı
+            if (this.siteId) {
+                headers['site-id'] = this.siteId;
+            }
+
+            // Authorization header
+            if (!skipAuth && this.token) {
+                headers['Authorization'] = 'Bearer ' + this.token;
+            }
+
+            // Custom header'ları merge et
+            if (customHeaders) {
+                Object.assign(headers, customHeaders);
+            }
+
+            return headers;
+        }
+
+        /**
+         * API yanıtını işler
+         * @private
+         */
+        async _handleResponse(response) {
+            let data;
+            
+            try {
+                const contentType = response.headers.get('content-type');
+                if (contentType && contentType.indexOf('application/json') !== -1) {
+                    data = await response.json();
+                } else {
+                    data = await response.text();
+                }
+            } catch (e) {
+                data = null;
+            }
+
+            if (!response.ok) {
+                const message = (data && data.message) || (data && data.error) || response.statusText || 'API Error';
+                throw new SupsisAPIError(message, response.status, data);
+            }
+
+            return data;
+        }
+
+        /**
+         * Promise tabanlı sleep
+         * @private
+         */
+        _sleep(ms) {
+            return new Promise(function(resolve) {
+                setTimeout(resolve, ms);
+            });
+        }
+
+        // Convenience methods
+        
+        /**
+         * GET isteği yapar
+         * @param {string} endpoint - API endpoint'i
+         * @param {Object} [options] - İstek seçenekleri
+         * @returns {Promise<Object>} API yanıtı
+         */
+        get(endpoint, options) {
+            return this.request('GET', endpoint, options);
+        }
+
+        /**
+         * POST isteği yapar
+         * @param {string} endpoint - API endpoint'i
+         * @param {Object} [body] - İstek body'si
+         * @param {Object} [options] - İstek seçenekleri
+         * @returns {Promise<Object>} API yanıtı
+         */
+        post(endpoint, body, options) {
+            return this.request('POST', endpoint, Object.assign({}, options, { body: body }));
+        }
+
+        /**
+         * PUT isteği yapar
+         * @param {string} endpoint - API endpoint'i
+         * @param {Object} [body] - İstek body'si
+         * @param {Object} [options] - İstek seçenekleri
+         * @returns {Promise<Object>} API yanıtı
+         */
+        put(endpoint, body, options) {
+            return this.request('PUT', endpoint, Object.assign({}, options, { body: body }));
+        }
+
+        /**
+         * PATCH isteği yapar
+         * @param {string} endpoint - API endpoint'i
+         * @param {Object} [body] - İstek body'si
+         * @param {Object} [options] - İstek seçenekleri
+         * @returns {Promise<Object>} API yanıtı
+         */
+        patch(endpoint, body, options) {
+            return this.request('PATCH', endpoint, Object.assign({}, options, { body: body }));
+        }
+
+        /**
+         * DELETE isteği yapar
+         * @param {string} endpoint - API endpoint'i
+         * @param {Object} [options] - İstek seçenekleri
+         * @returns {Promise<Object>} API yanıtı
+         */
+        delete(endpoint, options) {
+            return this.request('DELETE', endpoint, options);
+        }
+    }
+
+    /**
+     * Tüm SDK modüllerinin base sınıfı
+     * @class BaseModule
+     */
+    class BaseModule {
+        /**
+         * BaseModule oluşturur
+         * @param {import('./HttpClient.js').HttpClient} httpClient - HTTP client instance
+         */
+        constructor(httpClient) {
+            if (!httpClient) {
+                throw new Error('HttpClient is required');
+            }
+            /** @protected */
+            this.http = httpClient;
+        }
+
+        /**
+         * Pagination parametrelerini normalize eder
+         * @protected
+         * @param {Object} options - Pagination seçenekleri
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt sayısı
+         * @param {number} [options.offset] - Offset (alternatif pagination)
+         * @returns {Object} Normalize edilmiş pagination parametreleri
+         */
+        _normalizePagination(options) {
+            options = options || {};
+            const page = options.page || 1;
+            const limit = options.limit || 20;
+            
+            return {
+                page: page,
+                limit: limit,
+                offset: options.offset !== undefined ? options.offset : (page - 1) * limit
+            };
+        }
+
+        /**
+         * MongoDB ObjectId formatını doğrular
+         * @protected
+         * @param {string} id - Doğrulanacak ID
+         * @returns {boolean} Geçerli mi
+         */
+        _isValidObjectId(id) {
+            if (!id || typeof id !== 'string') {
+                return false;
+            }
+            return /^[a-fA-F0-9]{24}$/.test(id);
+        }
+
+        /**
+         * Gerekli parametreleri kontrol eder
+         * @protected
+         * @param {Object} params - Kontrol edilecek parametreler
+         * @param {string[]} required - Zorunlu parametre isimleri
+         * @throws {Error} Eksik parametre varsa
+         */
+        _validateRequired(params, required) {
+            const missing = [];
+            required.forEach(function(key) {
+                if (params[key] === undefined || params[key] === null) {
+                    missing.push(key);
+                }
+            });
+            
+            if (missing.length > 0) {
+                throw new Error('Missing required parameters: ' + missing.join(', '));
+            }
+        }
+
+        /**
+         * Tarih değerini ISO string'e çevirir
+         * @protected
+         * @param {Date|string|number} date - Tarih değeri
+         * @returns {string|null} ISO date string veya null
+         */
+        _toISODate(date) {
+            if (!date) {
+                return null;
+            }
+            
+            if (date instanceof Date) {
+                return date.toISOString();
+            }
+            
+            if (typeof date === 'number') {
+                return new Date(date).toISOString();
+            }
+            
+            if (typeof date === 'string') {
+                return new Date(date).toISOString();
+            }
+            
+            return null;
+        }
+
+        /**
+         * Objedeki undefined değerleri temizler
+         * @protected
+         * @param {Object} obj - Temizlenecek obje
+         * @returns {Object} Temizlenmiş obje
+         */
+        _cleanObject(obj) {
+            if (!obj || typeof obj !== 'object') {
+                return obj;
+            }
+            
+            const cleaned = {};
+            Object.keys(obj).forEach(function(key) {
+                if (obj[key] !== undefined) {
+                    cleaned[key] = obj[key];
+                }
+            });
+            
+            return cleaned;
+        }
+    }
+
+    /**
+     * Chat (Conversation) modülü
+     * Canlı sohbet, WhatsApp, Instagram ve diğer kanal konuşmalarını yönetir
+     * 
+     * @class Chat
+     * @extends BaseModule
+     * @example
+     * // Bir chat'i getir
+     * const chat = await supsis.chat.get('507f1f77bcf86cd799439011');
+     * 
+     * // Chat listesini getir
+     * const chats = await supsis.chat.list({ status: 'active', limit: 10 });
+     * 
+     * // Chat mesajlarını getir
+     * const messages = await supsis.chat.getMessages('507f1f77bcf86cd799439011');
+     */
+    class Chat extends BaseModule {
+        /**
+         * Bir chat/conversation bilgisini getirir
+         * @param {string} chatId - Chat ID'si (MongoDB ObjectId)
+         * @returns {Promise<ChatResponse>} Chat detayları
+         * @throws {SupsisAPIError} Chat bulunamadığında veya yetki hatası
+         * @example
+         * const chat = await supsis.chat.get('507f1f77bcf86cd799439011');
+         * console.log(chat.status); // "active", "destroyed", "lost", "new"
+         * console.log(chat.visitor); // Contact bilgisi
+         */
+        async get(chatId) {
+            this._validateRequired({ chatId: chatId }, ['chatId']);
+            return await this.http.get('/api/conversations/' + chatId);
+        }
+
+        /**
+         * Chat mesajlarını getirir
+         * @param {string} chatId - Chat ID'si
+         * @param {Object} [options] - Mesaj getirme seçenekleri
+         * @param {number} [options.limit=50] - Maksimum mesaj sayısı
+         * @param {string} [options.before] - Bu ID'den önceki mesajları getir
+         * @returns {Promise<MessageResponse[]>} Mesaj listesi
+         * @example
+         * const messages = await supsis.chat.getMessages('chatId', { limit: 100 });
+         */
+        async getMessages(chatId, options) {
+            this._validateRequired({ chatId: chatId }, ['chatId']);
+            options = options || {};
+            return await this.http.get('/api/conversations/' + chatId + '/messages', {
+                query: this._cleanObject({
+                    limit: options.limit,
+                    before: options.before
+                })
+            });
+        }
+
+        /**
+         * Chat mesaj geçmişini getirir (v2 - gelişmiş)
+         * @param {string} chatId - Chat ID'si
+         * @param {Object} [options] - Seçenekler
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=50] - Sayfa başına mesaj sayısı
+         * @returns {Promise<{messages: MessageResponse[], total: number, page: number}>}
+         */
+        async getMessageHistory(chatId, options) {
+            this._validateRequired({ chatId: chatId }, ['chatId']);
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.get('/api/conversations/' + chatId + '/v2-message-history', {
+                query: {
+                    page: pagination.page,
+                    limit: pagination.limit
+                }
+            });
+        }
+
+        /**
+         * Chat geçmişini listeler (filtreleme destekli)
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {string} [options.status] - Chat durumu: 'active', 'destroyed', 'lost', 'new', 'chatbot'
+         * @param {string} [options.channel] - Kanal ID'si
+         * @param {string} [options.userId] - Temsilci ID'si
+         * @param {string} [options.visitorId] - Contact/Visitor ID'si
+         * @param {Date|string} [options.startDate] - Başlangıç tarihi
+         * @param {Date|string} [options.endDate] - Bitiş tarihi
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt sayısı
+         * @returns {Promise<{data: ChatResponse[], total: number, page: number}>}
+         * @example
+         * // Aktif chatları listele
+         * const activeChats = await supsis.chat.list({ status: 'active' });
+         * 
+         * // Belirli bir kanalın chatlarını getir
+         * const whatsappChats = await supsis.chat.list({ 
+         *   channel: 'channelId',
+         *   startDate: '2024-01-01',
+         *   endDate: '2024-01-31'
+         * });
+         */
+        async list(options) {
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.get('/api/conversations/history', {
+                query: this._cleanObject({
+                    status: options.status,
+                    channel: options.channel,
+                    userId: options.userId,
+                    visitorId: options.visitorId,
+                    startDate: this._toISODate(options.startDate),
+                    endDate: this._toISODate(options.endDate),
+                    page: pagination.page,
+                    limit: pagination.limit
+                })
+            });
+        }
+
+        /**
+         * Realtime chat istatistiklerini getirir
+         * @returns {Promise<ChatStatistics>} Anlık chat istatistikleri
+         * @example
+         * const stats = await supsis.chat.getStats();
+         * console.log(stats.activeChats); // Aktif chat sayısı
+         * console.log(stats.waitingChats); // Bekleyen chat sayısı
+         */
+        async getStats() {
+            return await this.http.get('/api/conversations/conversation-stat-realtime');
+        }
+
+        /**
+         * Chat'e not ekler
+         * @param {string} chatId - Chat ID'si
+         * @param {string} note - Not içeriği
+         * @returns {Promise<ChatResponse>} Güncellenmiş chat
+         * @example
+         * await supsis.chat.addNote('chatId', 'Müşteri geri aranacak');
+         */
+        async addNote(chatId, note) {
+            this._validateRequired({ chatId: chatId, note: note }, ['chatId', 'note']);
+            return await this.http.post('/api/conversations/' + chatId + '/note', {
+                note: note
+            });
+        }
+
+        /**
+         * Chat etiketlerini günceller
+         * @param {string} chatId - Chat ID'si
+         * @param {string[]} tagIds - Etiket ID'leri
+         * @returns {Promise<ChatResponse>} Güncellenmiş chat
+         * @example
+         * await supsis.chat.updateTags('chatId', ['tagId1', 'tagId2']);
+         */
+        async updateTags(chatId, tagIds) {
+            this._validateRequired({ chatId: chatId }, ['chatId']);
+            return await this.http.post('/api/conversations/' + chatId + '/tags', {
+                tags: tagIds || []
+            });
+        }
+
+        /**
+         * Chat'i puanlar (müşteri değerlendirmesi)
+         * @param {string} chatId - Chat ID'si
+         * @param {number} rating - Puan (1-5)
+         * @param {string} [comment] - Yorum
+         * @returns {Promise<ChatResponse>} Güncellenmiş chat
+         * @example
+         * await supsis.chat.rate('chatId', 5, 'Harika hizmet!');
+         */
+        async rate(chatId, rating, comment) {
+            this._validateRequired({ chatId: chatId, rating: rating }, ['chatId', 'rating']);
+            return await this.http.post('/api/conversations/' + chatId + '/rate', {
+                point: rating,
+                description: comment
+            });
+        }
+
+        /**
+         * Chat transcript'ini email ile gönderir
+         * @param {string} chatId - Chat ID'si
+         * @param {string} email - Alıcı email adresi
+         * @returns {Promise<{success: boolean}>}
+         */
+        async sendTranscript(chatId, email) {
+            this._validateRequired({ chatId: chatId, email: email }, ['chatId', 'email']);
+            return await this.http.get('/api/conversations/' + chatId + '/sendTranscript', {
+                query: { email: email }
+            });
+        }
+
+        /**
+         * Chat'i sonlandırır (destroy)
+         * @param {string} chatId - Chat ID'si
+         * @returns {Promise<ChatResponse>} Sonlandırılmış chat
+         */
+        async destroy(chatId) {
+            this._validateRequired({ chatId: chatId }, ['chatId']);
+            return await this.http.post('/api/conversations/' + chatId + '/destroy');
+        }
+
+        /**
+         * Belirli bir kullanıcının chatlarını getirir
+         * @param {string} userId - Kullanıcı ID'si
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @returns {Promise<ChatResponse[]>} Chat listesi
+         */
+        async getByUser(userId, options) {
+            this._validateRequired({ userId: userId }, ['userId']);
+            options = options || {};
+            return await this.http.get('/api/conversations/user/' + userId, {
+                query: this._cleanObject(options)
+            });
+        }
+
+        /**
+         * WhatsApp contact listesini getirir
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @returns {Promise<ContactListResponse>} Contact listesi
+         */
+        async getWhatsAppContactList(options) {
+            options = options || {};
+            return await this.http.get('/api/conversations/contact-list/whatsapp', {
+                query: this._cleanObject(options)
+            });
+        }
+
+        /**
+         * Kanal bazlı contact listesini getirir
+         * @param {string} channelId - Kanal ID'si
+         * @param {Object} [options] - Pagination seçenekleri
+         * @returns {Promise<ContactListResponse>}
+         */
+        async getContactListByChannel(channelId, options) {
+            this._validateRequired({ channelId: channelId }, ['channelId']);
+            options = options || {};
+            return await this.http.get('/api/conversations/contact-list-by-channels', {
+                query: this._cleanObject({
+                    channels: channelId,
+                    page: options.page,
+                    limit: options.limit
+                })
+            });
+        }
+
+        /**
+         * Son mesajları toplu getirir
+         * @param {string[]} chatIds - Chat ID'leri
+         * @returns {Promise<Object>} Chat ID -> Son mesaj mapping
+         */
+        async getLastMessages(chatIds) {
+            this._validateRequired({ chatIds: chatIds }, ['chatIds']);
+            return await this.http.post('/api/conversations/last-messages', {
+                conversationIds: chatIds
+            });
+        }
+
+        /**
+         * Tek bir alanı günceller
+         * @param {string} chatId - Chat ID'si
+         * @param {string} key - Alan adı
+         * @param {*} value - Yeni değer
+         * @returns {Promise<ChatResponse>}
+         */
+        async updateField(chatId, key, value) {
+            this._validateRequired({ chatId: chatId, key: key }, ['chatId', 'key']);
+            return await this.http.put('/api/conversations/' + chatId + '/update-single-key', {
+                key: key,
+                value: value
+            });
+        }
+    }
+
+    /**
+     * @typedef {Object} ChatResponse
+     * @property {string} _id - Chat ID
+     * @property {string} siteId - Site ID
+     * @property {string} status - Chat durumu: 'new', 'active', 'lost', 'destroyed', 'chatbot', 'private'
+     * @property {Object} visitor - Contact/Visitor bilgisi
+     * @property {string[]} users - Bağlı temsilci ID'leri
+     * @property {string} [channel] - Kanal ID
+     * @property {string} [ref] - Referans: 'whatsapp', 'instagram', 'telegram', 'web', 'messenger'
+     * @property {Date} createdDate - Oluşturulma tarihi
+     * @property {Date} [destroyedDate] - Sonlandırılma tarihi
+     * @property {number} [point] - Müşteri puanı (1-5)
+     * @property {string} [description] - Müşteri yorumu
+     * @property {Object} [note] - Temsilci notu
+     * @property {string[]} [tags] - Etiket ID'leri
+     * @property {string} [handledBy] - İşleme alan: 'chatbot', 'live', 'hybrid', 'none'
+     * @property {number} [avgResponseTime] - Ortalama yanıt süresi (ms)
+     * @property {number} [firstAgentResponseTime] - İlk temsilci yanıt süresi (ms)
+     */
+
+    /**
+     * @typedef {Object} ChatStatistics
+     * @property {number} activeChats - Aktif chat sayısı
+     * @property {number} waitingChats - Bekleyen chat sayısı
+     * @property {number} lostChats - Kayıp chat sayısı
+     * @property {number} totalChats - Toplam chat sayısı
+     */
+
+    /**
+     * Contact (Visitor) modülü
+     * Müşteri/ziyaretçi verilerini yönetir
+     * 
+     * @class Contact
+     * @extends BaseModule
+     * @example
+     * // Bir contact'ı getir
+     * const contact = await supsis.contact.get('507f1f77bcf86cd799439011');
+     * 
+     * // Contact ara
+     * const results = await supsis.contact.search({ email: 'user@example.com' });
+     * 
+     * // Contact güncelle
+     * await supsis.contact.update('contactId', { fullname: 'John Doe' });
+     */
+    class Contact extends BaseModule {
+        /**
+         * Bir contact/visitor bilgisini getirir
+         * @param {string} contactId - Contact ID'si (MongoDB ObjectId)
+         * @returns {Promise<ContactResponse>} Contact detayları
+         * @throws {SupsisAPIError} Contact bulunamadığında
+         * @example
+         * const contact = await supsis.contact.get('507f1f77bcf86cd799439011');
+         * console.log(contact.fullname);
+         * console.log(contact.email);
+         * console.log(contact.phone);
+         */
+        async get(contactId) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.get('/api/visitors/' + contactId);
+        }
+
+        /**
+         * Contact listesini getirir
+         * @param {Object} [options] - Filtreleme ve pagination seçenekleri
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt sayısı
+         * @param {string} [options.search] - Arama terimi
+         * @param {string} [options.owner] - Sahip (temsilci) ID'si
+         * @param {string[]} [options.tags] - Etiket ID'leri
+         * @param {string} [options.channel] - Kanal ID'si
+         * @returns {Promise<{data: ContactResponse[], total: number}>}
+         * @example
+         * const contacts = await supsis.contact.list({ limit: 50, owner: 'userId' });
+         */
+        async list(options) {
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/visitors/visitor-list', {
+                page: pagination.page,
+                limit: pagination.limit,
+                search: options.search,
+                owner: options.owner,
+                tags: options.tags,
+                channel: options.channel
+            });
+        }
+
+        /**
+         * Contact arar
+         * @param {Object} filters - Arama filtreleri
+         * @param {string} [filters.email] - Email adresi
+         * @param {string} [filters.phone] - Telefon numarası
+         * @param {string} [filters.fullname] - İsim
+         * @param {string} [filters.query] - Genel arama terimi
+         * @param {Object} [options] - Pagination seçenekleri
+         * @returns {Promise<{data: ContactResponse[], total: number}>}
+         * @example
+         * // Email ile ara
+         * const results = await supsis.contact.search({ email: 'user@example.com' });
+         * 
+         * // Telefon ile ara
+         * const results = await supsis.contact.search({ phone: '+905551234567' });
+         */
+        async search(filters, options) {
+            filters = filters || {};
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.get('/api/visitors/search', {
+                query: this._cleanObject({
+                    email: filters.email,
+                    phone: filters.phone,
+                    fullname: filters.fullname,
+                    query: filters.query,
+                    page: pagination.page,
+                    limit: pagination.limit
+                })
+            });
+        }
+
+        /**
+         * Gelişmiş filtre ile contact arar
+         * @param {FilterGroup[]} filterGroups - Filtre grupları
+         * @param {Object} [options] - Pagination seçenekleri
+         * @param {string[]} [projectionFields] - Döndürülecek alanlar
+         * @returns {Promise<{data: ContactResponse[], total: number}>}
+         * @example
+         * const results = await supsis.contact.advancedSearch([
+         *   {
+         *     filters: [
+         *       { field: 'email', operator: 'contains', value: '@gmail.com' },
+         *       { field: 'createdDate', operator: 'after', value: '2024-01-01' }
+         *     ],
+         *     logic: 'and'
+         *   }
+         * ]);
+         */
+        async advancedSearch(filterGroups, options, projectionFields) {
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/visitors/contacts-by-advanced-filter', {
+                filterGroups: filterGroups,
+                cursor: {
+                    offset: pagination.offset,
+                    limit: pagination.limit
+                },
+                projectionFields: projectionFields
+            });
+        }
+
+        /**
+         * Contact oluşturur
+         * @param {Object} data - Contact verileri
+         * @param {string} data.fullname - İsim
+         * @param {string} [data.email] - Email
+         * @param {string} [data.phone] - Telefon
+         * @param {string} [data.platform] - Platform: 'whatsapp', 'web', 'instagram', etc.
+         * @param {string[]} [data.channelIds] - Kanal ID'leri
+         * @param {Object} [data.contactProperties] - Özel alanlar
+         * @returns {Promise<ContactResponse>} Oluşturulan contact
+         * @example
+         * const contact = await supsis.contact.create({
+         *   fullname: 'John Doe',
+         *   email: 'john@example.com',
+         *   phone: '+905551234567'
+         * });
+         */
+        async create(data) {
+            this._validateRequired(data, ['fullname']);
+            return await this.http.post('/api/visitors/contacts', data);
+        }
+
+        /**
+         * Contact günceller
+         * @param {string} contactId - Contact ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @param {string} [data.fullname] - İsim
+         * @param {string} [data.email] - Email
+         * @param {string} [data.phone] - Telefon
+         * @param {string} [data.owner] - Sahip (temsilci) ID'si
+         * @returns {Promise<ContactResponse>} Güncellenmiş contact
+         * @example
+         * await supsis.contact.update('contactId', {
+         *   fullname: 'Jane Doe',
+         *   email: 'jane@example.com'
+         * });
+         */
+        async update(contactId, data) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.post('/api/visitors/' + contactId + '/update', data);
+        }
+
+        /**
+         * Contact siler
+         * @param {string} contactId - Contact ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(contactId) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.delete('/api/visitors/' + contactId);
+        }
+
+        /**
+         * Birden fazla contact siler
+         * @param {string[]} contactIds - Contact ID'leri
+         * @returns {Promise<{success: boolean, deletedCount: number}>}
+         */
+        async deleteMany(contactIds) {
+            this._validateRequired({ contactIds: contactIds }, ['contactIds']);
+            return await this.http.post('/api/visitors/delete-multi-visitor', {
+                visitorIds: contactIds
+            });
+        }
+
+        /**
+         * Contact'a etiket ekler
+         * @param {string} contactId - Contact ID'si
+         * @param {string} tagId - Etiket ID'si
+         * @returns {Promise<ContactResponse>}
+         * @example
+         * await supsis.contact.addTag('contactId', 'tagId');
+         */
+        async addTag(contactId, tagId) {
+            this._validateRequired({ contactId: contactId, tagId: tagId }, ['contactId', 'tagId']);
+            return await this.http.post('/api/visitors/updateTagVisitor/' + contactId, {
+                tagId: tagId,
+                action: 'add'
+            });
+        }
+
+        /**
+         * Contact'tan etiket kaldırır
+         * @param {string} contactId - Contact ID'si
+         * @param {string} tagId - Etiket ID'si
+         * @returns {Promise<ContactResponse>}
+         */
+        async removeTag(contactId, tagId) {
+            this._validateRequired({ contactId: contactId, tagId: tagId }, ['contactId', 'tagId']);
+            return await this.http.post('/api/visitors/updateTagVisitor/' + contactId, {
+                tagId: tagId,
+                action: 'remove'
+            });
+        }
+
+        /**
+         * Contact'ı engeller
+         * @param {string} contactId - Contact ID'si
+         * @param {string} [reason] - Engelleme nedeni
+         * @returns {Promise<ContactResponse>}
+         */
+        async block(contactId, reason) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.post('/api/visitors/' + contactId + '/block', {
+                reason: reason
+            });
+        }
+
+        /**
+         * Contact engelini kaldırır
+         * @param {string} contactId - Contact ID'si
+         * @returns {Promise<ContactResponse>}
+         */
+        async unblock(contactId) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.post('/api/visitors/' + contactId + '/unblock');
+        }
+
+        /**
+         * Contact'ın sohbet geçmişini getirir
+         * @param {string} contactId - Contact ID'si
+         * @param {Object} [options] - Pagination seçenekleri
+         * @returns {Promise<ChatResponse[]>}
+         */
+        async getChatHistory(contactId, options) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.get('/api/visitors/' + contactId + '/conversations-paged', {
+                query: {
+                    page: pagination.page,
+                    limit: pagination.limit
+                }
+            });
+        }
+
+        /**
+         * Contact notlarını getirir
+         * @param {string} contactId - Contact ID'si
+         * @returns {Promise<NoteResponse[]>}
+         */
+        async getNotes(contactId) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.get('/api/visitors/' + contactId + '/notes-v2');
+        }
+
+        /**
+         * Contact'a not ekler
+         * @param {string} contactId - Contact ID'si
+         * @param {string} content - Not içeriği
+         * @returns {Promise<NoteResponse>}
+         */
+        async addNote(contactId, content) {
+            this._validateRequired({ contactId: contactId, content: content }, ['contactId', 'content']);
+            return await this.http.post('/api/visitors/' + contactId + '/notes-v2', {
+                content: content
+            });
+        }
+
+        /**
+         * Contact notunu günceller
+         * @param {string} contactId - Contact ID'si
+         * @param {string} noteId - Not ID'si
+         * @param {string} content - Yeni not içeriği
+         * @returns {Promise<NoteResponse>}
+         */
+        async updateNote(contactId, noteId, content) {
+            this._validateRequired({ contactId: contactId, noteId: noteId, content: content }, ['contactId', 'noteId', 'content']);
+            return await this.http.post('/api/visitors/' + contactId + '/notes-v2/' + noteId, {
+                content: content
+            });
+        }
+
+        /**
+         * Contact notunu siler
+         * @param {string} noteId - Not ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteNote(noteId) {
+            this._validateRequired({ noteId: noteId }, ['noteId']);
+            return await this.http.delete('/api/visitors/notes-v2/' + noteId);
+        }
+
+        /**
+         * Contact property günceller
+         * @param {string} contactId - Contact ID'si
+         * @param {string} propertyId - Property ID'si
+         * @param {*} value - Yeni değer
+         * @returns {Promise<ContactResponse>}
+         */
+        async updateProperty(contactId, propertyId, value) {
+            this._validateRequired({ contactId: contactId, propertyId: propertyId }, ['contactId', 'propertyId']);
+            return await this.http.put('/api/visitors/' + contactId + '/contact-property/' + propertyId, {
+                value: value
+            });
+        }
+
+        /**
+         * Contact sahipliğini değiştirir
+         * @param {string} contactId - Contact ID'si
+         * @param {string} ownerId - Yeni sahip (temsilci) ID'si
+         * @returns {Promise<ContactResponse>}
+         */
+        async changeOwner(contactId, ownerId) {
+            this._validateRequired({ contactId: contactId, ownerId: ownerId }, ['contactId', 'ownerId']);
+            return await this.http.post('/api/visitors/' + contactId + '/update', {
+                owner: ownerId
+            });
+        }
+
+        /**
+         * Contact'ların tercih edilen temsilcilerini günceller
+         * @param {string} contactId - Contact ID'si
+         * @param {string[]} agentIds - Temsilci ID'leri
+         * @returns {Promise<ContactResponse>}
+         */
+        async updatePreferredAgents(contactId, agentIds) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.post('/api/visitors/' + contactId + '/update-preferred-agents', {
+                agents: agentIds || []
+            });
+        }
+
+        /**
+         * Contact'ın medya dosyalarını getirir
+         * @param {string} contactId - Contact ID'si
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @returns {Promise<AssetResponse[]>}
+         */
+        async getMedia(contactId, options) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.get('/api/visitors/' + contactId + '/media', {
+                query: this._cleanObject(options)
+            });
+        }
+
+        /**
+         * İki contact'ı birleştirir
+         * @param {string} primaryContactId - Ana contact ID'si (korunacak)
+         * @param {string} secondaryContactId - İkincil contact ID'si (birleştirilecek)
+         * @returns {Promise<ContactResponse>} Birleştirilmiş contact
+         */
+        async merge(primaryContactId, secondaryContactId) {
+            this._validateRequired({ 
+                primaryContactId: primaryContactId, 
+                secondaryContactId: secondaryContactId 
+            }, ['primaryContactId', 'secondaryContactId']);
+            
+            return await this.http.post('/api/visitors/merge-visitors', {
+                primaryVisitorId: primaryContactId,
+                secondaryVisitorId: secondaryContactId
+            });
+        }
+
+        /**
+         * Contact listesini Excel olarak indirir
+         * @param {Object} [filters] - Filtreleme seçenekleri
+         * @returns {Promise<Blob>} Excel dosyası
+         */
+        async downloadExcel(filters) {
+            return await this.http.post('/api/visitors/visitor-list/download', filters || {});
+        }
+    }
+
+    /**
+     * @typedef {Object} ContactResponse
+     * @property {string} _id - Contact ID
+     * @property {string} siteId - Site ID
+     * @property {string} [fullname] - İsim
+     * @property {string} [email] - Email adresi
+     * @property {string} [phone] - Telefon numarası
+     * @property {string} [owner] - Sahip (temsilci) ID
+     * @property {string[]} [tags] - Etiket ID'leri
+     * @property {string} [platform] - Platform: 'whatsapp', 'web', 'instagram', etc.
+     * @property {Object} [contactProperties] - Özel alanlar
+     * @property {string} [status] - Durum: 'online', 'offline', 'blocked'
+     * @property {Date} createdDate - Oluşturulma tarihi
+     * @property {Date} [lastSeenDate] - Son görülme tarihi
+     * @property {Object} [lastConversation] - Son sohbet bilgisi
+     * @property {string} [whatsappNumber] - WhatsApp numarası
+     * @property {string} [instagramUserId] - Instagram kullanıcı ID'si
+     * @property {Object} [geoLocation] - Konum bilgisi
+     */
+
+    /**
+     * @typedef {Object} NoteResponse
+     * @property {string} _id - Not ID
+     * @property {string} content - Not içeriği
+     * @property {string} createdBy - Oluşturan kullanıcı ID
+     * @property {Date} createdAt - Oluşturulma tarihi
+     * @property {Date} [updatedAt] - Güncellenme tarihi
+     */
+
+    /**
+     * @typedef {Object} FilterGroup
+     * @property {Filter[]} filters - Filtreler
+     * @property {'and'|'or'} logic - Mantıksal operatör
+     */
+
+    /**
+     * @typedef {Object} Filter
+     * @property {string} field - Alan adı
+     * @property {string} operator - Operatör: 'equals', 'contains', 'startsWith', 'after', 'before', etc.
+     * @property {*} value - Değer
+     */
+
+    /**
+     * Message modülü
+     * Sohbet mesajlarını yönetir
+     * 
+     * @class Message
+     * @extends BaseModule
+     * @example
+     * // Mesajları getir
+     * const messages = await supsis.message.list('conversationId');
+     * 
+     * // Mesaj ara
+     * const results = await supsis.message.search({ query: 'sipariş' });
+     */
+    class Message extends BaseModule {
+        /**
+         * Bir mesajı ID'ye göre getirir
+         * @param {string} messageId - Mesaj ID'si
+         * @returns {Promise<MessageResponse>} Mesaj detayları
+         * @example
+         * const message = await supsis.message.get('messageId');
+         * console.log(message.message); // Mesaj içeriği
+         * console.log(message.senderType); // 'visitor' veya 'user'
+         */
+        async get(messageId) {
+            this._validateRequired({ messageId: messageId }, ['messageId']);
+            return await this.http.post('/api/messages/get-message', {
+                messageId: messageId
+            });
+        }
+
+        /**
+         * Bir sohbetteki mesajları listeler
+         * @param {string} conversationId - Sohbet ID'si
+         * @param {Object} [options] - Listeleme seçenekleri
+         * @param {number} [options.limit=50] - Maksimum mesaj sayısı
+         * @param {string} [options.before] - Bu ID'den önceki mesajları getir
+         * @param {string} [options.after] - Bu ID'den sonraki mesajları getir
+         * @returns {Promise<MessageResponse[]>} Mesaj listesi
+         * @example
+         * const messages = await supsis.message.list('conversationId', { limit: 100 });
+         */
+        async list(conversationId, options) {
+            this._validateRequired({ conversationId: conversationId }, ['conversationId']);
+            options = options || {};
+            
+            return await this.http.get('/api/messages/' + conversationId, {
+                query: this._cleanObject({
+                    limit: options.limit,
+                    before: options.before,
+                    after: options.after
+                })
+            });
+        }
+
+        /**
+         * Mesajlarda arama yapar
+         * @param {Object} options - Arama seçenekleri
+         * @param {string} options.query - Arama terimi
+         * @param {string} [options.conversationId] - Belirli bir sohbette ara
+         * @param {string} [options.visitorId] - Belirli bir contact'ın mesajlarında ara
+         * @param {string} [options.userId] - Belirli bir temsilcinin mesajlarında ara
+         * @param {Date|string} [options.startDate] - Başlangıç tarihi
+         * @param {Date|string} [options.endDate] - Bitiş tarihi
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına sonuç sayısı
+         * @returns {Promise<{data: MessageResponse[], total: number}>}
+         * @example
+         * // Genel arama
+         * const results = await supsis.message.search({ query: 'sipariş numarası' });
+         * 
+         * // Belirli bir sohbette arama
+         * const results = await supsis.message.search({ 
+         *   query: 'fatura',
+         *   conversationId: 'chatId',
+         *   startDate: '2024-01-01'
+         * });
+         */
+        async search(options) {
+            this._validateRequired(options, ['query']);
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/messages/search-messages', {
+                query: options.query,
+                conversationId: options.conversationId,
+                visitorId: options.visitorId,
+                userId: options.userId,
+                startDate: this._toISODate(options.startDate),
+                endDate: this._toISODate(options.endDate),
+                page: pagination.page,
+                limit: pagination.limit
+            });
+        }
+
+        /**
+         * Birden fazla mesajı ID'lere göre getirir
+         * @param {string[]} messageIds - Mesaj ID'leri
+         * @returns {Promise<MessageResponse[]>}
+         */
+        async getMany(messageIds) {
+            this._validateRequired({ messageIds: messageIds }, ['messageIds']);
+            return await this.http.post('/api/messages/get-message', {
+                messageIds: messageIds
+            });
+        }
+    }
+
+    /**
+     * @typedef {Object} MessageResponse
+     * @property {string} _id - Mesaj ID
+     * @property {string} siteId - Site ID
+     * @property {string} conversationId - Sohbet ID
+     * @property {string} message - Mesaj içeriği
+     * @property {string} senderType - Gönderen tipi: 'visitor', 'user', 'system', 'chatbot'
+     * @property {string} [senderId] - Gönderen ID (user veya visitor)
+     * @property {string} messageType - Mesaj tipi: 'text', 'image', 'file', 'audio', 'video', 'location', 'template'
+     * @property {Date} createdDate - Gönderilme tarihi
+     * @property {Object} [asset] - Dosya/medya bilgisi
+     * @property {Object} [location] - Konum bilgisi (lat, lng)
+     * @property {boolean} [isRead] - Okundu mu
+     * @property {Date} [readDate] - Okunma tarihi
+     * @property {string} [status] - Durum: 'sent', 'delivered', 'read', 'failed'
+     * @property {Object} [replyTo] - Yanıtlanan mesaj bilgisi
+     * @property {Object} [metadata] - Ek metadata
+     * @property {string} [externalProviderId] - Harici sağlayıcı mesaj ID'si (WhatsApp, Instagram vb.)
+     * @property {string} [gupshupMessageId] - Gupshup mesaj ID'si
+     * @property {string} [metaMessageId] - Meta (WhatsApp/Instagram) mesaj ID'si
+     */
+
+    /**
+     * Task modülü
+     * Görev ve iş akışı yönetimi
+     * 
+     * @class Task
+     * @extends BaseModule
+     * @example
+     * // Görev oluştur
+     * const task = await supsis.task.create({
+     *   title: 'Müşteriyi ara',
+     *   workflowId: 'workflowId',
+     *   pipelineId: 'pipelineId'
+     * });
+     * 
+     * // Görevleri listele
+     * const tasks = await supsis.task.list('workflowId');
+     */
+    class Task extends BaseModule {
+        /**
+         * Bir görevi ID'ye göre getirir
+         * @param {string} taskId - Görev ID'si
+         * @returns {Promise<TaskResponse>} Görev detayları
+         * @example
+         * const task = await supsis.task.get('taskId');
+         * console.log(task.title);
+         * console.log(task.status); // 'open', 'done', 'archived'
+         */
+        async get(taskId) {
+            this._validateRequired({ taskId: taskId }, ['taskId']);
+            return await this.http.get('/api/tasks/' + taskId + '/detail');
+        }
+
+        /**
+         * Bir iş akışındaki görevleri listeler
+         * @param {string} workflowId - İş akışı ID'si
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {string} [options.pipelineId] - Pipeline/aşama ID'si
+         * @param {string} [options.assignee] - Atanan kişi ID'si
+         * @param {string} [options.status] - Durum filtresi
+         * @returns {Promise<TaskResponse[]>}
+         * @example
+         * const tasks = await supsis.task.list('workflowId');
+         * const pipelineTasks = await supsis.task.list('workflowId', { pipelineId: 'pipelineId' });
+         */
+        async list(workflowId, options) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            options = options || {};
+            
+            if (options.pipelineId) {
+                return await this.http.get('/api/tasks/' + workflowId + '/' + options.pipelineId);
+            }
+            return await this.http.get('/api/tasks/' + workflowId);
+        }
+
+        /**
+         * Görev oluşturur
+         * @param {Object} data - Görev verileri
+         * @param {string} data.title - Görev başlığı
+         * @param {string} data.workflowId - İş akışı ID'si
+         * @param {string} data.pipelineId - Pipeline/aşama ID'si
+         * @param {string} [data.description] - Açıklama
+         * @param {string} [data.assignee] - Atanan kişi ID'si
+         * @param {Date|string} [data.dueDate] - Bitiş tarihi
+         * @param {string} [data.priority] - Öncelik: 'low', 'medium', 'high', 'urgent'
+         * @param {string} [data.contactId] - İlişkili contact ID'si
+         * @param {Object} [data.customFields] - Özel alanlar
+         * @returns {Promise<TaskResponse>} Oluşturulan görev
+         * @example
+         * const task = await supsis.task.create({
+         *   title: 'Müşteriyi ara',
+         *   workflowId: 'workflowId',
+         *   pipelineId: 'pipelineId',
+         *   assignee: 'userId',
+         *   dueDate: '2024-12-31',
+         *   priority: 'high',
+         *   contactId: 'contactId'
+         * });
+         */
+        async create(data) {
+            this._validateRequired(data, ['title', 'workflowId', 'pipelineId']);
+            
+            return await this.http.post('/api/tasks', {
+                title: data.title,
+                workflowId: data.workflowId,
+                pipelineId: data.pipelineId,
+                description: data.description,
+                assignee: data.assignee,
+                dueDate: this._toISODate(data.dueDate),
+                priority: data.priority,
+                contactId: data.contactId,
+                customFields: data.customFields
+            });
+        }
+
+        /**
+         * Basit görev oluşturur (minimal verilerle)
+         * @param {Object} data - Görev verileri
+         * @param {string} data.title - Görev başlığı
+         * @param {string} data.workflowId - İş akışı ID'si
+         * @param {string} data.pipelineId - Pipeline/aşama ID'si
+         * @returns {Promise<TaskResponse>}
+         */
+        async createSimple(data) {
+            this._validateRequired(data, ['title', 'workflowId', 'pipelineId']);
+            return await this.http.post('/api/tasks/simple', data);
+        }
+
+        /**
+         * Görevi günceller
+         * @param {string} taskId - Görev ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<TaskResponse>}
+         * @example
+         * await supsis.task.update('taskId', {
+         *   title: 'Yeni başlık',
+         *   priority: 'urgent'
+         * });
+         */
+        async update(taskId, data) {
+            this._validateRequired({ taskId: taskId }, ['taskId']);
+            return await this.http.patch('/api/tasks/' + taskId, data);
+        }
+
+        /**
+         * Görevi siler
+         * @param {string} taskId - Görev ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(taskId) {
+            this._validateRequired({ taskId: taskId }, ['taskId']);
+            return await this.http.delete('/api/tasks/' + taskId);
+        }
+
+        /**
+         * Görevi başka bir aşamaya taşır
+         * @param {string} taskId - Görev ID'si
+         * @param {string} pipelineId - Hedef pipeline/aşama ID'si
+         * @param {number} [position] - Yeni pozisyon (sıra)
+         * @returns {Promise<TaskResponse>}
+         * @example
+         * await supsis.task.move('taskId', 'newPipelineId');
+         */
+        async move(taskId, pipelineId, position) {
+            this._validateRequired({ taskId: taskId, pipelineId: pipelineId }, ['taskId', 'pipelineId']);
+            return await this.http.patch('/api/tasks/' + taskId + '/position', {
+                pipelineId: pipelineId,
+                position: position
+            });
+        }
+
+        /**
+         * Görevi tamamlandı olarak işaretler
+         * @param {string} taskId - Görev ID'si
+         * @returns {Promise<TaskResponse>}
+         */
+        async complete(taskId) {
+            this._validateRequired({ taskId: taskId }, ['taskId']);
+            return await this.http.patch('/api/tasks/' + taskId + '/done');
+        }
+
+        /**
+         * Görevi arşivler
+         * @param {string} taskId - Görev ID'si
+         * @returns {Promise<TaskResponse>}
+         */
+        async archive(taskId) {
+            this._validateRequired({ taskId: taskId }, ['taskId']);
+            return await this.http.patch('/api/tasks/' + taskId + '/archive');
+        }
+
+        /**
+         * Birden fazla görevi siler
+         * @param {string[]} taskIds - Görev ID'leri
+         * @returns {Promise<{success: boolean, deletedCount: number}>}
+         */
+        async deleteMany(taskIds) {
+            this._validateRequired({ taskIds: taskIds }, ['taskIds']);
+            return await this.http.post('/api/tasks/multiple/delete', {
+                taskIds: taskIds
+            });
+        }
+
+        /**
+         * Birden fazla görevi taşır
+         * @param {string[]} taskIds - Görev ID'leri
+         * @param {string} pipelineId - Hedef pipeline ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async moveMany(taskIds, pipelineId) {
+            this._validateRequired({ taskIds: taskIds, pipelineId: pipelineId }, ['taskIds', 'pipelineId']);
+            return await this.http.post('/api/tasks/multiple/change-pipeline', {
+                taskIds: taskIds,
+                pipelineId: pipelineId
+            });
+        }
+
+        /**
+         * Birden fazla görevi tamamlar
+         * @param {string[]} taskIds - Görev ID'leri
+         * @returns {Promise<{success: boolean}>}
+         */
+        async completeMany(taskIds) {
+            this._validateRequired({ taskIds: taskIds }, ['taskIds']);
+            return await this.http.post('/api/tasks/multiple/done', {
+                taskIds: taskIds
+            });
+        }
+
+        /**
+         * Görev aktivitelerini getirir
+         * @param {string} taskId - Görev ID'si
+         * @returns {Promise<ActivityResponse[]>}
+         */
+        async getActivities(taskId) {
+            this._validateRequired({ taskId: taskId }, ['taskId']);
+            return await this.http.get('/api/tasks/get-task-activity/' + taskId);
+        }
+
+        /**
+         * Tamamlanmış görevleri listeler
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @returns {Promise<TaskResponse[]>}
+         */
+        async listCompleted(options) {
+            return await this.http.get('/api/tasks/done-tasks', {
+                query: this._cleanObject(options)
+            });
+        }
+
+        /**
+         * Arşivlenmiş görevleri listeler
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @returns {Promise<TaskResponse[]>}
+         */
+        async listArchived(options) {
+            return await this.http.get('/api/tasks/archive-tasks', {
+                query: this._cleanObject(options)
+            });
+        }
+
+        /**
+         * Tarihe göre görev listesi getirir (takvim görünümü için)
+         * @param {Date|string} date - Tarih
+         * @returns {Promise<TaskResponse[]>}
+         */
+        async listByDate(date) {
+            this._validateRequired({ date: date }, ['date']);
+            return await this.http.get('/api/tasks/get-event-list-by-date', {
+                query: {
+                    date: this._toISODate(date)
+                }
+            });
+        }
+
+        /**
+         * Belirli bir contact'ın görevlerini listeler
+         * @param {string} contactId - Contact ID'si
+         * @returns {Promise<TaskResponse[]>}
+         */
+        async listByContact(contactId) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.get('/api/tasks/visitor-tasks', {
+                query: { visitorId: contactId }
+            });
+        }
+
+        // ==================== WORKFLOW METHODS ====================
+
+        /**
+         * Tüm iş akışlarını listeler
+         * @returns {Promise<WorkflowResponse[]>}
+         * @example
+         * const workflows = await supsis.task.listWorkflows();
+         */
+        async listWorkflows() {
+            return await this.http.get('/api/tasks/workflows');
+        }
+
+        /**
+         * Bir iş akışını getirir
+         * @param {string} workflowId - İş akışı ID'si
+         * @returns {Promise<WorkflowResponse>}
+         */
+        async getWorkflow(workflowId) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            return await this.http.get('/api/tasks/workflows/' + workflowId);
+        }
+
+        /**
+         * İş akışı oluşturur
+         * @param {Object} data - İş akışı verileri
+         * @param {string} data.name - İş akışı adı
+         * @param {string} [data.description] - Açıklama
+         * @param {string} [data.color] - Renk kodu
+         * @returns {Promise<WorkflowResponse>}
+         */
+        async createWorkflow(data) {
+            this._validateRequired(data, ['name']);
+            return await this.http.post('/api/tasks/workflows', data);
+        }
+
+        /**
+         * İş akışını günceller
+         * @param {string} workflowId - İş akışı ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<WorkflowResponse>}
+         */
+        async updateWorkflow(workflowId, data) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            return await this.http.patch('/api/tasks/workflows/' + workflowId, data);
+        }
+
+        /**
+         * İş akışını siler
+         * @param {string} workflowId - İş akışı ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteWorkflow(workflowId) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            return await this.http.delete('/api/tasks/workflows/' + workflowId);
+        }
+
+        /**
+         * İş akışı ile birlikte tüm pipeline ve görevleri getirir
+         * @param {string} workflowId - İş akışı ID'si
+         * @returns {Promise<WorkflowFullResponse>}
+         */
+        async getWorkflowFull(workflowId) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            return await this.http.get('/api/tasks/workflows/' + workflowId + '/full');
+        }
+
+        /**
+         * İş akışı raporlarını getirir
+         * @param {string} workflowId - İş akışı ID'si
+         * @returns {Promise<WorkflowReportResponse>}
+         */
+        async getWorkflowReports(workflowId) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            return await this.http.get('/api/tasks/workflows/' + workflowId + '/reports');
+        }
+
+        // ==================== PIPELINE METHODS ====================
+
+        /**
+         * Bir iş akışının pipeline'larını listeler
+         * @param {string} workflowId - İş akışı ID'si
+         * @returns {Promise<PipelineResponse[]>}
+         */
+        async listPipelines(workflowId) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            return await this.http.get('/api/tasks/workflows/' + workflowId + '/pipelines');
+        }
+
+        /**
+         * Pipeline/aşama oluşturur
+         * @param {string} workflowId - İş akışı ID'si
+         * @param {Object} data - Pipeline verileri
+         * @param {string} data.name - Pipeline adı
+         * @param {string} [data.color] - Renk kodu
+         * @param {number} [data.position] - Sıra
+         * @returns {Promise<PipelineResponse>}
+         */
+        async createPipeline(workflowId, data) {
+            this._validateRequired({ workflowId: workflowId }, ['workflowId']);
+            this._validateRequired(data, ['name']);
+            return await this.http.post('/api/tasks/workflows/' + workflowId + '/pipelines', data);
+        }
+
+        /**
+         * Pipeline günceller
+         * @param {string} pipelineId - Pipeline ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<PipelineResponse>}
+         */
+        async updatePipeline(pipelineId, data) {
+            this._validateRequired({ pipelineId: pipelineId }, ['pipelineId']);
+            return await this.http.patch('/api/tasks/pipelines/' + pipelineId, data);
+        }
+
+        /**
+         * Pipeline siler
+         * @param {string} pipelineId - Pipeline ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deletePipeline(pipelineId) {
+            this._validateRequired({ pipelineId: pipelineId }, ['pipelineId']);
+            return await this.http.delete('/api/tasks/pipelines/' + pipelineId);
+        }
+
+        /**
+         * Pipeline pozisyonunu günceller
+         * @param {string} workflowId - İş akışı ID'si
+         * @param {string} pipelineId - Pipeline ID'si
+         * @param {number} position - Yeni pozisyon
+         * @returns {Promise<PipelineResponse>}
+         */
+        async updatePipelinePosition(workflowId, pipelineId, position) {
+            this._validateRequired({ workflowId: workflowId, pipelineId: pipelineId }, ['workflowId', 'pipelineId']);
+            return await this.http.patch('/api/tasks/' + workflowId + '/' + pipelineId + '/position', {
+                position: position
+            });
+        }
+    }
+
+    /**
+     * @typedef {Object} TaskResponse
+     * @property {string} _id - Görev ID
+     * @property {string} siteId - Site ID
+     * @property {string} title - Başlık
+     * @property {string} [description] - Açıklama
+     * @property {string} workflowId - İş akışı ID
+     * @property {string} pipelineId - Pipeline/aşama ID
+     * @property {string} [assignee] - Atanan kişi ID
+     * @property {string} [contactId] - İlişkili contact ID
+     * @property {string} status - Durum: 'open', 'done', 'archived'
+     * @property {string} [priority] - Öncelik: 'low', 'medium', 'high', 'urgent'
+     * @property {Date} [dueDate] - Bitiş tarihi
+     * @property {Date} createdAt - Oluşturulma tarihi
+     * @property {Date} [completedAt] - Tamamlanma tarihi
+     * @property {Object} [customFields] - Özel alanlar
+     * @property {number} [position] - Sıra
+     */
+
+    /**
+     * @typedef {Object} WorkflowResponse
+     * @property {string} _id - İş akışı ID
+     * @property {string} siteId - Site ID
+     * @property {string} name - İş akışı adı
+     * @property {string} [description] - Açıklama
+     * @property {string} [color] - Renk kodu
+     * @property {Date} createdAt - Oluşturulma tarihi
+     */
+
+    /**
+     * @typedef {Object} PipelineResponse
+     * @property {string} _id - Pipeline ID
+     * @property {string} name - Pipeline adı
+     * @property {string} [color] - Renk kodu
+     * @property {number} position - Sıra
+     * @property {string} workflowId - İş akışı ID
+     */
+
+    /**
+     * @typedef {Object} WorkflowFullResponse
+     * @property {WorkflowResponse} workflow - İş akışı bilgisi
+     * @property {PipelineResponse[]} pipelines - Pipeline listesi
+     * @property {Object} tasksByPipeline - Pipeline ID -> Task[] mapping
+     */
+
+    /**
+     * AICall modülü
+     * Yapay zeka destekli sesli arama (Voice Agent) işlemleri
+     * 
+     * @class AICall
+     * @extends BaseModule
+     * @example
+     * // Arama başlat
+     * const call = await supsis.aicall.makeCall({
+     *   agentId: 'agentId',
+     *   toNumber: '+905551234567',
+     *   fromNumber: '+908501234567'
+     * });
+     * 
+     * // Arama detayını getir
+     * const callDetails = await supsis.aicall.getCall('callId');
+     */
+    class AICall extends BaseModule {
+        /**
+         * Telefon araması başlatır
+         * @param {Object} options - Arama seçenekleri
+         * @param {string} options.agentId - AI Agent ID'si
+         * @param {string} options.toNumber - Aranacak telefon numarası
+         * @param {string} options.fromNumber - Arayan telefon numarası
+         * @param {Object} [options.variables] - Dinamik değişkenler (LLM için)
+         * @param {Object} [options.metadata] - Ek metadata
+         * @returns {Promise<CallResponse>} Arama bilgisi
+         * @example
+         * const call = await supsis.aicall.makeCall({
+         *   agentId: 'agentId',
+         *   toNumber: '+905551234567',
+         *   fromNumber: '+908501234567',
+         *   variables: {
+         *     customerName: 'John Doe',
+         *     orderNumber: '12345'
+         *   }
+         * });
+         */
+        async makeCall(options) {
+            this._validateRequired(options, ['agentId', 'toNumber', 'fromNumber']);
+            
+            return await this.http.post('/api/voice-agent/calls/phone', {
+                overrideAgentId: options.agentId,
+                toNumber: options.toNumber,
+                fromNumber: options.fromNumber,
+                retellLlmDynamicVariables: options.variables || {},
+                metadata: options.metadata
+            });
+        }
+
+        /**
+         * Web araması başlatır (tarayıcıdan)
+         * @param {Object} options - Arama seçenekleri
+         * @param {string} options.agentId - AI Agent ID'si
+         * @param {Object} [options.variables] - Dinamik değişkenler
+         * @returns {Promise<WebCallResponse>} Web arama bilgisi
+         */
+        async makeWebCall(options) {
+            this._validateRequired(options, ['agentId']);
+            
+            return await this.http.post('/api/voice-agent/calls/web', {
+                agentId: options.agentId,
+                retellLlmDynamicVariables: options.variables || {}
+            });
+        }
+
+        /**
+         * Toplu arama başlatır (batch call)
+         * @param {Object} options - Toplu arama seçenekleri
+         * @param {string} options.agentId - AI Agent ID'si
+         * @param {string} options.fromNumber - Arayan telefon numarası
+         * @param {Array<{toNumber: string, variables?: Object}>} options.calls - Aranacak numaralar
+         * @returns {Promise<BatchCallResponse>}
+         */
+        async makeBatchCall(options) {
+            this._validateRequired(options, ['agentId', 'fromNumber', 'calls']);
+            return await this.http.post('/api/voice-agent/calls/batch', options);
+        }
+
+        /**
+         * Bir arama kaydını getirir
+         * @param {string} callId - Arama ID'si
+         * @returns {Promise<CallResponse>} Arama detayları
+         * @example
+         * const call = await supsis.aicall.getCall('callId');
+         * console.log(call.status); // 'completed', 'failed', 'in_progress'
+         * console.log(call.duration); // Süre (saniye)
+         * console.log(call.transcript); // Konuşma metni
+         */
+        async getCall(callId) {
+            this._validateRequired({ callId: callId }, ['callId']);
+            return await this.http.get('/api/voice-agent/calls/' + callId);
+        }
+
+        /**
+         * Arama listesini getirir
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {string} [options.agentId] - Agent ID filtresi
+         * @param {string} [options.status] - Durum filtresi
+         * @param {Date|string} [options.startDate] - Başlangıç tarihi
+         * @param {Date|string} [options.endDate] - Bitiş tarihi
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt sayısı
+         * @returns {Promise<{data: CallResponse[], total: number}>}
+         */
+        async listCalls(options) {
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/voice-agent/calls/list', {
+                agentId: options.agentId,
+                status: options.status,
+                startDate: this._toISODate(options.startDate),
+                endDate: this._toISODate(options.endDate),
+                page: pagination.page,
+                limit: pagination.limit
+            });
+        }
+
+        /**
+         * Toplu arama listesini getirir
+         * @returns {Promise<BatchCallResponse[]>}
+         */
+        async listBatchCalls() {
+            return await this.http.get('/api/voice-agent/calls/batch');
+        }
+
+        // ==================== AGENT METHODS ====================
+
+        /**
+         * AI Agent listesini getirir
+         * @returns {Promise<AgentResponse[]>}
+         */
+        async listAgents() {
+            return await this.http.get('/api/voice-agent/agents');
+        }
+
+        /**
+         * Bir AI Agent'ı getirir
+         * @param {string} agentId - Agent ID'si
+         * @returns {Promise<AgentResponse>}
+         */
+        async getAgent(agentId) {
+            this._validateRequired({ agentId: agentId }, ['agentId']);
+            return await this.http.get('/api/voice-agent/agents/' + agentId);
+        }
+
+        /**
+         * AI Agent oluşturur
+         * @param {Object} data - Agent verileri
+         * @param {string} data.name - Agent adı
+         * @param {string} data.voiceId - Ses ID'si
+         * @param {string} data.llmId - LLM ID'si
+         * @param {Object} [data.settings] - Agent ayarları
+         * @returns {Promise<AgentResponse>}
+         */
+        async createAgent(data) {
+            this._validateRequired(data, ['name']);
+            return await this.http.post('/api/voice-agent/agents', data);
+        }
+
+        /**
+         * AI Agent günceller
+         * @param {string} agentId - Agent ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<AgentResponse>}
+         */
+        async updateAgent(agentId, data) {
+            this._validateRequired({ agentId: agentId }, ['agentId']);
+            return await this.http.patch('/api/voice-agent/agents/' + agentId, data);
+        }
+
+        /**
+         * AI Agent siler
+         * @param {string} agentId - Agent ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteAgent(agentId) {
+            this._validateRequired({ agentId: agentId }, ['agentId']);
+            return await this.http.delete('/api/voice-agent/agents/' + agentId);
+        }
+
+        // ==================== PHONE NUMBER METHODS ====================
+
+        /**
+         * Telefon numarası listesini getirir
+         * @returns {Promise<PhoneNumberResponse[]>}
+         */
+        async listNumbers() {
+            return await this.http.get('/api/voice-agent/numbers');
+        }
+
+        /**
+         * Telefon numarası bilgisini getirir
+         * @param {string} phoneNumber - Telefon numarası
+         * @returns {Promise<PhoneNumberResponse>}
+         */
+        async getNumber(phoneNumber) {
+            this._validateRequired({ phoneNumber: phoneNumber }, ['phoneNumber']);
+            return await this.http.get('/api/voice-agent/numbers/' + encodeURIComponent(phoneNumber));
+        }
+
+        // ==================== VOICE METHODS ====================
+
+        /**
+         * Kullanılabilir ses listesini getirir
+         * @returns {Promise<VoiceResponse[]>}
+         */
+        async listVoices() {
+            return await this.http.get('/api/voice-agent/voices');
+        }
+
+        /**
+         * Bir ses bilgisini getirir
+         * @param {string} voiceId - Ses ID'si
+         * @returns {Promise<VoiceResponse>}
+         */
+        async getVoice(voiceId) {
+            this._validateRequired({ voiceId: voiceId }, ['voiceId']);
+            return await this.http.get('/api/voice-agent/voices/' + voiceId);
+        }
+
+        // ==================== KNOWLEDGE BASE METHODS ====================
+
+        /**
+         * Bilgi tabanı listesini getirir
+         * @returns {Promise<KnowledgeBaseResponse[]>}
+         */
+        async listKnowledgeBases() {
+            return await this.http.get('/api/voice-agent/knowledgebases');
+        }
+
+        /**
+         * Bir bilgi tabanını getirir
+         * @param {string} knowledgeBaseId - Bilgi tabanı ID'si
+         * @returns {Promise<KnowledgeBaseResponse>}
+         */
+        async getKnowledgeBase(knowledgeBaseId) {
+            this._validateRequired({ knowledgeBaseId: knowledgeBaseId }, ['knowledgeBaseId']);
+            return await this.http.get('/api/voice-agent/knowledgebases/' + knowledgeBaseId);
+        }
+
+        /**
+         * Bilgi tabanı siler
+         * @param {string} knowledgeBaseId - Bilgi tabanı ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteKnowledgeBase(knowledgeBaseId) {
+            this._validateRequired({ knowledgeBaseId: knowledgeBaseId }, ['knowledgeBaseId']);
+            return await this.http.delete('/api/voice-agent/knowledgebases/' + knowledgeBaseId);
+        }
+
+        // ==================== LLM METHODS ====================
+
+        /**
+         * LLM listesini getirir
+         * @returns {Promise<LLMResponse[]>}
+         */
+        async listLLMs() {
+            return await this.http.get('/api/voice-agent/llms');
+        }
+
+        /**
+         * Bir LLM'i getirir
+         * @param {string} llmId - LLM ID'si
+         * @returns {Promise<LLMResponse>}
+         */
+        async getLLM(llmId) {
+            this._validateRequired({ llmId: llmId }, ['llmId']);
+            return await this.http.get('/api/voice-agent/llms/' + llmId);
+        }
+
+        /**
+         * LLM oluşturur
+         * @param {Object} data - LLM verileri
+         * @returns {Promise<LLMResponse>}
+         */
+        async createLLM(data) {
+            return await this.http.post('/api/voice-agent/llms', data);
+        }
+
+        /**
+         * LLM günceller
+         * @param {string} llmId - LLM ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<LLMResponse>}
+         */
+        async updateLLM(llmId, data) {
+            this._validateRequired({ llmId: llmId }, ['llmId']);
+            return await this.http.patch('/api/voice-agent/llms/' + llmId, data);
+        }
+
+        /**
+         * LLM siler
+         * @param {string} llmId - LLM ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteLLM(llmId) {
+            this._validateRequired({ llmId: llmId }, ['llmId']);
+            return await this.http.delete('/api/voice-agent/llms/' + llmId);
+        }
+    }
+
+    /**
+     * @typedef {Object} CallResponse
+     * @property {string} call_id - Arama ID
+     * @property {string} agent_id - Agent ID
+     * @property {string} call_status - Durum: 'registered', 'ongoing', 'ended', 'error'
+     * @property {string} [from_number] - Arayan numara
+     * @property {string} [to_number] - Aranan numara
+     * @property {number} [start_timestamp] - Başlangıç zamanı (ms)
+     * @property {number} [end_timestamp] - Bitiş zamanı (ms)
+     * @property {number} [duration_ms] - Süre (ms)
+     * @property {string} [transcript] - Konuşma metni
+     * @property {Object} [call_analysis] - Arama analizi
+     * @property {string} [recording_url] - Kayıt URL'si
+     * @property {Object} [metadata] - Ek metadata
+     */
+
+    /**
+     * @typedef {Object} AgentResponse
+     * @property {string} agent_id - Agent ID
+     * @property {string} agent_name - Agent adı
+     * @property {string} voice_id - Ses ID
+     * @property {string} llm_websocket_url - LLM WebSocket URL
+     * @property {Object} [settings] - Agent ayarları
+     */
+
+    /**
+     * @typedef {Object} VoiceResponse
+     * @property {string} voice_id - Ses ID
+     * @property {string} voice_name - Ses adı
+     * @property {string} [sample_audio_url] - Örnek ses URL'si
+     * @property {string} [gender] - Cinsiyet
+     * @property {string} [language] - Dil
+     */
+
+    /**
+     * @typedef {Object} KnowledgeBaseResponse
+     * @property {string} knowledge_base_id - Bilgi tabanı ID
+     * @property {string} name - Ad
+     * @property {Object[]} [sources] - Kaynaklar
+     */
+
+    /**
+     * @typedef {Object} LLMResponse
+     * @property {string} llm_id - LLM ID
+     * @property {string} [model] - Model adı
+     * @property {Object} [settings] - LLM ayarları
+     */
+
+    /**
+     * @typedef {Object} PhoneNumberResponse
+     * @property {string} phone_number - Telefon numarası
+     * @property {string} [agent_id] - Bağlı agent ID
+     * @property {string} [status] - Durum
+     */
+
+    /**
+     * @typedef {Object} BatchCallResponse
+     * @property {string} batch_id - Batch ID
+     * @property {string} status - Durum
+     * @property {number} total_calls - Toplam arama sayısı
+     * @property {number} completed_calls - Tamamlanan arama sayısı
+     */
+
+    /**
+     * Asset modülü
+     * Dosya ve medya yönetimi
+     * 
+     * @class Asset
+     * @extends BaseModule
+     * @example
+     * // Asset bilgisi getir
+     * const asset = await supsis.asset.get('assetId');
+     * console.log(asset.path); // S3 path
+     * console.log(asset.mime); // MIME type
+     */
+    class Asset extends BaseModule {
+        /**
+         * Bir asset bilgisini getirir
+         * @param {string} assetId - Asset ID'si
+         * @returns {Promise<AssetResponse>} Asset detayları
+         * @example
+         * const asset = await supsis.asset.get('assetId');
+         * console.log(asset.path); // 'siteId/whatsapp/uuid.jpg'
+         * console.log(asset.mime); // 'image/jpeg'
+         * console.log(asset.size); // Dosya boyutu (bytes)
+         */
+        async get(assetId) {
+            this._validateRequired({ assetId: assetId }, ['assetId']);
+            return await this.http.get('/api/assets/id/' + assetId);
+        }
+
+        /**
+         * Asset URL'sini oluşturur
+         * @param {string} path - Asset path'i
+         * @returns {string} Tam URL
+         */
+        getUrl(path) {
+            if (!path) return null;
+            // S3 bucket URL'si
+            return 'https://supsis-storage.s3.amazonaws.com/' + path;
+        }
+    }
+
+    /**
+     * @typedef {Object} AssetResponse
+     * @property {string} _id - Asset ID
+     * @property {string} siteId - Site ID
+     * @property {string} path - S3 path
+     * @property {string} mime - MIME type
+     * @property {string} ext - Dosya uzantısı
+     * @property {number} size - Dosya boyutu (bytes)
+     * @property {string} [platform] - Platform: 'whatsapp', 'web', 'instagram', etc.
+     * @property {string} [externalUrl] - Harici URL
+     * @property {Date} createdAt - Oluşturulma tarihi
+     * @property {Date} updatedAt - Güncellenme tarihi
+     */
+
+    /**
+     * Table modülü
+     * Müşteri tabloları (CustomerTable) yönetimi - Airtable benzeri tablo sistemi
+     * 
+     * @class Table
+     * @extends BaseModule
+     * @example
+     * // Tablo listele
+     * const tables = await supsis.table.list();
+     * 
+     * // Tablo kayıtlarını getir
+     * const records = await supsis.table.listRecords('tableId');
+     */
+    class Table extends BaseModule {
+        /**
+         * Tüm tabloları listeler
+         * @returns {Promise<TableResponse[]>}
+         */
+        async list() {
+            return await this.http.get('/api/tables');
+        }
+
+        /**
+         * Bir tabloyu getirir
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<TableResponse>}
+         */
+        async get(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.get('/api/tables/' + tableId);
+        }
+
+        /**
+         * Tablo oluşturur
+         * @param {Object} data - Tablo verileri
+         * @param {string} data.name - Tablo adı
+         * @param {string} [data.description] - Açıklama
+         * @param {string} [data.icon] - İkon
+         * @returns {Promise<TableResponse>}
+         */
+        async create(data) {
+            this._validateRequired(data, ['name']);
+            return await this.http.put('/api/tables', data);
+        }
+
+        /**
+         * Tabloyu günceller
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<TableResponse>}
+         */
+        async update(tableId, data) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.post('/api/tables/' + tableId, data);
+        }
+
+        /**
+         * Tabloyu siler
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.delete('/api/tables/' + tableId);
+        }
+
+        /**
+         * Tabloyu kopyalar
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<TableResponse>}
+         */
+        async duplicate(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.post('/api/tables/' + tableId + '/duplicate');
+        }
+
+        /**
+         * Tabloyu JSON olarak export eder
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<Object>} Export edilmiş tablo
+         */
+        async export(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.get('/api/tables/' + tableId + '/export');
+        }
+
+        /**
+         * JSON'dan tablo import eder
+         * @param {Object} data - Import edilecek tablo verisi
+         * @returns {Promise<TableResponse>}
+         */
+        async import(data) {
+            return await this.http.post('/api/tables/import', data);
+        }
+
+        // ==================== FIELD METHODS ====================
+
+        /**
+         * Tablo alanlarını listeler
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<FieldResponse[]>}
+         */
+        async listFields(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.get('/api/tables/' + tableId + '/fields');
+        }
+
+        /**
+         * Tablo alanı oluşturur
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object} data - Alan verileri
+         * @param {string} data.name - Alan adı
+         * @param {string} data.type - Alan tipi: 'text', 'number', 'date', 'select', 'multiselect', 'checkbox', 'url', 'email', 'phone', 'user', 'contact', 'relation', 'formula', 'rollup', 'lookup', 'attachment', 'rating', 'currency', 'percent', 'duration', 'barcode'
+         * @param {Object} [data.options] - Alan seçenekleri
+         * @returns {Promise<FieldResponse>}
+         */
+        async createField(tableId, data) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            this._validateRequired(data, ['name', 'type']);
+            return await this.http.put('/api/tables/' + tableId + '/fields', data);
+        }
+
+        /**
+         * Tablo alanını günceller
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} fieldId - Alan ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<FieldResponse>}
+         */
+        async updateField(tableId, fieldId, data) {
+            this._validateRequired({ tableId: tableId, fieldId: fieldId }, ['tableId', 'fieldId']);
+            return await this.http.post('/api/tables/' + tableId + '/fields/' + fieldId, data);
+        }
+
+        /**
+         * Tablo alanını siler
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} fieldId - Alan ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteField(tableId, fieldId) {
+            this._validateRequired({ tableId: tableId, fieldId: fieldId }, ['tableId', 'fieldId']);
+            return await this.http.delete('/api/tables/' + tableId + '/fields/' + fieldId);
+        }
+
+        // ==================== RECORD METHODS ====================
+
+        /**
+         * Tablo kayıtlarını listeler
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {Object} [options.filters] - Filtreler
+         * @param {Object} [options.sort] - Sıralama
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt
+         * @param {string} [options.viewId] - View ID'si
+         * @returns {Promise<{data: RecordResponse[], total: number}>}
+         */
+        async listRecords(tableId, options) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/tables/' + tableId + '/records', {
+                filters: options.filters,
+                sort: options.sort,
+                page: pagination.page,
+                limit: pagination.limit,
+                viewId: options.viewId
+            });
+        }
+
+        /**
+         * Bir kaydı getirir
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} recordId - Kayıt ID'si
+         * @returns {Promise<RecordResponse>}
+         */
+        async getRecord(tableId, recordId) {
+            this._validateRequired({ tableId: tableId, recordId: recordId }, ['tableId', 'recordId']);
+            return await this.http.get('/api/tables/' + tableId + '/records/' + recordId);
+        }
+
+        /**
+         * Kayıt oluşturur
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object} data - Kayıt verileri (field slug -> value)
+         * @returns {Promise<RecordResponse>}
+         * @example
+         * const record = await supsis.table.createRecord('tableId', {
+         *   name: 'John Doe',
+         *   email: 'john@example.com',
+         *   status: 'active'
+         * });
+         */
+        async createRecord(tableId, data) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.put('/api/tables/' + tableId + '/records', data);
+        }
+
+        /**
+         * Boş kayıt oluşturur
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<RecordResponse>}
+         */
+        async createEmptyRecord(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.put('/api/tables/' + tableId + '/records/empty');
+        }
+
+        /**
+         * Birden fazla kayıt oluşturur
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object[]} records - Kayıt verileri dizisi
+         * @returns {Promise<RecordResponse[]>}
+         */
+        async createManyRecords(tableId, records) {
+            this._validateRequired({ tableId: tableId, records: records }, ['tableId', 'records']);
+            return await this.http.put('/api/tables/' + tableId + '/records/multi', {
+                records: records
+            });
+        }
+
+        /**
+         * Kaydı günceller
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} recordId - Kayıt ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<RecordResponse>}
+         */
+        async updateRecord(tableId, recordId, data) {
+            this._validateRequired({ tableId: tableId, recordId: recordId }, ['tableId', 'recordId']);
+            return await this.http.post('/api/tables/' + tableId + '/records/' + recordId + '/update', data);
+        }
+
+        /**
+         * Birden fazla kaydın aynı alanını günceller
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} fieldId - Alan ID'si
+         * @param {string[]} recordIds - Kayıt ID'leri
+         * @param {*} value - Yeni değer
+         * @returns {Promise<{success: boolean}>}
+         */
+        async updateManyRecords(tableId, fieldId, recordIds, value) {
+            this._validateRequired({ tableId: tableId, fieldId: fieldId, recordIds: recordIds }, ['tableId', 'fieldId', 'recordIds']);
+            return await this.http.put('/api/tables/' + tableId + '/fields/' + fieldId + '/records', {
+                recordIds: recordIds,
+                value: value
+            });
+        }
+
+        /**
+         * Kaydı siler
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} recordId - Kayıt ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteRecord(tableId, recordId) {
+            this._validateRequired({ tableId: tableId, recordId: recordId }, ['tableId', 'recordId']);
+            return await this.http.delete('/api/tables/' + tableId + '/records/' + recordId);
+        }
+
+        /**
+         * Birden fazla kaydı siler
+         * @param {string} tableId - Tablo ID'si
+         * @param {string[]} recordIds - Kayıt ID'leri
+         * @returns {Promise<{success: boolean, deletedCount: number}>}
+         */
+        async deleteManyRecords(tableId, recordIds) {
+            this._validateRequired({ tableId: tableId, recordIds: recordIds }, ['tableId', 'recordIds']);
+            return await this.http.post('/api/tables/' + tableId + '/records/delete', {
+                recordIds: recordIds
+            });
+        }
+
+        /**
+         * Kayıtları kopyalar
+         * @param {string} tableId - Tablo ID'si
+         * @param {string[]} recordIds - Kopyalanacak kayıt ID'leri
+         * @returns {Promise<RecordResponse[]>}
+         */
+        async duplicateRecords(tableId, recordIds) {
+            this._validateRequired({ tableId: tableId, recordIds: recordIds }, ['tableId', 'recordIds']);
+            return await this.http.post('/api/tables/' + tableId + '/records/duplicate', {
+                recordIds: recordIds
+            });
+        }
+
+        /**
+         * Alan değerlerinde arama yapar
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} fieldId - Alan ID'si
+         * @param {string} query - Arama terimi
+         * @returns {Promise<*[]>} Eşleşen değerler
+         */
+        async searchFieldValues(tableId, fieldId, query) {
+            this._validateRequired({ tableId: tableId, fieldId: fieldId }, ['tableId', 'fieldId']);
+            return await this.http.get('/api/tables/' + tableId + '/' + fieldId + '/search', {
+                query: { q: query }
+            });
+        }
+
+        // ==================== VIEW METHODS ====================
+
+        /**
+         * Tablo görünümlerini listeler
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<ViewResponse[]>}
+         */
+        async listViews(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.get('/api/tables/' + tableId + '/views');
+        }
+
+        /**
+         * Görünüm oluşturur
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object} data - Görünüm verileri
+         * @param {string} data.name - Görünüm adı
+         * @param {string} [data.type] - Tip: 'grid', 'kanban', 'calendar', 'gallery'
+         * @param {Object} [data.filters] - Filtreler
+         * @param {Object} [data.sort] - Sıralama
+         * @returns {Promise<ViewResponse>}
+         */
+        async createView(tableId, data) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            this._validateRequired(data, ['name']);
+            return await this.http.put('/api/tables/' + tableId + '/views', data);
+        }
+
+        /**
+         * Görünümü günceller
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} viewId - Görünüm ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<ViewResponse>}
+         */
+        async updateView(tableId, viewId, data) {
+            this._validateRequired({ tableId: tableId, viewId: viewId }, ['tableId', 'viewId']);
+            return await this.http.post('/api/tables/' + tableId + '/views/' + viewId, data);
+        }
+
+        /**
+         * Görünümü siler
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} viewId - Görünüm ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteView(tableId, viewId) {
+            this._validateRequired({ tableId: tableId, viewId: viewId }, ['tableId', 'viewId']);
+            return await this.http.delete('/api/tables/' + tableId + '/views/' + viewId);
+        }
+
+        // ==================== PAGE & WIDGET METHODS ====================
+
+        /**
+         * Tablo sayfalarını listeler
+         * @param {string} tableId - Tablo ID'si
+         * @returns {Promise<PageResponse[]>}
+         */
+        async listPages(tableId) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.get('/api/tables/' + tableId + '/pages');
+        }
+
+        /**
+         * Bir sayfayı getirir
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} pageId - Sayfa ID'si
+         * @returns {Promise<PageResponse>}
+         */
+        async getPage(tableId, pageId) {
+            this._validateRequired({ tableId: tableId, pageId: pageId }, ['tableId', 'pageId']);
+            return await this.http.get('/api/tables/' + tableId + '/pages/' + pageId);
+        }
+
+        /**
+         * Sayfa oluşturur
+         * @param {string} tableId - Tablo ID'si
+         * @param {Object} data - Sayfa verileri
+         * @returns {Promise<PageResponse>}
+         */
+        async createPage(tableId, data) {
+            this._validateRequired({ tableId: tableId }, ['tableId']);
+            return await this.http.put('/api/tables/' + tableId + '/pages', data);
+        }
+
+        /**
+         * Widget listesini getirir
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} pageId - Sayfa ID'si
+         * @returns {Promise<WidgetResponse[]>}
+         */
+        async listWidgets(tableId, pageId) {
+            this._validateRequired({ tableId: tableId, pageId: pageId }, ['tableId', 'pageId']);
+            return await this.http.get('/api/tables/' + tableId + '/pages/' + pageId + '/widgets');
+        }
+
+        /**
+         * Widget chart verisini getirir
+         * @param {string} tableId - Tablo ID'si
+         * @param {string} widgetId - Widget ID'si
+         * @param {Object} [options] - Seçenekler
+         * @returns {Promise<Object>} Chart verisi
+         */
+        async getWidgetChartData(tableId, widgetId, options) {
+            this._validateRequired({ tableId: tableId, widgetId: widgetId }, ['tableId', 'widgetId']);
+            return await this.http.post('/api/tables/' + tableId + '/widgets/' + widgetId + '/chart-data', options || {});
+        }
+    }
+
+    /**
+     * @typedef {Object} TableResponse
+     * @property {string} _id - Tablo ID
+     * @property {string} siteId - Site ID
+     * @property {string} name - Tablo adı
+     * @property {string} [description] - Açıklama
+     * @property {string} [icon] - İkon
+     * @property {Date} createdAt - Oluşturulma tarihi
+     */
+
+    /**
+     * @typedef {Object} FieldResponse
+     * @property {string} _id - Alan ID
+     * @property {string} name - Alan adı
+     * @property {string} slug - URL-friendly isim
+     * @property {string} type - Alan tipi
+     * @property {Object} [options] - Alan seçenekleri
+     * @property {number} [position] - Sıra
+     * @property {boolean} [required] - Zorunlu mu
+     */
+
+    /**
+     * @typedef {Object} RecordResponse
+     * @property {string} _id - Kayıt ID
+     * @property {string} tableId - Tablo ID
+     * @property {Object} data - Alan değerleri (slug -> value)
+     * @property {Date} createdAt - Oluşturulma tarihi
+     * @property {Date} updatedAt - Güncellenme tarihi
+     * @property {string} [createdBy] - Oluşturan kullanıcı ID
+     */
+
+    /**
+     * @typedef {Object} ViewResponse
+     * @property {string} _id - Görünüm ID
+     * @property {string} name - Görünüm adı
+     * @property {string} type - Tip: 'grid', 'kanban', 'calendar', 'gallery'
+     * @property {Object} [filters] - Filtreler
+     * @property {Object} [sort] - Sıralama
+     */
+
+    /**
+     * @typedef {Object} PageResponse
+     * @property {string} _id - Sayfa ID
+     * @property {string} name - Sayfa adı
+     * @property {string} tableId - Tablo ID
+     */
+
+    /**
+     * @typedef {Object} WidgetResponse
+     * @property {string} _id - Widget ID
+     * @property {string} type - Widget tipi
+     * @property {Object} config - Widget konfigürasyonu
+     */
+
+    /**
+     * Module modülü
+     * Dinamik modüller (müşteri özelinde CRM modülleri) yönetimi
+     * 
+     * @class Module
+     * @extends BaseModule
+     * @example
+     * // Modül listele
+     * const modules = await supsis.module.list();
+     * 
+     * // Modül kayıtlarını getir
+     * const records = await supsis.module.listRecords('Leads');
+     * 
+     * // Kayıt oluştur
+     * const lead = await supsis.module.createRecord('Leads', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com'
+     * });
+     */
+    class Module extends BaseModule {
+        /**
+         * Tüm modülleri listeler
+         * @returns {Promise<ModuleDefinitionResponse[]>}
+         */
+        async list() {
+            return await this.http.get('/api/module');
+        }
+
+        /**
+         * Modül oluşturur
+         * @param {Object} data - Modül verileri
+         * @param {string} data.name - Modül adı (API name)
+         * @param {string} data.displayName - Görünen ad
+         * @param {Object[]} [data.fields] - Alan tanımları
+         * @returns {Promise<ModuleDefinitionResponse>}
+         */
+        async create(data) {
+            this._validateRequired(data, ['name', 'displayName']);
+            return await this.http.post('/api/module', data);
+        }
+
+        /**
+         * Modülü günceller
+         * @param {string} moduleName - Modül adı
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<ModuleDefinitionResponse>}
+         */
+        async update(moduleName, data) {
+            this._validateRequired({ moduleName: moduleName }, ['moduleName']);
+            return await this.http.post('/api/module/' + moduleName, data);
+        }
+
+        /**
+         * Modülü siler
+         * @param {string} moduleId - Modül ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(moduleId) {
+            this._validateRequired({ moduleId: moduleId }, ['moduleId']);
+            return await this.http.delete('/api/module/' + moduleId);
+        }
+
+        // ==================== RECORD METHODS ====================
+
+        /**
+         * Modül kayıtlarını listeler
+         * @param {string} moduleName - Modül adı
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {Object} [options.filters] - Filtreler
+         * @param {Object} [options.sort] - Sıralama
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt
+         * @returns {Promise<{data: ModuleRecordResponse[], total: number}>}
+         * @example
+         * const leads = await supsis.module.listRecords('Leads', {
+         *   filters: { status: 'new' },
+         *   limit: 50
+         * });
+         */
+        async listRecords(moduleName, options) {
+            this._validateRequired({ moduleName: moduleName }, ['moduleName']);
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/module/' + moduleName + '/records', {
+                filters: options.filters,
+                sort: options.sort,
+                page: pagination.page,
+                limit: pagination.limit
+            });
+        }
+
+        /**
+         * Modül kayıtlarını filtre olmadan listeler
+         * @param {string} moduleName - Modül adı
+         * @returns {Promise<ModuleRecordResponse[]>}
+         */
+        async listAllRecords(moduleName) {
+            this._validateRequired({ moduleName: moduleName }, ['moduleName']);
+            return await this.http.get('/api/module/' + moduleName + '/records');
+        }
+
+        /**
+         * Kayıtlarda arama yapar
+         * @param {string} moduleName - Modül adı
+         * @param {string} query - Arama terimi
+         * @returns {Promise<ModuleRecordResponse[]>}
+         */
+        async searchRecords(moduleName, query) {
+            this._validateRequired({ moduleName: moduleName, query: query }, ['moduleName', 'query']);
+            return await this.http.get('/api/module/' + moduleName + '/records/search', {
+                query: { q: query }
+            });
+        }
+
+        /**
+         * Bir kaydı getirir
+         * @param {string} moduleName - Modül adı
+         * @param {string} recordId - Kayıt ID'si
+         * @returns {Promise<ModuleRecordResponse>}
+         */
+        async getRecord(moduleName, recordId) {
+            this._validateRequired({ moduleName: moduleName, recordId: recordId }, ['moduleName', 'recordId']);
+            return await this.http.get('/api/module/' + moduleName + '/records/' + recordId);
+        }
+
+        /**
+         * Kayıt oluşturur
+         * @param {string} moduleName - Modül adı
+         * @param {Object} data - Kayıt verileri
+         * @returns {Promise<ModuleRecordResponse>}
+         * @example
+         * const lead = await supsis.module.createRecord('Leads', {
+         *   name: 'John Doe',
+         *   email: 'john@example.com',
+         *   phone: '+905551234567',
+         *   status: 'new'
+         * });
+         */
+        async createRecord(moduleName, data) {
+            this._validateRequired({ moduleName: moduleName }, ['moduleName']);
+            return await this.http.put('/api/module/' + moduleName + '/records', data);
+        }
+
+        /**
+         * Birden fazla kayıt oluşturur
+         * @param {string} moduleName - Modül adı
+         * @param {Object[]} records - Kayıt verileri dizisi
+         * @returns {Promise<ModuleRecordResponse[]>}
+         */
+        async createManyRecords(moduleName, records) {
+            this._validateRequired({ moduleName: moduleName, records: records }, ['moduleName', 'records']);
+            return await this.http.put('/api/module/' + moduleName + '/records/multi', {
+                records: records
+            });
+        }
+
+        /**
+         * Kaydı günceller
+         * @param {string} moduleName - Modül adı
+         * @param {string} recordId - Kayıt ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<ModuleRecordResponse>}
+         */
+        async updateRecord(moduleName, recordId, data) {
+            this._validateRequired({ moduleName: moduleName, recordId: recordId }, ['moduleName', 'recordId']);
+            return await this.http.put('/api/module/' + moduleName + '/records/' + recordId, data);
+        }
+
+        /**
+         * Kaydı siler
+         * @param {string} moduleName - Modül adı
+         * @param {string} recordId - Kayıt ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async deleteRecord(moduleName, recordId) {
+            this._validateRequired({ moduleName: moduleName, recordId: recordId }, ['moduleName', 'recordId']);
+            return await this.http.delete('/api/module/' + moduleName + '/records/' + recordId);
+        }
+
+        /**
+         * Contact ile ilişkili kayıtları listeler
+         * @param {string} contactId - Contact ID'si
+         * @returns {Promise<Object>} Modül adı -> Kayıtlar mapping
+         */
+        async listContactRelatedRecords(contactId) {
+            this._validateRequired({ contactId: contactId }, ['contactId']);
+            return await this.http.get('/api/module/records/contact-related-list', {
+                query: { contactId: contactId }
+            });
+        }
+
+        /**
+         * Modül ile ilişkili kayıtları listeler
+         * @param {string} moduleName - Modül adı
+         * @param {string} recordId - Kayıt ID'si
+         * @returns {Promise<Object>} İlişkili kayıtlar
+         */
+        async listModuleRelatedRecords(moduleName, recordId) {
+            this._validateRequired({ moduleName: moduleName, recordId: recordId }, ['moduleName', 'recordId']);
+            return await this.http.get('/api/module/records/module-related-list', {
+                query: { 
+                    moduleName: moduleName,
+                    recordId: recordId 
+                }
+            });
+        }
+    }
+
+    /**
+     * @typedef {Object} ModuleDefinitionResponse
+     * @property {string} _id - Modül ID
+     * @property {string} siteId - Site ID
+     * @property {string} name - Modül adı (API name)
+     * @property {string} displayName - Görünen ad
+     * @property {string} [description] - Açıklama
+     * @property {string} [icon] - İkon
+     * @property {ModuleFieldDefinition[]} fields - Alan tanımları
+     * @property {Date} createdAt - Oluşturulma tarihi
+     */
+
+    /**
+     * @typedef {Object} ModuleFieldDefinition
+     * @property {string} name - Alan adı
+     * @property {string} displayName - Görünen ad
+     * @property {string} type - Alan tipi
+     * @property {boolean} [required] - Zorunlu mu
+     * @property {*} [defaultValue] - Varsayılan değer
+     * @property {Object} [options] - Alan seçenekleri
+     */
+
+    /**
+     * @typedef {Object} ModuleRecordResponse
+     * @property {string} _id - Kayıt ID
+     * @property {string} moduleId - Modül ID
+     * @property {Object} data - Alan değerleri
+     * @property {Date} createdAt - Oluşturulma tarihi
+     * @property {Date} updatedAt - Güncellenme tarihi
+     * @property {string} [createdBy] - Oluşturan kullanıcı ID
+     */
+
+    /**
+     * User modülü
+     * Kullanıcı (temsilci) yönetimi
+     * 
+     * @class User
+     * @extends BaseModule
+     * @example
+     * // Mevcut kullanıcı bilgisi
+     * const me = await supsis.user.me();
+     * 
+     * // Kullanıcı listesi
+     * const users = await supsis.user.list();
+     */
+    class User extends BaseModule {
+        /**
+         * Mevcut kullanıcının bilgisini getirir
+         * @returns {Promise<UserResponse>}
+         * @example
+         * const me = await supsis.user.me();
+         * console.log(me.fullname);
+         * console.log(me.email);
+         * console.log(me.role);
+         */
+        async me() {
+            return await this.http.get('/api/users/me');
+        }
+
+        /**
+         * Mevcut kullanıcıyı günceller
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<UserResponse>}
+         */
+        async updateMe(data) {
+            return await this.http.put('/api/users/me', data);
+        }
+
+        /**
+         * Bir kullanıcıyı getirir
+         * @param {string} userId - Kullanıcı ID'si
+         * @returns {Promise<UserResponse>}
+         */
+        async get(userId) {
+            this._validateRequired({ userId: userId }, ['userId']);
+            return await this.http.get('/api/users/user/' + userId);
+        }
+
+        /**
+         * Kullanıcı listesini getirir
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt
+         * @param {string} [options.status] - Durum filtresi
+         * @returns {Promise<{data: UserResponse[], total: number}>}
+         */
+        async list(options) {
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.get('/api/users/pagination', {
+                query: this._cleanObject({
+                    page: pagination.page,
+                    limit: pagination.limit,
+                    status: options.status
+                })
+            });
+        }
+
+        /**
+         * Online kullanıcıları listeler
+         * @returns {Promise<UserResponse[]>}
+         */
+        async listOnline() {
+            return await this.http.get('/api/users/list-online-users');
+        }
+
+        /**
+         * Kullanıcı oluşturur
+         * @param {Object} data - Kullanıcı verileri
+         * @param {string} data.fullname - İsim
+         * @param {string} data.email - Email
+         * @param {string} data.password - Şifre
+         * @param {string} [data.role] - Rol ID'si
+         * @param {string[]} [data.subjects] - Departman ID'leri
+         * @returns {Promise<UserResponse>}
+         */
+        async create(data) {
+            this._validateRequired(data, ['fullname', 'email', 'password']);
+            return await this.http.post('/api/users', data);
+        }
+
+        /**
+         * Kullanıcıyı günceller
+         * @param {string} userId - Kullanıcı ID'si
+         * @param {Object} data - Güncellenecek veriler
+         * @returns {Promise<UserResponse>}
+         */
+        async update(userId, data) {
+            this._validateRequired({ userId: userId }, ['userId']);
+            return await this.http.put('/api/users/' + userId, data);
+        }
+
+        /**
+         * Kullanıcıyı siler
+         * @param {string} userId - Kullanıcı ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(userId) {
+            this._validateRequired({ userId: userId }, ['userId']);
+            return await this.http.delete('/api/users/' + userId);
+        }
+
+        /**
+         * Kullanıcı şifresini günceller
+         * @param {string} userId - Kullanıcı ID'si
+         * @param {string} newPassword - Yeni şifre
+         * @returns {Promise<{success: boolean}>}
+         */
+        async updatePassword(userId, newPassword) {
+            this._validateRequired({ userId: userId, newPassword: newPassword }, ['userId', 'newPassword']);
+            return await this.http.put('/api/users/' + userId + '/updatePassword', {
+                password: newPassword
+            });
+        }
+
+        /**
+         * Kullanıcının online durumunu günceller
+         * @param {string} userId - Kullanıcı ID'si
+         * @param {boolean} isOnline - Online mi
+         * @returns {Promise<UserResponse>}
+         */
+        async updateOnlineStatus(userId, isOnline) {
+            this._validateRequired({ userId: userId }, ['userId']);
+            return await this.http.put('/api/users/' + userId + '/onlineStatus', {
+                isOnline: isOnline
+            });
+        }
+
+        /**
+         * Kullanıcının durumunu günceller
+         * @param {string} userId - Kullanıcı ID'si
+         * @param {string} status - Durum: 'Online', 'Offline', 'Away', 'Busy'
+         * @returns {Promise<UserResponse>}
+         */
+        async updateStatus(userId, status) {
+            this._validateRequired({ userId: userId, status: status }, ['userId', 'status']);
+            return await this.http.put('/api/users/' + userId + '/status', {
+                status: status
+            });
+        }
+
+        /**
+         * Aktif kullanıcı sayısını getirir
+         * @returns {Promise<{count: number}>}
+         */
+        async getActiveCount() {
+            return await this.http.get('/api/users/active-user-count');
+        }
+
+        /**
+         * Mevcut kullanıcının bildirim ayarlarını getirir
+         * @returns {Promise<NotificationSettingsResponse>}
+         */
+        async getNotificationSettings() {
+            return await this.http.get('/api/users/me/notification-settings');
+        }
+
+        /**
+         * Tutorial'ı tamamlandı olarak işaretler
+         * @param {string} tutorialKey - Tutorial anahtarı
+         * @returns {Promise<{success: boolean}>}
+         */
+        async completeTutorial(tutorialKey) {
+            this._validateRequired({ tutorialKey: tutorialKey }, ['tutorialKey']);
+            return await this.http.post('/api/users/me/setup-guide/' + tutorialKey);
+        }
+
+        /**
+         * Oturumu kapatır
+         * @returns {Promise<{success: boolean}>}
+         */
+        async logout() {
+            return await this.http.get('/api/users/logout');
+        }
+    }
+
+    /**
+     * @typedef {Object} UserResponse
+     * @property {string} _id - Kullanıcı ID
+     * @property {string} siteId - Site ID
+     * @property {string} fullname - İsim
+     * @property {string} email - Email
+     * @property {string} [role] - Rol ID
+     * @property {string[]} [subjects] - Departman ID'leri
+     * @property {string} status - Durum: 'Online', 'Offline', 'Away', 'Busy'
+     * @property {boolean} isOnline - Online mi
+     * @property {string} [profilePicture] - Profil fotoğrafı URL
+     * @property {Date} createdDate - Oluşturulma tarihi
+     * @property {Date} [lastLoginDate] - Son giriş tarihi
+     * @property {Object} [permissions] - İzinler
+     */
+
+    /**
+     * @typedef {Object} NotificationSettingsResponse
+     * @property {boolean} emailNotifications - Email bildirimleri
+     * @property {boolean} pushNotifications - Push bildirimleri
+     * @property {boolean} soundEnabled - Ses açık mı
+     * @property {Object} [channels] - Kanal bazlı ayarlar
+     */
+
+    /**
+     * Tag modülü
+     * Etiket yönetimi
+     * 
+     * @class Tag
+     * @extends BaseModule
+     * @example
+     * // Etiket listele
+     * const tags = await supsis.tag.list();
+     * 
+     * // Etiket oluştur
+     * const tag = await supsis.tag.create({ name: 'VIP', color: '#FF0000' });
+     */
+    class Tag extends BaseModule {
+        /**
+         * Etiketleri listeler
+         * @param {string} [type] - Etiket tipi: 'visitor', 'conversation', 'ticket'
+         * @returns {Promise<TagResponse[]>}
+         * @example
+         * // Tüm etiketler
+         * const allTags = await supsis.tag.list();
+         * 
+         * // Contact etiketleri
+         * const visitorTags = await supsis.tag.list('visitor');
+         */
+        async list(type) {
+            const endpoint = type ? '/api/tags/' + type : '/api/tags';
+            return await this.http.get(endpoint);
+        }
+
+        /**
+         * Etiket oluşturur
+         * @param {Object} data - Etiket verileri
+         * @param {string} data.name - Etiket adı
+         * @param {string} [data.color] - Renk kodu (#RRGGBB)
+         * @param {string} [data.type] - Etiket tipi: 'visitor', 'conversation', 'ticket'
+         * @returns {Promise<TagResponse>}
+         * @example
+         * const tag = await supsis.tag.create({
+         *   name: 'VIP Müşteri',
+         *   color: '#FF0000',
+         *   type: 'visitor'
+         * });
+         */
+        async create(data) {
+            this._validateRequired(data, ['name']);
+            return await this.http.post('/api/tags', data);
+        }
+
+        /**
+         * Etiketi günceller
+         * @param {Object} data - Güncellenecek veriler
+         * @param {string} data._id - Etiket ID'si
+         * @param {string} [data.name] - Yeni ad
+         * @param {string} [data.color] - Yeni renk
+         * @returns {Promise<TagResponse>}
+         */
+        async update(data) {
+            this._validateRequired(data, ['_id']);
+            return await this.http.patch('/api/tags', data);
+        }
+
+        /**
+         * Etiketi siler
+         * @param {string} tagId - Etiket ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(tagId) {
+            this._validateRequired({ tagId: tagId }, ['tagId']);
+            return await this.http.delete('/api/tags/' + tagId);
+        }
+    }
+
+    /**
+     * @typedef {Object} TagResponse
+     * @property {string} _id - Etiket ID
+     * @property {string} siteId - Site ID
+     * @property {string} name - Etiket adı
+     * @property {string} [color] - Renk kodu
+     * @property {string} [type] - Etiket tipi: 'visitor', 'conversation', 'ticket'
+     * @property {Date} createdAt - Oluşturulma tarihi
+     */
+
+    /**
+     * Site modülü
+     * Site bilgileri ve ayarları
+     * 
+     * @class Site
+     * @extends BaseModule
+     * @example
+     * // Site özellikleri
+     * const features = await supsis.site.getFeatures();
+     * 
+     * // Cüzdan bilgisi
+     * const wallet = await supsis.site.getWallet();
+     */
+    class Site extends BaseModule {
+        /**
+         * Mevcut planı getirir
+         * @returns {Promise<PlanResponse>}
+         * @example
+         * const plan = await supsis.site.getCurrentPlan();
+         * console.log(plan.name); // 'Professional'
+         * console.log(plan.features);
+         */
+        async getCurrentPlan() {
+            return await this.http.get('/api/sites/current-plan');
+        }
+
+        /**
+         * Site özelliklerini getirir
+         * @returns {Promise<FeaturesResponse>}
+         * @example
+         * const features = await supsis.site.getFeatures();
+         * console.log(features.whatsapp); // true/false
+         * console.log(features.voiceAgent); // true/false
+         */
+        async getFeatures() {
+            return await this.http.get('/api/sites/features');
+        }
+
+        /**
+         * Cüzdan bilgisini getirir
+         * @returns {Promise<WalletResponse[]>}
+         */
+        async getWallet() {
+            return await this.http.get('/api/sites/wallet');
+        }
+
+        /**
+         * Cüzdan aktivitelerini getirir
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {string} [options.walletType] - Cüzdan tipi
+         * @param {Date|string} [options.startDate] - Başlangıç tarihi
+         * @param {Date|string} [options.endDate] - Bitiş tarihi
+         * @returns {Promise<WalletActivityResponse[]>}
+         */
+        async getWalletActivities(options) {
+            options = options || {};
+            return await this.http.get('/api/sites/wallet/activities', {
+                query: this._cleanObject({
+                    walletType: options.walletType,
+                    startDate: this._toISODate(options.startDate),
+                    endDate: this._toISODate(options.endDate)
+                })
+            });
+        }
+
+        /**
+         * Cüzdana bakiye yükler
+         * @param {string} walletType - Cüzdan tipi (örn: 'whatsapp')
+         * @param {number} amount - Miktar
+         * @returns {Promise<WalletResponse>}
+         */
+        async depositWallet(walletType, amount) {
+            this._validateRequired({ walletType: walletType, amount: amount }, ['walletType', 'amount']);
+            return await this.http.post('/api/sites/wallet/' + walletType, {
+                amount: amount
+            });
+        }
+
+        /**
+         * Otomatik bakiye yükleme ayarlarını getirir
+         * @param {string} walletType - Cüzdan tipi
+         * @returns {Promise<AutoRebalanceResponse>}
+         */
+        async getAutoRebalanceSettings(walletType) {
+            this._validateRequired({ walletType: walletType }, ['walletType']);
+            return await this.http.get('/api/sites/wallet/' + walletType + '/auto-rebalance');
+        }
+
+        /**
+         * Otomatik bakiye yükleme ayarlarını günceller
+         * @param {string} walletType - Cüzdan tipi
+         * @param {Object} settings - Ayarlar
+         * @returns {Promise<AutoRebalanceResponse>}
+         */
+        async updateAutoRebalanceSettings(walletType, settings) {
+            this._validateRequired({ walletType: walletType }, ['walletType']);
+            return await this.http.put('/api/sites/wallet/' + walletType + '/auto-rebalance', settings);
+        }
+
+        /**
+         * Konuşma istatistiklerini getirir
+         * @returns {Promise<ConversationUsageResponse>}
+         */
+        async getConversationUsage() {
+            return await this.http.get('/api/sites/conversation-usages');
+        }
+
+        /**
+         * Depolama kullanımını getirir
+         * @param {Object} [options] - Seçenekler
+         * @returns {Promise<StorageUsageResponse>}
+         */
+        async getStorageUsage(options) {
+            return await this.http.post('/api/sites/storage-usages', options || {});
+        }
+
+        /**
+         * Entegrasyon durumunu kontrol eder
+         * @param {Object} options - Kontrol seçenekleri
+         * @returns {Promise<IntegrationStatusResponse>}
+         */
+        async checkIntegrationStatus(options) {
+            return await this.http.post('/api/public/sites/check-integration-status', options || {});
+        }
+    }
+
+    /**
+     * @typedef {Object} PlanResponse
+     * @property {string} _id - Plan ID
+     * @property {string} name - Plan adı
+     * @property {string} [description] - Açıklama
+     * @property {Object} features - Özellikler
+     * @property {Object} limits - Limitler
+     * @property {Date} [expiresAt] - Bitiş tarihi
+     */
+
+    /**
+     * @typedef {Object} FeaturesResponse
+     * @property {boolean} whatsapp - WhatsApp aktif mi
+     * @property {boolean} instagram - Instagram aktif mi
+     * @property {boolean} voiceAgent - Voice Agent aktif mi
+     * @property {boolean} automation - Otomasyon aktif mi
+     * @property {boolean} chatbot - Chatbot aktif mi
+     * @property {boolean} crm - CRM aktif mi
+     * @property {Object} [limits] - Özellik limitleri
+     */
+
+    /**
+     * @typedef {Object} WalletResponse
+     * @property {string} _id - Cüzdan ID
+     * @property {string} type - Cüzdan tipi
+     * @property {number} amount - Bakiye
+     * @property {string} currency - Para birimi
+     */
+
+    /**
+     * @typedef {Object} WalletActivityResponse
+     * @property {string} _id - Aktivite ID
+     * @property {string} type - Aktivite tipi
+     * @property {number} amount - Miktar
+     * @property {string} description - Açıklama
+     * @property {Date} createdAt - Tarih
+     */
+
+    /**
+     * @typedef {Object} AutoRebalanceResponse
+     * @property {boolean} enabled - Aktif mi
+     * @property {number} threshold - Eşik değer
+     * @property {number} rechargeAmount - Yüklenecek miktar
+     */
+
+    /**
+     * @typedef {Object} ConversationUsageResponse
+     * @property {number} total - Toplam konuşma
+     * @property {number} thisMonth - Bu ay
+     * @property {number} limit - Limit
+     */
+
+    /**
+     * @typedef {Object} StorageUsageResponse
+     * @property {number} used - Kullanılan (bytes)
+     * @property {number} limit - Limit (bytes)
+     * @property {number} percentage - Kullanım yüzdesi
+     */
+
+    /**
+     * @typedef {Object} IntegrationStatusResponse
+     * @property {boolean} integrated - Entegre mi
+     * @property {string} [status] - Durum
+     */
+
+    /**
+     * Cache modülü
+     * Anahtar-değer cache yönetimi (Otomasyon ve Chatbot için)
+     * 
+     * @class Cache
+     * @extends BaseModule
+     * @example
+     * // Cache yaz
+     * await supsis.cache.write('user:123', { name: 'John' }, { expiresIn: { value: 1, unit: 'hours' } });
+     * 
+     * // Cache oku
+     * const data = await supsis.cache.read('user:123');
+     */
+    class Cache extends BaseModule {
+        /**
+         * Cache listesini getirir
+         * @param {Object} [options] - Filtreleme seçenekleri
+         * @param {string} [options.pattern] - Anahtar pattern'i
+         * @param {string} [options.type] - Tip: 'public', 'private'
+         * @param {string} [options.actorType] - Oluşturan: 'chatbot', 'automation', 'api', 'user'
+         * @param {number} [options.page=1] - Sayfa numarası
+         * @param {number} [options.limit=20] - Sayfa başına kayıt
+         * @returns {Promise<{data: CacheResponse[], total: number}>}
+         */
+        async list(options) {
+            options = options || {};
+            const pagination = this._normalizePagination(options);
+            
+            return await this.http.post('/api/cache/list', {
+                pattern: options.pattern,
+                type: options.type,
+                actorType: options.actorType,
+                page: pagination.page,
+                limit: pagination.limit
+            });
+        }
+
+        /**
+         * Cache yazar
+         * @param {string} key - Anahtar
+         * @param {*} value - Değer (herhangi bir JSON-serializable değer)
+         * @param {Object} [options] - Seçenekler
+         * @param {string} [options.type='public'] - Tip: 'public', 'private'
+         * @param {string} [options.dataType='mixed'] - Veri tipi: 'string', 'number', 'boolean', 'date', 'json', 'array', 'mixed'
+         * @param {Object} [options.expiresIn] - Geçerlilik süresi
+         * @param {number} options.expiresIn.value - Süre değeri
+         * @param {string} options.expiresIn.unit - Birim: 'seconds', 'minutes', 'hours', 'days', 'weeks', 'months'
+         * @param {Date|string} [options.expiresAt] - Kesin bitiş tarihi
+         * @returns {Promise<CacheResponse>}
+         * @example
+         * // 1 saat geçerli cache
+         * await supsis.cache.write('session:abc', { userId: '123' }, {
+         *   expiresIn: { value: 1, unit: 'hours' }
+         * });
+         * 
+         * // Belirli bir tarihe kadar geçerli
+         * await supsis.cache.write('promo:summer', { discount: 20 }, {
+         *   expiresAt: '2024-08-31T23:59:59Z'
+         * });
+         */
+        async write(key, value, options) {
+            this._validateRequired({ key: key }, ['key']);
+            options = options || {};
+            
+            const body = {
+                key: key,
+                value: value,
+                type: options.type || 'public',
+                dataType: options.dataType || 'mixed'
+            };
+
+            // expiresIn varsa expiresAt'e çevir
+            if (options.expiresIn) {
+                const now = new Date();
+                const multipliers = {
+                    seconds: 1000,
+                    minutes: 60 * 1000,
+                    hours: 60 * 60 * 1000,
+                    days: 24 * 60 * 60 * 1000,
+                    weeks: 7 * 24 * 60 * 60 * 1000,
+                    months: 30 * 24 * 60 * 60 * 1000
+                };
+                const ms = options.expiresIn.value * (multipliers[options.expiresIn.unit] || multipliers.hours);
+                body.expiresAt = new Date(now.getTime() + ms).toISOString();
+            } else if (options.expiresAt) {
+                body.expiresAt = this._toISODate(options.expiresAt);
+            }
+
+            return await this.http.post('/api/cache/write', body);
+        }
+
+        /**
+         * Cache okur
+         * @param {string} key - Anahtar
+         * @param {*} [defaultValue=null] - Bulunamazsa dönecek değer
+         * @returns {Promise<*>} Cache değeri veya defaultValue
+         * @example
+         * const session = await supsis.cache.read('session:abc');
+         * const count = await supsis.cache.read('counter', 0);
+         */
+        async read(key, defaultValue) {
+            this._validateRequired({ key: key }, ['key']);
+            
+            try {
+                const result = await this.http.post('/api/cache/list', {
+                    pattern: key,
+                    limit: 1
+                });
+                
+                if (result && result.data && result.data.length > 0) {
+                    return result.data[0].value;
+                }
+                return defaultValue !== undefined ? defaultValue : null;
+            } catch (e) {
+                return defaultValue !== undefined ? defaultValue : null;
+            }
+        }
+
+        /**
+         * Cache değerini günceller
+         * @param {string} cacheId - Cache ID'si
+         * @param {*} value - Yeni değer
+         * @returns {Promise<CacheResponse>}
+         */
+        async update(cacheId, value) {
+            this._validateRequired({ cacheId: cacheId }, ['cacheId']);
+            return await this.http.post('/api/cache/' + cacheId + '/update', {
+                value: value
+            });
+        }
+
+        /**
+         * Cache süresini uzatır
+         * @param {string} cacheId - Cache ID'si
+         * @param {Object} expiresIn - Uzatma süresi
+         * @param {number} expiresIn.value - Süre değeri
+         * @param {string} expiresIn.unit - Birim
+         * @returns {Promise<CacheResponse>}
+         * @example
+         * await supsis.cache.extend('cacheId', { value: 1, unit: 'hours' });
+         */
+        async extend(cacheId, expiresIn) {
+            this._validateRequired({ cacheId: cacheId, expiresIn: expiresIn }, ['cacheId', 'expiresIn']);
+            
+            const multipliers = {
+                seconds: 1000,
+                minutes: 60 * 1000,
+                hours: 60 * 60 * 1000,
+                days: 24 * 60 * 60 * 1000,
+                weeks: 7 * 24 * 60 * 60 * 1000,
+                months: 30 * 24 * 60 * 60 * 1000
+            };
+            
+            const now = new Date();
+            const ms = expiresIn.value * (multipliers[expiresIn.unit] || multipliers.hours);
+            const newExpiresAt = new Date(now.getTime() + ms);
+
+            return await this.http.post('/api/cache/' + cacheId + '/extend', {
+                expiresAt: newExpiresAt.toISOString()
+            });
+        }
+
+        /**
+         * Cache'i sonsuz yapar (süresiz)
+         * @param {string} cacheId - Cache ID'si
+         * @returns {Promise<CacheResponse>}
+         */
+        async makeNeverExpire(cacheId) {
+            this._validateRequired({ cacheId: cacheId }, ['cacheId']);
+            return await this.http.post('/api/cache/' + cacheId + '/never-expire');
+        }
+
+        /**
+         * Cache siler
+         * @param {string} cacheId - Cache ID'si
+         * @returns {Promise<{success: boolean}>}
+         */
+        async delete(cacheId) {
+            this._validateRequired({ cacheId: cacheId }, ['cacheId']);
+            return await this.http.delete('/api/cache/' + cacheId);
+        }
+
+        /**
+         * Birden fazla cache siler
+         * @param {string[]} cacheIds - Cache ID'leri
+         * @returns {Promise<{success: boolean, deletedCount: number}>}
+         */
+        async deleteMany(cacheIds) {
+            this._validateRequired({ cacheIds: cacheIds }, ['cacheIds']);
+            return await this.http.post('/api/cache/bulk-delete', {
+                cacheIds: cacheIds
+            });
+        }
+
+        /**
+         * Belirli bir actor'ün cache'lerini siler
+         * @param {string} actorType - Actor tipi: 'chatbot', 'automation'
+         * @param {string} actorId - Actor ID'si
+         * @returns {Promise<{success: boolean, deletedCount: number}>}
+         */
+        async deleteByActor(actorType, actorId) {
+            this._validateRequired({ actorType: actorType, actorId: actorId }, ['actorType', 'actorId']);
+            return await this.http.post('/api/cache/delete-by-actor', {
+                actorType: actorType,
+                actorId: actorId
+            });
+        }
+
+        /**
+         * Pattern'e göre cache siler
+         * @param {string} pattern - Anahtar pattern'i
+         * @returns {Promise<{success: boolean, deletedCount: number}>}
+         */
+        async deleteByPattern(pattern) {
+            this._validateRequired({ pattern: pattern }, ['pattern']);
+            return await this.http.post('/api/cache/delete-by-pattern', {
+                pattern: pattern
+            });
+        }
+    }
+
+    /**
+     * @typedef {Object} CacheResponse
+     * @property {string} _id - Cache ID
+     * @property {string} siteId - Site ID
+     * @property {string} key - Anahtar
+     * @property {*} value - Değer
+     * @property {string} type - Tip: 'public', 'private'
+     * @property {string} dataType - Veri tipi
+     * @property {string} createdByActorType - Oluşturan actor tipi
+     * @property {string} [createdByAutomation] - Oluşturan otomasyon ID
+     * @property {string} [createdByChatbot] - Oluşturan chatbot ID
+     * @property {string} [createdByUser] - Oluşturan kullanıcı ID
+     * @property {Date} [expiresAt] - Bitiş tarihi
+     * @property {Date} createdAt - Oluşturulma tarihi
+     * @property {Date} updatedAt - Güncellenme tarihi
+     */
+
+    /**
+     * Supsis API SDK Ana Sınıfı
+     * 
+     * Browser ve Node.js ortamlarında çalışan, Supsis API'sine erişim sağlayan SDK.
+     * Email/password ile authentication yaparak tüm API'lere erişim sağlar.
+     * 
+     * @class SupsisJS
+     * @example
+     * // Temel kullanım
+     * const supsis = new SupsisJS({
+     *   email: 'user@example.com',
+     *   password: 'secret',
+     *   siteId: 'site123'
+     * });
+     * 
+     * await supsis.connect();
+     * 
+     * const chat = await supsis.chat.get('chatId');
+     * const contacts = await supsis.contact.list({ limit: 10 });
+     * 
+     * @example
+     * // Stage ortamında kullanım
+     * const supsis = new SupsisJS({
+     *   email: 'dev@example.com',
+     *   password: 'secret',
+     *   siteId: 'site123',
+     *   env: 'stage'
+     * });
+     * 
+     * @example
+     * // OnPrem kurulum
+     * const supsis = new SupsisJS({
+     *   email: 'user@company.com',
+     *   password: 'secret',
+     *   siteId: 'site123',
+     *   baseApiAddress: 'https://api.company-supsis.com'
+     * });
+     */
+    class SupsisJS {
+        /**
+         * SupsisJS instance oluşturur
+         * @param {SupsisConfig} config - SDK konfigürasyonu
+         */
+        constructor(config) {
+            if (!config) {
+                throw new Error('Config is required');
+            }
+            
+            this._validateConfig(config);
+            
+            /** @private */
+            this._config = config;
+            
+            /** @private */
+            this._http = new HttpClient({
+                env: config.env || 'production',
+                baseApiAddress: config.baseApiAddress,
+                siteId: config.siteId,
+                timeout: config.timeout,
+                retryCount: config.retryCount
+            });
+            
+            /** @private */
+            this._connected = false;
+            
+            /** @private */
+            this._token = null;
+            
+            /** @private */
+            this._user = null;
+            
+            // Modülleri oluştur
+            this._initModules();
+        }
+
+        /**
+         * Config validasyonu
+         * @private
+         */
+        _validateConfig(config) {
+            if (!config.email) {
+                throw new Error('email is required');
+            }
+            if (!config.password) {
+                throw new Error('password is required');
+            }
+            if (!config.siteId) {
+                throw new Error('siteId is required');
+            }
+        }
+
+        /**
+         * Modülleri initialize eder
+         * @private
+         */
+        _initModules() {
+            /**
+             * Chat (Conversation) modülü
+             * @type {Chat}
+             */
+            this.chat = new Chat(this._http);
+            
+            /**
+             * Contact (Visitor) modülü
+             * @type {Contact}
+             */
+            this.contact = new Contact(this._http);
+            
+            /**
+             * Message modülü
+             * @type {Message}
+             */
+            this.message = new Message(this._http);
+            
+            /**
+             * Task modülü
+             * @type {Task}
+             */
+            this.task = new Task(this._http);
+            
+            /**
+             * AI Call (Voice Agent) modülü
+             * @type {AICall}
+             */
+            this.aicall = new AICall(this._http);
+            
+            /**
+             * Asset modülü
+             * @type {Asset}
+             */
+            this.asset = new Asset(this._http);
+            
+            /**
+             * Table (CustomerTable) modülü
+             * @type {Table}
+             */
+            this.table = new Table(this._http);
+            
+            /**
+             * Module (Dynamic Modules) modülü
+             * @type {Module}
+             */
+            this.module = new Module(this._http);
+            
+            /**
+             * User modülü
+             * @type {User}
+             */
+            this.user = new User(this._http);
+            
+            /**
+             * Tag modülü
+             * @type {Tag}
+             */
+            this.tag = new Tag(this._http);
+            
+            /**
+             * Site modülü
+             * @type {Site}
+             */
+            this.site = new Site(this._http);
+            
+            /**
+             * Cache modülü
+             * @type {Cache}
+             */
+            this.cache = new Cache(this._http);
+        }
+
+        /**
+         * API'ye bağlanır (login yapar)
+         * @returns {Promise<UserResponse>} Giriş yapan kullanıcı bilgisi
+         * @throws {SupsisAPIError} Login başarısız olduğunda
+         * @example
+         * await supsis.connect();
+         * console.log('Connected as:', supsis.currentUser.fullname);
+         */
+        async connect() {
+            if (this._connected) {
+                return this._user;
+            }
+
+            const response = await this._http.post('/api/users/login', {
+                email: this._config.email,
+                password: this._config.password
+            }, { skipAuth: true });
+
+            if (!response || !response.token) {
+                throw new SupsisAPIError('Login failed: No token received', 401);
+            }
+
+            this._token = response.token;
+            this._user = response.user || response;
+            this._http.setToken(this._token);
+            this._connected = true;
+
+            return this._user;
+        }
+
+        /**
+         * Bağlantıyı kapatır (logout yapar)
+         * @returns {Promise<void>}
+         */
+        async disconnect() {
+            if (!this._connected) {
+                return;
+            }
+
+            try {
+                await this._http.get('/api/users/logout');
+            } catch (e) {
+                // Logout hatası ignore edilebilir
+            }
+
+            this._token = null;
+            this._user = null;
+            this._http.setToken(null);
+            this._connected = false;
+        }
+
+        /**
+         * Bağlı mı kontrol eder
+         * @returns {boolean}
+         */
+        get isConnected() {
+            return this._connected;
+        }
+
+        /**
+         * Mevcut kullanıcı bilgisi
+         * @returns {UserResponse|null}
+         */
+        get currentUser() {
+            return this._user;
+        }
+
+        /**
+         * Mevcut token
+         * @returns {string|null}
+         */
+        get token() {
+            return this._token;
+        }
+
+        /**
+         * SDK versiyonu
+         * @returns {string}
+         */
+        get version() {
+            return SDK_VERSION;
+        }
+
+        /**
+         * HttpClient'a direkt erişim (gelişmiş kullanım için)
+         * @returns {HttpClient}
+         */
+        get http() {
+            return this._http;
+        }
+
+        /**
+         * Mevcut token'ı manuel olarak set eder (örn: önceden alınmış token ile)
+         * @param {string} token - JWT token
+         */
+        setToken(token) {
+            this._token = token;
+            this._http.setToken(token);
+            this._connected = true;
+        }
+    }
+
+    /**
+     * @typedef {Object} SupsisConfig
+     * @property {string} email - Kullanıcı email adresi
+     * @property {string} password - Kullanıcı şifresi
+     * @property {string} siteId - Site ID (multi-tenant)
+     * @property {string} [env='production'] - Ortam: 'production', 'stage', 'local'
+     * @property {string} [baseApiAddress] - Custom API adresi (OnPrem için)
+     * @property {number} [timeout=30000] - HTTP istek timeout süresi (ms)
+     * @property {number} [retryCount=3] - Başarısız isteklerde retry sayısı
+     */
+
+    /**
+     * @typedef {Object} UserResponse
+     * @property {string} _id - Kullanıcı ID
+     * @property {string} fullname - İsim
+     * @property {string} email - Email
+     * @property {string} [role] - Rol
+     * @property {Object} [permissions] - İzinler
+     */
+
+    /**
+     * Supsis Module API Sınıfı
+     * 
+     * Developer access token ile çalışan kısıtlı API erişimi.
+     * Panelden alınan access token ile direkt kullanılabilir.
+     * 
+     * @class SupsisModuleAPI
+     * @example
+     * const api = new SupsisModuleAPI({
+     *   accessToken: 'dev_token_xxx',
+     *   siteId: 'site123'
+     * });
+     * 
+     * const records = await api.module.listRecords('Leads');
+     * const tables = await api.table.list();
+     */
+    class SupsisModuleAPI {
+        /**
+         * SupsisModuleAPI instance oluşturur
+         * @param {ModuleAPIConfig} config - API konfigürasyonu
+         */
+        constructor(config) {
+            if (!config) {
+                throw new Error('Config is required');
+            }
+            
+            if (!config.accessToken) {
+                throw new Error('accessToken is required');
+            }
+            
+            if (!config.siteId) {
+                throw new Error('siteId is required');
+            }
+            
+            /** @private */
+            this._config = config;
+            
+            /** @private */
+            this._http = new HttpClient({
+                env: config.env || 'production',
+                baseApiAddress: config.baseApiAddress,
+                siteId: config.siteId,
+                timeout: config.timeout,
+                retryCount: config.retryCount
+            });
+            
+            // Token'ı set et
+            this._http.setToken(config.accessToken);
+            
+            // Modülleri oluştur
+            this._initModules();
+        }
+
+        /**
+         * Modülleri initialize eder
+         * @private
+         */
+        _initModules() {
+            /**
+             * Table (CustomerTable) modülü
+             * @type {Table}
+             */
+            this.table = new Table(this._http);
+            
+            /**
+             * Module (Dynamic Modules) modülü
+             * @type {Module}
+             */
+            this.module = new Module(this._http);
+            
+            /**
+             * Cache modülü
+             * @type {Cache}
+             */
+            this.cache = new Cache(this._http);
+        }
+
+        /**
+         * SDK versiyonu
+         * @returns {string}
+         */
+        get version() {
+            return SDK_VERSION;
+        }
+
+        /**
+         * HttpClient'a direkt erişim (gelişmiş kullanım için)
+         * @returns {HttpClient}
+         */
+        get http() {
+            return this._http;
+        }
+
+        /**
+         * Access token'ı günceller
+         * @param {string} token - Yeni access token
+         */
+        setAccessToken(token) {
+            this._http.setToken(token);
+        }
+    }
+
+    /**
+     * @typedef {Object} ModuleAPIConfig
+     * @property {string} accessToken - Developer access token (panelden alınır)
+     * @property {string} siteId - Site ID (multi-tenant)
+     * @property {string} [env='production'] - Ortam: 'production', 'stage', 'local'
+     * @property {string} [baseApiAddress] - Custom API adresi (OnPrem için)
+     * @property {number} [timeout=30000] - HTTP istek timeout süresi (ms)
+     * @property {number} [retryCount=3] - Başarısız isteklerde retry sayısı
+     */
+
+    /**
+     * Supsis JS SDK
+     * 
+     * Browser ve Node.js ortamlarında çalışan, Supsis API'sine erişim sağlayan SDK.
+     * 
+     * @module @supsis/supsis-js
+     * @version 1.0.0
+     * @author Supsis <info@supsis.com>
+     * @license MIT
+     * 
+     * @example
+     * // Browser (UMD)
+     * const supsis = new SupsisJS({
+     *   email: 'user@example.com',
+     *   password: 'secret',
+     *   siteId: 'site123'
+     * });
+     * await supsis.connect();
+     * 
+     * @example
+     * // Node.js (CommonJS)
+     * const { SupsisJS, SupsisModuleAPI } = require('@supsis/supsis-js');
+     * 
+     * @example
+     * // Node.js (ESM)
+     * import { SupsisJS, SupsisModuleAPI } from '@supsis/supsis-js';
+     */
+
+    exports.AICall = AICall;
+    exports.Asset = Asset;
+    exports.BaseModule = BaseModule;
+    exports.Cache = Cache;
+    exports.Chat = Chat;
+    exports.Contact = Contact;
+    exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+    exports.ENVIRONMENTS = ENVIRONMENTS;
+    exports.HttpClient = HttpClient;
+    exports.Message = Message;
+    exports.Module = Module;
+    exports.SDK_VERSION = SDK_VERSION;
+    exports.Site = Site;
+    exports.SupsisAPIError = SupsisAPIError;
+    exports.SupsisJS = SupsisJS;
+    exports.SupsisModuleAPI = SupsisModuleAPI;
+    exports.Table = Table;
+    exports.Tag = Tag;
+    exports.Task = Task;
+    exports.User = User;
+    exports.default = SupsisJS;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));