@supsis/supsis-js 1.0.0

package/dist/supsis.cjs.js

@@ -0,0 +1,4069 @@
+/**
+ * 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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 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;