acecoderz-chat-ui 1.0.0

package/dist/core/src/ChatEngine.js

@@ -0,0 +1,357 @@
+import { checkUrlWhitelist, getWhitelistErrorMessage } from './urlWhitelist';
+import { apiLogger } from './apiLogger';
+export class ChatEngine {
+    constructor(config) {
+        this.messages = [];
+        this.input = '';
+        this.isLoading = false;
+        this.error = null;
+        this.ws = null;
+        this.listeners = new Map();
+        this.abortController = null;
+        this.conversationId = null; // Track conversation ID for context
+        this.config = config;
+        this.initializeWebSocket();
+    }
+    // Event emitter pattern for reactivity
+    on(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(callback);
+        return () => this.off(event, callback);
+    }
+    off(event, callback) {
+        this.listeners.get(event)?.delete(callback);
+    }
+    emit(event, data) {
+        this.listeners.get(event)?.forEach(callback => callback(data));
+    }
+    // Getters
+    getMessages() {
+        return [...this.messages];
+    }
+    getInput() {
+        return this.input;
+    }
+    getIsLoading() {
+        return this.isLoading;
+    }
+    getError() {
+        return this.error;
+    }
+    getConversationId() {
+        return this.conversationId;
+    }
+    // Methods
+    setInput(value) {
+        this.input = value;
+        this.emit('inputChange', value);
+    }
+    async sendMessage(content) {
+        console.log('[ChatEngine] sendMessage called', { content, input: this.input, isLoading: this.isLoading });
+        const message = (content || this.input).trim();
+        console.log('[ChatEngine] Message after trim:', message);
+        if (!message || this.isLoading) {
+            console.log('[ChatEngine] Early return - message empty or loading', { message, isLoading: this.isLoading });
+            return;
+        }
+        // Add user message
+        const userMessage = {
+            id: Date.now().toString(),
+            content: message,
+            role: 'user',
+            timestamp: new Date(),
+        };
+        this.messages.push(userMessage);
+        this.input = '';
+        this.emit('inputChange', '');
+        this.emit('messagesChange', this.messages);
+        this.emit('message', userMessage);
+        this.config.onMessage?.(userMessage);
+        this.isLoading = true;
+        this.error = null;
+        this.emit('loadingChange', true);
+        this.emit('error', null);
+        // Cancel previous request if exists
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+        this.abortController = new AbortController();
+        try {
+            console.log('[ChatEngine] Starting API call process', {
+                enableUrlWhitelistCheck: this.config.enableUrlWhitelistCheck,
+                apiUrl: this.config.apiUrl,
+                enableWebSocket: this.config.enableWebSocket,
+                wsReadyState: this.ws?.readyState,
+            });
+            // Check URL whitelist if enabled (default: true)
+            if (this.config.enableUrlWhitelistCheck !== false && this.config.apiUrl) {
+                console.log('[ChatEngine] Checking URL whitelist...', this.config.apiUrl);
+                try {
+                    const whitelistCheck = await checkUrlWhitelist(this.config.apiUrl);
+                    console.log('[ChatEngine] Whitelist check result:', whitelistCheck);
+                    if (!whitelistCheck.isWhitelisted) {
+                        const origin = typeof window !== 'undefined' ? window.location.origin : 'unknown';
+                        const errorMessage = whitelistCheck.error || getWhitelistErrorMessage(origin);
+                        console.error('[ChatEngine] URL not whitelisted:', errorMessage);
+                        const error = new Error(errorMessage);
+                        this.error = error;
+                        this.emit('error', error);
+                        this.config.onError?.(error);
+                        this.isLoading = false;
+                        this.emit('loadingChange', false);
+                        return;
+                    }
+                }
+                catch (whitelistError) {
+                    console.error('[ChatEngine] Whitelist check failed with error:', whitelistError);
+                    // Allow the request to proceed if whitelist check fails (backward compatibility)
+                    console.warn('[ChatEngine] Proceeding despite whitelist check error');
+                }
+            }
+            else {
+                console.log('[ChatEngine] Skipping URL whitelist check', {
+                    enableUrlWhitelistCheck: this.config.enableUrlWhitelistCheck,
+                    hasApiUrl: !!this.config.apiUrl,
+                });
+            }
+            // Send via WebSocket if enabled
+            if (this.config.enableWebSocket && this.ws?.readyState === WebSocket.OPEN) {
+                console.log('[ChatEngine] Sending via WebSocket');
+                this.ws.send(JSON.stringify({
+                    type: 'message',
+                    content: message,
+                    role: 'user',
+                }));
+                // WebSocket responses are handled in onmessage handler
+                this.isLoading = false;
+                this.emit('loadingChange', false);
+                return;
+            }
+            // Send via HTTP API
+            console.log('[ChatEngine] Sending message to backend:', message);
+            const response = await this.sendToBackend(message);
+            console.log('[ChatEngine] Backend response:', response);
+            // Store conversation ID from response to maintain context
+            if (response.conversationId) {
+                this.conversationId = response.conversationId;
+            }
+            const assistantMessage = {
+                id: response.id || Date.now().toString(),
+                content: response.message || response.content || '',
+                role: 'assistant',
+                timestamp: new Date(response.timestamp || Date.now()),
+                metadata: response.metadata,
+            };
+            this.messages.push(assistantMessage);
+            this.emit('messagesChange', this.messages);
+            this.emit('message', assistantMessage);
+            this.config.onMessage?.(assistantMessage);
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                return;
+            }
+            this.error = err instanceof Error ? err : new Error('Failed to send message');
+            this.emit('error', this.error);
+            this.config.onError?.(this.error);
+        }
+        finally {
+            this.isLoading = false;
+            this.emit('loadingChange', false);
+        }
+    }
+    async sendToBackend(message) {
+        if (!this.config.apiUrl) {
+            throw new Error('API URL is required');
+        }
+        const url = `${this.config.apiUrl}/chat`;
+        console.log('[ChatEngine] Making API call to:', url);
+        const startTime = Date.now();
+        const requestBody = {
+            message,
+            conversationId: this.conversationId || undefined, // Use stored conversation ID for context
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            ...this.config.headers,
+        };
+        if (this.config.apiKey) {
+            headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+        }
+        // Log request
+        const logEntry = {
+            timestamp: new Date().toISOString(),
+            url,
+            method: 'POST',
+            requestHeaders: { ...headers },
+            requestBody: { ...requestBody },
+        };
+        // Mask sensitive data in logs
+        if (logEntry.requestHeaders && logEntry.requestHeaders['Authorization']) {
+            logEntry.requestHeaders['Authorization'] = logEntry.requestHeaders['Authorization'].substring(0, 20) + '...';
+        }
+        try {
+            console.log('[ChatEngine] About to fetch:', {
+                url,
+                method: 'POST',
+                headers,
+                body: requestBody,
+            });
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(requestBody),
+                signal: this.abortController?.signal,
+            });
+            console.log('[ChatEngine] Fetch completed, status:', response.status);
+            const duration = Date.now() - startTime;
+            logEntry.duration = duration;
+            // Try to get response body (may be JSON or text)
+            let responseBody = null;
+            const contentType = response.headers.get('content-type');
+            try {
+                if (contentType && contentType.includes('application/json')) {
+                    responseBody = await response.json();
+                }
+                else {
+                    const text = await response.text();
+                    try {
+                        responseBody = JSON.parse(text);
+                    }
+                    catch {
+                        responseBody = text;
+                    }
+                }
+            }
+            catch (err) {
+                // Failed to parse response body
+                responseBody = null;
+            }
+            // Log response
+            logEntry.responseStatus = response.status;
+            logEntry.responseHeaders = Object.fromEntries(response.headers.entries());
+            logEntry.responseBody = responseBody;
+            if (!response.ok) {
+                // Try to extract error message from response
+                let errorMessage = `HTTP error! status: ${response.status}`;
+                if (response.status === 403) {
+                    // Likely a whitelist error
+                    try {
+                        const errorData = responseBody;
+                        if (errorData?.error?.message) {
+                            errorMessage = errorData.error.message;
+                        }
+                        else {
+                            const origin = typeof window !== 'undefined' ? window.location.origin : 'unknown';
+                            errorMessage = getWhitelistErrorMessage(origin);
+                        }
+                    }
+                    catch {
+                        const origin = typeof window !== 'undefined' ? window.location.origin : 'unknown';
+                        errorMessage = getWhitelistErrorMessage(origin);
+                    }
+                }
+                else if (responseBody?.error?.message) {
+                    errorMessage = responseBody.error.message;
+                }
+                else if (typeof responseBody === 'string') {
+                    errorMessage = responseBody;
+                }
+                logEntry.error = errorMessage;
+                apiLogger.log(logEntry);
+                throw new Error(errorMessage);
+            }
+            // Log successful response
+            apiLogger.log(logEntry);
+            return responseBody;
+        }
+        catch (err) {
+            const duration = Date.now() - startTime;
+            logEntry.duration = duration;
+            logEntry.error = err instanceof Error ? err.message : String(err);
+            apiLogger.log(logEntry);
+            throw err;
+        }
+    }
+    initializeWebSocket() {
+        if (this.config.enableWebSocket && this.config.websocketUrl) {
+            try {
+                this.ws = new WebSocket(this.config.websocketUrl);
+                this.ws.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        if (data.type === 'message') {
+                            const message = {
+                                id: data.id || Date.now().toString(),
+                                content: data.content,
+                                role: data.role || 'assistant',
+                                timestamp: new Date(data.timestamp || Date.now()),
+                                metadata: data.metadata,
+                            };
+                            this.messages.push(message);
+                            this.emit('messagesChange', this.messages);
+                            this.emit('message', message);
+                            this.config.onMessage?.(message);
+                            this.isLoading = false;
+                            this.emit('loadingChange', false);
+                        }
+                    }
+                    catch (err) {
+                        const error = err instanceof Error ? err : new Error('Failed to parse WebSocket message');
+                        this.error = error;
+                        this.emit('error', error);
+                        this.config.onError?.(error);
+                    }
+                };
+                this.ws.onerror = () => {
+                    const error = new Error('WebSocket error');
+                    this.error = error;
+                    this.emit('error', error);
+                    this.config.onError?.(error);
+                };
+                this.ws.onclose = () => {
+                    // WebSocket closed
+                };
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to initialize WebSocket');
+                this.error = error;
+                this.emit('error', error);
+                this.config.onError?.(error);
+            }
+        }
+    }
+    addMessage(message) {
+        this.messages.push(message);
+        this.emit('messagesChange', this.messages);
+        this.emit('message', message);
+        this.config.onMessage?.(message);
+    }
+    clearMessages() {
+        this.messages = [];
+        this.conversationId = null; // Clear conversation ID when clearing messages
+        this.error = null;
+        this.emit('messagesChange', this.messages);
+        this.emit('error', null);
+    }
+    retryLastMessage() {
+        const lastUserMessage = [...this.messages].reverse().find((m) => m.role === 'user');
+        if (lastUserMessage) {
+            // Remove the last user message and assistant response
+            const index = this.messages.findIndex((m) => m.id === lastUserMessage.id);
+            if (index >= 0) {
+                this.messages = this.messages.slice(0, index);
+                this.emit('messagesChange', this.messages);
+            }
+            return this.sendMessage(lastUserMessage.content);
+        }
+        return Promise.resolve();
+    }
+    destroy() {
+        this.ws?.close();
+        this.abortController?.abort();
+        this.listeners.clear();
+    }
+}

package/dist/core/src/apiLogger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * API Logger - Logs API calls to a file
+ */
+export interface ApiLogEntry {
+    timestamp: string;
+    url: string;
+    method: string;
+    requestHeaders?: Record<string, string>;
+    requestBody?: any;
+    responseStatus?: number;
+    responseHeaders?: Record<string, string>;
+    responseBody?: any;
+    duration?: number;
+    error?: string;
+}
+declare class ApiLogger {
+    private logs;
+    private maxLogs;
+    private enabled;
+    /**
+     * Enable or disable logging
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Log an API call
+     */
+    log(entry: ApiLogEntry): void;
+    /**
+     * Get all logs
+     */
+    getLogs(): ApiLogEntry[];
+    /**
+     * Clear all logs
+     */
+    clearLogs(): void;
+    /**
+     * Export logs to a file
+     */
+    exportToFile(filename?: string): Promise<void>;
+    /**
+     * Export logs as text file (human-readable format)
+     */
+    exportToTextFile(filename?: string): Promise<void>;
+}
+export declare const apiLogger: ApiLogger;
+export { ApiLogger };
+//# sourceMappingURL=apiLogger.d.ts.map

package/dist/core/src/apiLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiLogger.d.ts","sourceRoot":"","sources":["../../../core/src/apiLogger.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,cAAM,SAAS;IACb,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,OAAO,CAAiB;IAEhC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAkC7B;;OAEG;IACH,OAAO,IAAI,WAAW,EAAE;IAIxB;;OAEG;IACH,SAAS,IAAI,IAAI;IAIjB;;OAEG;IACG,YAAY,CAAC,QAAQ,GAAE,MAA0E,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDvH;;OAEG;IACG,gBAAgB,CAAC,QAAQ,GAAE,MAAyE,GAAG,OAAO,CAAC,IAAI,CAAC;CAqF3H;AAGD,eAAO,MAAM,SAAS,WAAkB,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/core/src/apiLogger.js

@@ -0,0 +1,199 @@
+/**
+ * API Logger - Logs API calls to a file
+ */
+class ApiLogger {
+    constructor() {
+        this.logs = [];
+        this.maxLogs = 1000; // Maximum number of logs to keep in memory
+        this.enabled = true;
+    }
+    /**
+     * Enable or disable logging
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Log an API call
+     */
+    log(entry) {
+        if (!this.enabled)
+            return;
+        this.logs.push(entry);
+        // Keep only the last maxLogs entries
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        // Also log to console in development
+        // Check for development mode (browser-compatible)
+        let isDev = false;
+        if (typeof window !== 'undefined') {
+            isDev = window.location?.hostname === 'localhost' ||
+                window.location?.hostname === '127.0.0.1';
+        }
+        // Check Node.js process.env if available (using globalThis to avoid TS errors)
+        if (!isDev) {
+            try {
+                const proc = globalThis.process;
+                if (proc && proc.env && proc.env.NODE_ENV === 'development') {
+                    isDev = true;
+                }
+            }
+            catch {
+                // process not available (browser environment)
+            }
+        }
+        if (isDev) {
+            console.log('[API Logger]', entry);
+        }
+    }
+    /**
+     * Get all logs
+     */
+    getLogs() {
+        return [...this.logs];
+    }
+    /**
+     * Clear all logs
+     */
+    clearLogs() {
+        this.logs = [];
+    }
+    /**
+     * Export logs to a file
+     */
+    async exportToFile(filename = `api-logs-${new Date().toISOString().replace(/[:.]/g, '-')}.json`) {
+        if (this.logs.length === 0) {
+            console.warn('[API Logger] No logs to export');
+            return;
+        }
+        const logData = {
+            exportedAt: new Date().toISOString(),
+            totalLogs: this.logs.length,
+            logs: this.logs,
+        };
+        const jsonString = JSON.stringify(logData, null, 2);
+        const blob = new Blob([jsonString], { type: 'application/json' });
+        // Try to use File System Access API if available (Chrome/Edge)
+        if ('showSaveFilePicker' in window) {
+            try {
+                const fileHandle = await window.showSaveFilePicker({
+                    suggestedName: filename,
+                    types: [{
+                            description: 'JSON files',
+                            accept: { 'application/json': ['.json'] },
+                        }],
+                });
+                const writable = await fileHandle.createWritable();
+                await writable.write(blob);
+                await writable.close();
+                console.log(`[API Logger] Logs saved to file: ${filename}`);
+                return;
+            }
+            catch (err) {
+                // User cancelled or error occurred, fall back to download
+                if (err.name !== 'AbortError') {
+                    console.warn('[API Logger] File System Access API failed, falling back to download:', err);
+                }
+                else {
+                    return; // User cancelled
+                }
+            }
+        }
+        // Fallback: Download file
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        console.log(`[API Logger] Logs downloaded as: ${filename}`);
+    }
+    /**
+     * Export logs as text file (human-readable format)
+     */
+    async exportToTextFile(filename = `api-logs-${new Date().toISOString().replace(/[:.]/g, '-')}.txt`) {
+        if (this.logs.length === 0) {
+            console.warn('[API Logger] No logs to export');
+            return;
+        }
+        let textContent = `API Call Logs\n`;
+        textContent += `Exported at: ${new Date().toISOString()}\n`;
+        textContent += `Total logs: ${this.logs.length}\n`;
+        textContent += `${'='.repeat(80)}\n\n`;
+        this.logs.forEach((log, index) => {
+            textContent += `[${index + 1}] ${log.timestamp}\n`;
+            textContent += `URL: ${log.method} ${log.url}\n`;
+            if (log.requestHeaders) {
+                textContent += `Request Headers:\n`;
+                Object.entries(log.requestHeaders).forEach(([key, value]) => {
+                    // Mask sensitive headers
+                    if (key.toLowerCase() === 'authorization') {
+                        textContent += `  ${key}: ${value.substring(0, 20)}...\n`;
+                    }
+                    else {
+                        textContent += `  ${key}: ${value}\n`;
+                    }
+                });
+            }
+            if (log.requestBody) {
+                textContent += `Request Body:\n${JSON.stringify(log.requestBody, null, 2)}\n`;
+            }
+            if (log.error) {
+                textContent += `Error: ${log.error}\n`;
+            }
+            else if (log.responseStatus) {
+                textContent += `Response Status: ${log.responseStatus}\n`;
+                if (log.responseBody) {
+                    textContent += `Response Body:\n${JSON.stringify(log.responseBody, null, 2)}\n`;
+                }
+            }
+            if (log.duration !== undefined) {
+                textContent += `Duration: ${log.duration}ms\n`;
+            }
+            textContent += `${'-'.repeat(80)}\n\n`;
+        });
+        const blob = new Blob([textContent], { type: 'text/plain' });
+        // Try to use File System Access API if available
+        if ('showSaveFilePicker' in window) {
+            try {
+                const fileHandle = await window.showSaveFilePicker({
+                    suggestedName: filename,
+                    types: [{
+                            description: 'Text files',
+                            accept: { 'text/plain': ['.txt'] },
+                        }],
+                });
+                const writable = await fileHandle.createWritable();
+                await writable.write(blob);
+                await writable.close();
+                console.log(`[API Logger] Logs saved to file: ${filename}`);
+                return;
+            }
+            catch (err) {
+                if (err.name !== 'AbortError') {
+                    console.warn('[API Logger] File System Access API failed, falling back to download:', err);
+                }
+                else {
+                    return;
+                }
+            }
+        }
+        // Fallback: Download file
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        console.log(`[API Logger] Logs downloaded as: ${filename}`);
+    }
+}
+// Singleton instance
+export const apiLogger = new ApiLogger();
+// Export the class for custom instances if needed
+export { ApiLogger };

package/dist/core/src/index.d.ts

@@ -0,0 +1,7 @@
+export { ChatEngine } from './ChatEngine';
+export type { Message, ChatConfig, ChatTheme, ChatEventType, ChatEventListener } from './types';
+export { checkUrlWhitelist, getWhitelistErrorMessage } from './urlWhitelist';
+export type { WhitelistCheckResult } from './urlWhitelist';
+export { apiLogger, ApiLogger } from './apiLogger';
+export type { ApiLogEntry } from './apiLogger';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../core/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAChG,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/core/src/index.js

@@ -0,0 +1,3 @@
+export { ChatEngine } from './ChatEngine';
+export { checkUrlWhitelist, getWhitelistErrorMessage } from './urlWhitelist';
+export { apiLogger, ApiLogger } from './apiLogger';

package/dist/core/src/types.d.ts

@@ -0,0 +1,62 @@
+export interface Message {
+    id: string;
+    content: string;
+    role: 'user' | 'assistant' | 'system';
+    timestamp: Date;
+    metadata?: Record<string, any>;
+}
+export interface ChatConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    onMessage?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    enableWebSocket?: boolean;
+    websocketUrl?: string;
+    /**
+     * Enable URL whitelist checking before making API calls
+     * @default true
+     */
+    enableUrlWhitelistCheck?: boolean;
+}
+export interface ChatTheme {
+    primaryColor?: string;
+    secondaryColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    userMessageColor?: string;
+    assistantMessageColor?: string;
+    inputBackgroundColor?: string;
+    inputTextColor?: string;
+    errorBackgroundColor?: string;
+    errorTextColor?: string;
+    borderColor?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    lineHeight?: string;
+    padding?: string;
+    messageGap?: string;
+    inputPadding?: string;
+    messagePadding?: string;
+    borderRadius?: string;
+    messageBorderRadius?: string;
+    inputBorderRadius?: string;
+    borderWidth?: string;
+    boxShadow?: string;
+    messageBoxShadow?: string;
+    inputBoxShadow?: string;
+    maxHeight?: string;
+    maxWidth?: string;
+    messageMaxWidth?: string;
+    avatarSize?: string;
+    transitionDuration?: string;
+    animationDuration?: string;
+    scrollbarWidth?: string;
+    scrollbarColor?: string;
+    scrollbarTrackColor?: string;
+    customCSS?: string;
+}
+export type ChatEventType = 'messagesChange' | 'inputChange' | 'loadingChange' | 'error' | 'message';
+export type ChatEventListener = (data?: any) => void;
+//# sourceMappingURL=types.d.ts.map