@vserifsaglam/chat-react-client 1.0.2

package/dist/index.js

@@ -0,0 +1,3075 @@
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var React = require('react');
+var React__default = _interopDefault(React);
+var axios = _interopDefault(require('axios'));
+var socket_ioClient = require('socket.io-client');
+
+// A type of promise-like that resolves synchronously and supports only one observer
+const _Pact = /*#__PURE__*/(function() {
+	function _Pact() {}
+	_Pact.prototype.then = function(onFulfilled, onRejected) {
+		const result = new _Pact();
+		const state = this.s;
+		if (state) {
+			const callback = state & 1 ? onFulfilled : onRejected;
+			if (callback) {
+				try {
+					_settle(result, 1, callback(this.v));
+				} catch (e) {
+					_settle(result, 2, e);
+				}
+				return result;
+			} else {
+				return this;
+			}
+		}
+		this.o = function(_this) {
+			try {
+				const value = _this.v;
+				if (_this.s & 1) {
+					_settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+				} else if (onRejected) {
+					_settle(result, 1, onRejected(value));
+				} else {
+					_settle(result, 2, value);
+				}
+			} catch (e) {
+				_settle(result, 2, e);
+			}
+		};
+		return result;
+	};
+	return _Pact;
+})();
+
+// Settles a pact synchronously
+function _settle(pact, state, value) {
+	if (!pact.s) {
+		if (value instanceof _Pact) {
+			if (value.s) {
+				if (state & 1) {
+					state = value.s;
+				}
+				value = value.v;
+			} else {
+				value.o = _settle.bind(null, pact, state);
+				return;
+			}
+		}
+		if (value && value.then) {
+			value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+			return;
+		}
+		pact.s = state;
+		pact.v = value;
+		const observer = pact.o;
+		if (observer) {
+			observer(pact);
+		}
+	}
+}
+
+function _isSettledPact(thenable) {
+	return thenable instanceof _Pact && thenable.s & 1;
+}
+
+const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
+
+const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
+
+// Asynchronously implement a generic for loop
+function _for(test, update, body) {
+	var stage;
+	for (;;) {
+		var shouldContinue = test();
+		if (_isSettledPact(shouldContinue)) {
+			shouldContinue = shouldContinue.v;
+		}
+		if (!shouldContinue) {
+			return result;
+		}
+		if (shouldContinue.then) {
+			stage = 0;
+			break;
+		}
+		var result = body();
+		if (result && result.then) {
+			if (_isSettledPact(result)) {
+				result = result.s;
+			} else {
+				stage = 1;
+				break;
+			}
+		}
+		if (update) {
+			var updateValue = update();
+			if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+				stage = 2;
+				break;
+			}
+		}
+	}
+	var pact = new _Pact();
+	var reject = _settle.bind(null, pact, 2);
+	(stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+	return pact;
+	function _resumeAfterBody(value) {
+		result = value;
+		do {
+			if (update) {
+				updateValue = update();
+				if (updateValue && updateValue.then && !_isSettledPact(updateValue)) {
+					updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+					return;
+				}
+			}
+			shouldContinue = test();
+			if (!shouldContinue || (_isSettledPact(shouldContinue) && !shouldContinue.v)) {
+				_settle(pact, 1, result);
+				return;
+			}
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+				return;
+			}
+			result = body();
+			if (_isSettledPact(result)) {
+				result = result.v;
+			}
+		} while (!result || !result.then);
+		result.then(_resumeAfterBody).then(void 0, reject);
+	}
+	function _resumeAfterTest(shouldContinue) {
+		if (shouldContinue) {
+			result = body();
+			if (result && result.then) {
+				result.then(_resumeAfterBody).then(void 0, reject);
+			} else {
+				_resumeAfterBody(result);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+	function _resumeAfterUpdate() {
+		if (shouldContinue = test()) {
+			if (shouldContinue.then) {
+				shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+			} else {
+				_resumeAfterTest(shouldContinue);
+			}
+		} else {
+			_settle(pact, 1, result);
+		}
+	}
+}
+
+// Asynchronously call a function and send errors to recovery continuation
+function _catch(body, recover) {
+	try {
+		var result = body();
+	} catch(e) {
+		return recover(e);
+	}
+	if (result && result.then) {
+		return result.then(void 0, recover);
+	}
+	return result;
+}
+
+// Asynchronously await a promise and pass the result to a finally continuation
+function _finallyRethrows(body, finalizer) {
+	try {
+		var result = body();
+	} catch (e) {
+		return finalizer(true, e);
+	}
+	if (result && result.then) {
+		return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+	}
+	return finalizer(false, result);
+}
+
+var ChatApi = /*#__PURE__*/function () {
+  function ChatApi(config) {
+    this.client = axios.create({
+      baseURL: config.baseUrl,
+      headers: {
+        Authorization: "Bearer " + config.token,
+        'Content-Type': 'application/json',
+        'x-requesting-client-id': config.client_id
+      }
+    });
+  }
+  var _proto = ChatApi.prototype;
+  _proto.healthCheck = function healthCheck() {
+    try {
+      var _this = this;
+      return Promise.resolve(_this.client.get('/api/health')).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.listConversations = function listConversations(archived, clientIds) {
+    try {
+      var _this2 = this;
+      var params = {};
+      if (archived !== undefined) params.archived = String(archived);
+      if (clientIds) params.client_ids = clientIds;
+      return Promise.resolve(_this2.client.get('/api/chat/conversations', {
+        params: params
+      })).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.deleteConversation = function deleteConversation(conversationUid) {
+    try {
+      var _this3 = this;
+      return Promise.resolve(_this3.client["delete"]("/api/chat/conversations/" + conversationUid + "/delete")).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.archiveConversation = function archiveConversation(conversationUid) {
+    try {
+      var _this4 = this;
+      return Promise.resolve(_this4.client.post("/api/chat/conversations/" + conversationUid + "/archive")).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.unarchiveConversation = function unarchiveConversation(conversationUid) {
+    try {
+      var _this5 = this;
+      return Promise.resolve(_this5.client.post("/api/chat/conversations/" + conversationUid + "/unarchive")).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getConversationDetails = function getConversationDetails(conversationUid) {
+    try {
+      var _this6 = this;
+      return Promise.resolve(_this6.client.get("/api/chat/conversations/" + conversationUid + "/details")).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getConversationWithReceiver = function getConversationWithReceiver(receiverId) {
+    try {
+      var _this7 = this;
+      return Promise.resolve(_this7.client.get("/api/chat/conversations/with/" + receiverId)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.searchConversation = function searchConversation(conversationUid, term) {
+    try {
+      var _this8 = this;
+      return Promise.resolve(_this8.client.get("/api/chat/conversations/" + conversationUid + "/search", {
+        params: {
+          term: term
+        }
+      })).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getMessages = function getMessages(conversationUid, page, pageSize) {
+    if (page === void 0) {
+      page = 1;
+    }
+    if (pageSize === void 0) {
+      pageSize = 20;
+    }
+    try {
+      var _this9 = this;
+      return Promise.resolve(_this9.client.get("/api/messages/" + conversationUid + "/list", {
+        params: {
+          page: page,
+          page_size: pageSize
+        }
+      })).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.markMessageAsRead = function markMessageAsRead(messageId) {
+    try {
+      var _this0 = this;
+      return Promise.resolve(_this0.client.post("/api/messages/" + messageId + "/read")).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.sendMessage = function sendMessage(message) {
+    try {
+      var _this1 = this;
+      return Promise.resolve(_this1.client.post('/api/messages/send-message', message)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.markConversationAsRead = function markConversationAsRead(conversationUid) {
+    try {
+      var _this10 = this;
+      return Promise.resolve(_this10.client.post("/api/messages/conversation/" + conversationUid + "/read")).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.updateMessage = function updateMessage(messageId, update) {
+    try {
+      var _this11 = this;
+      return Promise.resolve(_this11.client.put("/api/messages/" + messageId, update)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.deleteMessage = function deleteMessage(messageId) {
+    try {
+      var _this12 = this;
+      return Promise.resolve(_this12.client["delete"]("/api/messages/" + messageId)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.uploadFile = function uploadFile(file) {
+    try {
+      var _this13 = this;
+      var formData = new FormData();
+      formData.append('file', file);
+      var config = {
+        headers: {
+          'Content-Type': 'multipart/form-data'
+        }
+      };
+      return Promise.resolve(_this13.client.post('/api/files/upload', formData, config)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.banClient = function banClient(request) {
+    try {
+      var _this14 = this;
+      return Promise.resolve(_this14.client.post('/api/bans/client', request)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.unbanClient = function unbanClient(request) {
+    try {
+      var _this15 = this;
+      return Promise.resolve(_this15.client["delete"]('/api/bans/client', {
+        data: request
+      })).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.adminBanClient = function adminBanClient(request) {
+    try {
+      var _this16 = this;
+      return Promise.resolve(_this16.client.post('/api/bans/admin', request)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.adminUnbanClient = function adminUnbanClient(request) {
+    try {
+      var _this17 = this;
+      return Promise.resolve(_this17.client["delete"]('/api/bans/admin', {
+        data: request
+      })).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.checkBanStatus = function checkBanStatus(clientId) {
+    try {
+      var _this18 = this;
+      return Promise.resolve(_this18.client.get("/api/bans/status/" + clientId)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getClientProfile = function getClientProfile() {
+    try {
+      var _this19 = this;
+      return Promise.resolve(_this19.client.get('/api/clients/profile')).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getClientPreferences = function getClientPreferences() {
+    try {
+      var _this20 = this;
+      return Promise.resolve(_this20.client.get('/api/clients/preferences')).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.updateClientPreferences = function updateClientPreferences(request) {
+    try {
+      var _this21 = this;
+      return Promise.resolve(_this21.client.put('/api/clients/preferences', request)).then(function (response) {
+        return response.data;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  return ChatApi;
+}();
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+(function (ConnectionType) {
+  ConnectionType["WebSocket"] = "websocket";
+  ConnectionType["LongPolling"] = "longpolling";
+})(exports.ConnectionType || (exports.ConnectionType = {}));
+(function (ConnectionStatus) {
+  ConnectionStatus["Connected"] = "connected";
+  ConnectionStatus["Connecting"] = "connecting";
+  ConnectionStatus["Disconnected"] = "disconnected";
+  ConnectionStatus["Error"] = "error";
+})(exports.ConnectionStatus || (exports.ConnectionStatus = {}));
+(function (EventType) {
+  EventType["MessageSent"] = "message_sent";
+  EventType["MessageEdited"] = "message_edited";
+  EventType["MessageDeleted"] = "message_deleted";
+  EventType["MessageReceived"] = "message_received";
+  EventType["MessageRead"] = "message_read";
+  EventType["ConversationRead"] = "conversation_read";
+})(exports.EventType || (exports.EventType = {}));
+
+(function (LogLevel) {
+  LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+  LogLevel[LogLevel["INFO"] = 1] = "INFO";
+  LogLevel[LogLevel["WARN"] = 2] = "WARN";
+  LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+  LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(exports.LogLevel || (exports.LogLevel = {}));
+var Logger = /*#__PURE__*/function () {
+  function Logger(config) {
+    if (config === void 0) {
+      config = {};
+    }
+    this.config = _extends({
+      enabled: false,
+      level: exports.LogLevel.INFO,
+      prefix: '[ChatWS]',
+      timestamp: true,
+      includeData: true,
+      prettyPrint: true
+    }, config);
+  }
+  var _proto = Logger.prototype;
+  _proto.shouldLog = function shouldLog(level) {
+    return this.config.enabled && level >= this.config.level;
+  };
+  _proto.formatMessage = function formatMessage(level, message) {
+    var parts = [];
+    if (this.config.timestamp) {
+      parts.push("[" + new Date().toISOString() + "]");
+    }
+    if (this.config.prefix) {
+      parts.push(this.config.prefix);
+    }
+    parts.push("[" + level + "]");
+    parts.push(message);
+    return parts.join(' ');
+  };
+  _proto.formatData = function formatData(data) {
+    if (!this.config.includeData || !data) return undefined;
+    try {
+      var cloned = JSON.parse(JSON.stringify(data));
+      this.maskSensitiveData(cloned);
+      return this.config.prettyPrint ? cloned : JSON.stringify(cloned);
+    } catch (err) {
+      var _data$constructor;
+      return "[Object: " + ((data === null || data === void 0 ? void 0 : (_data$constructor = data.constructor) === null || _data$constructor === void 0 ? void 0 : _data$constructor.name) || typeof data) + "]";
+    }
+  };
+  _proto.maskSensitiveData = function maskSensitiveData(obj) {
+    var _this = this;
+    if (!obj || typeof obj !== 'object') return;
+    var sensitiveKeys = ['token', 'password', 'auth', 'authorization', 'api_key', 'apiKey', 'secret'];
+    var _loop = function _loop() {
+      var lowerKey = key.toLowerCase();
+      if (sensitiveKeys.some(function (sensitive) {
+        return lowerKey.includes(sensitive);
+      })) {
+        obj[key] = '***MASKED***';
+      } else if (typeof obj[key] === 'object') {
+        _this.maskSensitiveData(obj[key]);
+      }
+    };
+    for (var key in obj) {
+      _loop();
+    }
+  };
+  _proto.debug = function debug(message, data) {
+    if (!this.shouldLog(exports.LogLevel.DEBUG)) return;
+    var formatted = this.formatMessage('DEBUG', message);
+    var formattedData = this.formatData(data);
+    if (formattedData !== undefined) {
+      console.log(formatted, formattedData);
+    } else {
+      console.log(formatted);
+    }
+  };
+  _proto.info = function info(message, data) {
+    if (!this.shouldLog(exports.LogLevel.INFO)) return;
+    var formatted = this.formatMessage('INFO', message);
+    var formattedData = this.formatData(data);
+    if (formattedData !== undefined) {
+      console.info(formatted, formattedData);
+    } else {
+      console.info(formatted);
+    }
+  };
+  _proto.warn = function warn(message, data) {
+    if (!this.shouldLog(exports.LogLevel.WARN)) return;
+    var formatted = this.formatMessage('WARN', message);
+    var formattedData = this.formatData(data);
+    if (formattedData !== undefined) {
+      console.warn(formatted, formattedData);
+    } else {
+      console.warn(formatted);
+    }
+  };
+  _proto.error = function error(message, data) {
+    if (!this.shouldLog(exports.LogLevel.ERROR)) return;
+    var formatted = this.formatMessage('ERROR', message);
+    var formattedData = this.formatData(data);
+    if (formattedData !== undefined) {
+      console.error(formatted, formattedData);
+    } else {
+      console.error(formatted);
+    }
+  };
+  _proto.group = function group(label) {
+    if (!this.config.enabled) return;
+    console.group(this.formatMessage('GROUP', label));
+  };
+  _proto.groupEnd = function groupEnd() {
+    if (!this.config.enabled) return;
+    console.groupEnd();
+  };
+  _proto.time = function time(label) {
+    if (!this.config.enabled) return;
+    console.time(this.config.prefix + " " + label);
+  };
+  _proto.timeEnd = function timeEnd(label) {
+    if (!this.config.enabled) return;
+    console.timeEnd(this.config.prefix + " " + label);
+  };
+  _proto.updateConfig = function updateConfig(config) {
+    this.config = _extends({}, this.config, config);
+  };
+  _proto.getConfig = function getConfig() {
+    return _extends({}, this.config);
+  };
+  return Logger;
+}();
+
+var DEFAULT_CONFIG = {
+  type: exports.ConnectionType.WebSocket,
+  autoReconnect: true,
+  reconnectAttempts: 5,
+  reconnectDelay: 3000,
+  logging: {
+    enabled: false,
+    level: exports.LogLevel.INFO
+  },
+  onlyLongpolling: false,
+  degradeWsOnFailure: true,
+  wsFailureThreshold: 3,
+  wsDegradeTTLms: 24 * 60 * 60 * 1000,
+  forceWebSocket: false
+};
+var QUEUE_KEY = 'chat_queue';
+var ConnectionManager = /*#__PURE__*/function () {
+  function ConnectionManager(auth, api, options) {
+    var _this$cfg$logging;
+    if (options === void 0) {
+      options = {};
+    }
+    this.socket = null;
+    this.status = exports.ConnectionStatus.Disconnected;
+    this.eventListeners = new Map();
+    this.statusListeners = [];
+    this.errorListeners = [];
+    this.queue = [];
+    this.processingQueue = false;
+    this.connecting = false;
+    this.reconnectCount = 0;
+    this.wsFailCount = 0;
+    this.isDegraded = false;
+    this.auth = auth;
+    this.api = api;
+    this.cfg = _extends({}, DEFAULT_CONFIG, options);
+    this.logger = new Logger(this.cfg.logging || {});
+    this.logger.info('ConnectionManager initialized', {
+      config: {
+        type: this.cfg.type,
+        autoReconnect: this.cfg.autoReconnect,
+        reconnectAttempts: this.cfg.reconnectAttempts,
+        reconnectDelay: this.cfg.reconnectDelay,
+        loggingEnabled: (_this$cfg$logging = this.cfg.logging) === null || _this$cfg$logging === void 0 ? void 0 : _this$cfg$logging.enabled
+      }
+    });
+    if (typeof window !== 'undefined') {
+      var saved = sessionStorage.getItem(QUEUE_KEY);
+      if (saved) {
+        try {
+          var _this$queue;
+          var parsed = JSON.parse(saved);
+          (_this$queue = this.queue).push.apply(_this$queue, parsed);
+          this.logger.debug('Loaded queued messages from session storage', {
+            count: parsed.length
+          });
+        } catch (err) {
+          this.logger.warn('Failed to parse queued messages from session storage', err);
+        }
+      }
+      var degradeUntil = this.getDegradeUntil();
+      if (degradeUntil && Date.now() < degradeUntil && !this.cfg.forceWebSocket) {
+        this.isDegraded = true;
+        this.logger.info('WebSocket degraded mode active from persisted state', {
+          degradeUntil: degradeUntil
+        });
+      } else if (degradeUntil && Date.now() >= degradeUntil) {
+        this.clearDegradation();
+      }
+      this.wsFailCount = this.getFailCount();
+    }
+  }
+  ConnectionManager.getInstance = function getInstance(auth, api, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    if (!ConnectionManager.instance) {
+      ConnectionManager.instance = new ConnectionManager(auth, api, options);
+    }
+    return ConnectionManager.instance;
+  };
+  ConnectionManager.resetInstance = function resetInstance() {
+    if (ConnectionManager.instance) {
+      ConnectionManager.instance.disconnect();
+      ConnectionManager.instance = null;
+    }
+  };
+  var _proto = ConnectionManager.prototype;
+  _proto.connect = function connect() {
+    if (this.status === exports.ConnectionStatus.Connected || this.status === exports.ConnectionStatus.Connecting || this.connecting) {
+      this.logger.debug('Connect called but already connected/connecting', {
+        status: this.status,
+        connecting: this.connecting
+      });
+      return;
+    }
+    this.logger.info('Initiating connection', {
+      socketUrl: this.auth.socketBaseUrl
+    });
+    this.connecting = true;
+    this.setStatus(exports.ConnectionStatus.Connecting);
+    this.connectWS();
+  };
+  _proto.disconnect = function disconnect() {
+    var _this$socket;
+    this.logger.info('Disconnecting from websocket');
+    this.clearTimers();
+    (_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.disconnect();
+    this.socket = null;
+    this.connecting = false;
+    this.setStatus(exports.ConnectionStatus.Disconnected);
+    this.logger.info('Disconnected successfully');
+  };
+  _proto.getStatus = function getStatus() {
+    return this.status;
+  };
+  _proto.queueMessage = function queueMessage(msg, maxAttempts) {
+    if (maxAttempts === void 0) {
+      maxAttempts = 3;
+    }
+    var id = typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : (Date.now() + Math.random()).toString(36);
+    var queuedMessage = {
+      id: id,
+      message: msg,
+      attempts: 0,
+      maxAttempts: maxAttempts,
+      timestamp: Date.now()
+    };
+    this.logger.debug('Queueing message', {
+      messageId: id,
+      receiver: msg.receiver_client_id,
+      hasContent: !!msg.content,
+      hasAttachments: !!(msg.attachments && msg.attachments.length > 0),
+      maxAttempts: maxAttempts
+    });
+    this.queue.push(queuedMessage);
+    this.saveQueue();
+    this.processQueue();
+    return id;
+  };
+  _proto.on = function on(evt, cb) {
+    this.add(this.eventListeners, evt, cb);
+  };
+  _proto.off = function off(evt, cb) {
+    this.remove(this.eventListeners, evt, cb);
+  };
+  _proto.emit = function emit(evt) {
+    var _this$socket2;
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    this.logger.debug('Emitting event', {
+      event: evt,
+      args: args.length > 0 ? args : undefined
+    });
+    (_this$socket2 = this.socket).emit.apply(_this$socket2, [evt].concat(args));
+  };
+  _proto.onStatusChange = function onStatusChange(cb) {
+    this.statusListeners.push(cb);
+  };
+  _proto.offStatusChange = function offStatusChange(cb) {
+    var i = this.statusListeners.indexOf(cb);
+    if (i !== -1) this.statusListeners.splice(i, 1);
+  };
+  _proto.onError = function onError(cb) {
+    this.errorListeners.push(cb);
+  };
+  _proto.offError = function offError(cb) {
+    var i = this.errorListeners.indexOf(cb);
+    if (i !== -1) this.errorListeners.splice(i, 1);
+  };
+  _proto.updateLogging = function updateLogging(config) {
+    this.logger.updateConfig(config);
+    this.logger.info('Logging configuration updated', config);
+  };
+  _proto.getLoggingConfig = function getLoggingConfig() {
+    return this.logger.getConfig();
+  };
+  _proto.connectWS = function connectWS() {
+    var _this = this;
+    try {
+      this.logger.debug('Starting WebSocket connection', {
+        url: this.auth.socketBaseUrl,
+        hasExistingSocket: !!this.socket,
+        degraded: this.isDegraded
+      });
+      if (this.socket) {
+        this.logger.debug('Cleaning up existing socket connection');
+        this.socket.removeAllListeners();
+        this.socket.disconnect();
+      }
+      var socketOpts = this.buildSocketOpts();
+      this.logger.debug('Creating socket with options', socketOpts);
+      this.socket = socket_ioClient.io(this.auth.socketBaseUrl, socketOpts);
+      try {
+        var manager = this.socket.io;
+        var engine = manager === null || manager === void 0 ? void 0 : manager.engine;
+        if (engine && typeof engine.on === 'function') {
+          engine.on('upgrade', function (transport) {
+            var name = (transport === null || transport === void 0 ? void 0 : transport.name) || transport;
+            _this.logger.info('Engine.io upgrade success', {
+              transport: name
+            });
+            if (name === 'websocket') {
+              _this.resetWsFailures();
+              if (_this.isDegraded) {
+                _this.logger.info('Exiting degraded mode after successful websocket upgrade');
+                _this.clearDegradation();
+                _this.isDegraded = false;
+              }
+            }
+          });
+          engine.on('upgradeError', function (err) {
+            _this.logger.warn('Engine.io upgrade error', {
+              error: (err === null || err === void 0 ? void 0 : err.message) || err
+            });
+            _this.onWsFailure();
+          });
+        }
+      } catch (wiringErr) {
+        this.logger.debug('Unable to wire engine.io upgrade listeners', {
+          error: (wiringErr === null || wiringErr === void 0 ? void 0 : wiringErr.message) || wiringErr
+        });
+      }
+      this.socket.on('connect', function () {
+        _this.logger.info('WebSocket connected successfully', {
+          socketId: _this.socket.id,
+          reconnectCount: _this.reconnectCount
+        });
+        _this.connecting = false;
+        _this.reconnectCount = 0;
+        _this.setStatus(exports.ConnectionStatus.Connected);
+        _this.processQueue();
+      });
+      this.socket.on('connect_error', function (err) {
+        _this.logger.error('WebSocket connection error', {
+          error: err.message,
+          type: err.type || 'unknown',
+          reconnectCount: _this.reconnectCount
+        });
+        _this.connecting = false;
+        if (!_this.isDegraded && !_this.cfg.onlyLongpolling && !_this.cfg.forceWebSocket) {
+          _this.onWsFailure();
+        }
+        _this.handleConnError(err);
+      });
+      this.socket.on('disconnect', function (reason) {
+        _this.logger.info('WebSocket disconnected', {
+          reason: reason,
+          willReconnect: _this.cfg.autoReconnect
+        });
+        _this.connecting = false;
+        _this.setStatus(exports.ConnectionStatus.Disconnected);
+        _this.scheduleReconnect();
+      });
+      if (this.logger.getConfig().level <= exports.LogLevel.DEBUG) {
+        this.socket.on('ping', function () {
+          _this.logger.debug('Socket.io ping sent');
+        });
+        this.socket.on('pong', function (latency) {
+          _this.logger.debug('Socket.io pong received', {
+            latency: latency
+          });
+        });
+      }
+      Object.values(exports.EventType).forEach(function (evt) {
+        _this.socket.on(evt, function (data) {
+          _this.logger.debug('Received realtime event', {
+            event: evt,
+            data: data
+          });
+          _this.handleEvent({
+            type: evt,
+            data: data
+          });
+        });
+      });
+      this.logger.debug('WebSocket event listeners registered', {
+        events: Object.values(exports.EventType)
+      });
+    } catch (err) {
+      this.logger.error('WebSocket initialization failed', err);
+      this.connecting = false;
+      this.handleConnError(err);
+    }
+  };
+  _proto.buildSocketOpts = function buildSocketOpts() {
+    var isBrowser = typeof window !== 'undefined';
+    var headers = _extends({}, this.cfg.headers, {
+      Authorization: "Bearer " + this.auth.token
+    });
+    var transports = ['websocket'];
+    var degraded = this.isDegraded && !this.cfg.forceWebSocket;
+    if (this.cfg.onlyLongpolling || degraded) {
+      transports = ['polling'];
+    } else if (this.cfg.type === exports.ConnectionType.LongPolling) {
+      transports = ['polling', 'websocket'];
+    } else {
+      transports = ['websocket', 'polling'];
+    }
+    var opts = {
+      reconnection: false,
+      rememberUpgrade: !this.cfg.onlyLongpolling && !degraded,
+      timeout: 20000,
+      auth: _extends({
+        token: this.auth.token
+      }, this.cfg.extraAuth || {}),
+      transports: transports,
+      upgrade: !this.cfg.onlyLongpolling && !degraded
+    };
+    if (!isBrowser) {
+      opts.transportOptions = {
+        polling: {
+          extraHeaders: headers
+        },
+        websocket: {
+          extraHeaders: headers
+        }
+      };
+    } else if (this.cfg.type === exports.ConnectionType.LongPolling || this.cfg.onlyLongpolling) {
+      var query = {};
+      if (this.cfg.extraAuth) {
+        Object.entries(this.cfg.extraAuth).forEach(function (_ref) {
+          var key = _ref[0],
+            value = _ref[1];
+          query[key] = String(value);
+        });
+      }
+      opts.query = query;
+    }
+    this.logger.debug('Socket options built', {
+      isBrowser: isBrowser,
+      hasExtraAuth: !!this.cfg.extraAuth,
+      hasHeaders: !!this.cfg.headers,
+      timeout: opts.timeout,
+      transports: opts.transports,
+      onlyLongpolling: this.cfg.onlyLongpolling,
+      degraded: degraded,
+      rememberUpgrade: opts.rememberUpgrade,
+      upgrade: opts.upgrade
+    });
+    return opts;
+  };
+  _proto.handleConnError = function handleConnError(err) {
+    var _this2 = this;
+    this.logger.error('Connection error occurred', {
+      error: (err === null || err === void 0 ? void 0 : err.message) || err,
+      errorType: (err === null || err === void 0 ? void 0 : err.type) || 'unknown',
+      willReconnect: this.cfg.autoReconnect && this.reconnectCount < this.cfg.reconnectAttempts
+    });
+    this.setStatus(exports.ConnectionStatus.Error);
+    this.errorListeners.forEach(function (cb) {
+      try {
+        cb(err);
+      } catch (listenerErr) {
+        _this2.logger.warn('Error in error listener', listenerErr);
+      }
+    });
+    this.clearTimers();
+    this.scheduleReconnect();
+  };
+  _proto.processQueue = function processQueue() {
+    try {
+      var _temp3 = function _temp3() {
+        _this3.processingQueue = false;
+        if (_this3.queue.length) {
+          _this3.logger.debug('Queue still has messages, scheduling next processing', {
+            remainingMessages: _this3.queue.length
+          });
+          setTimeout(function () {
+            return _this3.processQueue();
+          }, 100);
+        }
+      };
+      var _interrupt = false;
+      var _this3 = this;
+      if (_this3.processingQueue || _this3.status !== exports.ConnectionStatus.Connected) {
+        _this3.logger.debug('Skipping queue processing', {
+          processingQueue: _this3.processingQueue,
+          status: _this3.status,
+          queueLength: _this3.queue.length
+        });
+        return Promise.resolve();
+      }
+      if (_this3.queue.length === 0) {
+        _this3.logger.debug('Queue is empty, nothing to process');
+        return Promise.resolve();
+      }
+      _this3.logger.debug('Starting queue processing', {
+        queueLength: _this3.queue.length
+      });
+      _this3.processingQueue = true;
+      var _temp2 = _for(function () {
+        return !_interrupt && !!_this3.queue.length && _this3.status === exports.ConnectionStatus.Connected;
+      }, void 0, function () {
+        var q = _this3.queue[0];
+        q.attempts += 1;
+        _this3.logger.debug('Processing queued message', {
+          messageId: q.id,
+          attempt: q.attempts,
+          maxAttempts: q.maxAttempts,
+          age: Date.now() - q.timestamp
+        });
+        var _temp = _catch(function () {
+          return Promise.resolve(_this3.sendMessageHttp(q.message)).then(function () {
+            _this3.logger.info('Queued message sent successfully', {
+              messageId: q.id,
+              attempts: q.attempts
+            });
+            _this3.queue.shift();
+            _this3.saveQueue();
+          });
+        }, function (err) {
+          _this3.logger.error("Failed to send queued message (attempt " + q.attempts + "/" + q.maxAttempts + ")", {
+            messageId: q.id,
+            error: err
+          });
+          if (q.attempts >= q.maxAttempts) {
+            _this3.logger.warn('Message exceeded max attempts, removing from queue', {
+              messageId: q.id
+            });
+            _this3.queue.shift();
+          }
+          _this3.saveQueue();
+          _interrupt = true;
+        });
+        if (_temp && _temp.then) return _temp.then(function () {});
+      });
+      return Promise.resolve(_temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.sendMessageHttp = function sendMessageHttp(msg) {
+    try {
+      var _this4 = this;
+      _this4.logger.debug('Sending message via HTTP', {
+        receiver: msg.receiver_client_id,
+        hasContent: !!msg.content,
+        hasAttachments: !!(msg.attachments && msg.attachments.length > 0)
+      });
+      _this4.logger.time('sendMessage');
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(_this4.api.sendMessage(msg)).then(function () {
+          _this4.logger.timeEnd('sendMessage');
+          _this4.logger.debug('Message sent successfully via HTTP');
+        });
+      }, function (err) {
+        _this4.logger.timeEnd('sendMessage');
+        _this4.logger.error('Failed to send message via HTTP', err);
+        throw err;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.handleEvent = function handleEvent(evt) {
+    var _this5 = this;
+    var listeners = this.eventListeners.get(evt.type) || [];
+    this.logger.debug('Handling event', {
+      type: evt.type,
+      listenerCount: listeners.length,
+      hasData: !!evt.data
+    });
+    listeners.forEach(function (cb, index) {
+      try {
+        cb(evt);
+      } catch (err) {
+        _this5.logger.error("Event listener error for " + evt.type, {
+          listenerIndex: index,
+          error: err
+        });
+      }
+    });
+  };
+  _proto.setStatus = function setStatus(s) {
+    var _this6 = this;
+    if (this.status === s) {
+      this.logger.debug('Status unchanged', {
+        status: s
+      });
+      return;
+    }
+    var oldStatus = this.status;
+    this.status = s;
+    this.logger.info('Connection status changed', {
+      from: oldStatus,
+      to: s,
+      listenerCount: this.statusListeners.length
+    });
+    this.statusListeners.forEach(function (cb, index) {
+      try {
+        cb(s);
+      } catch (e) {
+        _this6.logger.error('Status listener error', {
+          listenerIndex: index,
+          error: e
+        });
+      }
+    });
+  };
+  _proto.scheduleReconnect = function scheduleReconnect() {
+    var _this7 = this;
+    if (!this.cfg.autoReconnect) {
+      this.logger.debug('Auto-reconnect disabled, not scheduling reconnect');
+      return;
+    }
+    if (this.reconnectCount >= this.cfg.reconnectAttempts) {
+      this.logger.warn('Max reconnect attempts reached', {
+        reconnectCount: this.reconnectCount,
+        maxAttempts: this.cfg.reconnectAttempts
+      });
+      return;
+    }
+    this.reconnectCount += 1;
+    this.logger.info('Scheduling reconnect', {
+      attempt: this.reconnectCount,
+      maxAttempts: this.cfg.reconnectAttempts,
+      delayMs: this.cfg.reconnectDelay
+    });
+    setTimeout(function () {
+      _this7.logger.debug('Executing scheduled reconnect', {
+        attempt: _this7.reconnectCount
+      });
+      _this7.connect();
+    }, this.cfg.reconnectDelay);
+  };
+  _proto.clearTimers = function clearTimers() {};
+  _proto.saveQueue = function saveQueue() {
+    if (typeof window === 'undefined') return;
+    try {
+      sessionStorage.setItem(QUEUE_KEY, JSON.stringify(this.queue));
+      this.logger.debug('Queue saved to session storage', {
+        count: this.queue.length
+      });
+    } catch (err) {
+      this.logger.warn('Failed to save queue to session storage', err);
+    }
+  };
+  _proto.add = function add(m, k, cb) {
+    if (!m.has(k)) m.set(k, []);
+    m.get(k).push(cb);
+  };
+  _proto.remove = function remove(m, k, cb) {
+    var arr = m.get(k);
+    if (!arr) return;
+    var i = arr.indexOf(cb);
+    if (i !== -1) arr.splice(i, 1);
+  };
+  _proto.storageAvailable = function storageAvailable() {
+    try {
+      if (typeof window === 'undefined') return false;
+      var testKey = '__wsdeg__';
+      window.localStorage.setItem(testKey, '1');
+      window.localStorage.removeItem(testKey);
+      return true;
+    } catch (_unused) {
+      return false;
+    }
+  };
+  _proto.failKey = function failKey() {
+    return "WS_FAIL_COUNT::" + this.auth.socketBaseUrl;
+  };
+  _proto.untilKey = function untilKey() {
+    return "WS_DEGRADE_UNTIL::" + this.auth.socketBaseUrl;
+  };
+  _proto.getFailCount = function getFailCount() {
+    if (!this.storageAvailable()) return this.wsFailCount;
+    var v = window.localStorage.getItem(this.failKey());
+    return v ? parseInt(v, 10) || 0 : 0;
+  };
+  _proto.setFailCount = function setFailCount(n) {
+    this.wsFailCount = n;
+    if (!this.storageAvailable()) return;
+    try {
+      window.localStorage.setItem(this.failKey(), String(n));
+    } catch (_unused2) {}
+  };
+  _proto.resetWsFailures = function resetWsFailures() {
+    if (!this.cfg.degradeWsOnFailure) return;
+    this.setFailCount(0);
+  };
+  _proto.getDegradeUntil = function getDegradeUntil() {
+    if (!this.storageAvailable()) return null;
+    var v = window.localStorage.getItem(this.untilKey());
+    return v ? parseInt(v, 10) || null : null;
+  };
+  _proto.setDegradeUntil = function setDegradeUntil(ts) {
+    if (!this.storageAvailable()) return;
+    try {
+      window.localStorage.setItem(this.untilKey(), String(ts));
+    } catch (_unused3) {}
+  };
+  _proto.clearDegradation = function clearDegradation() {
+    if (!this.storageAvailable()) return;
+    try {
+      window.localStorage.removeItem(this.untilKey());
+      window.localStorage.removeItem(this.failKey());
+    } catch (_unused4) {}
+  };
+  _proto.onWsFailure = function onWsFailure() {
+    if (!this.cfg.degradeWsOnFailure || this.cfg.forceWebSocket) return;
+    if (this.isDegraded || this.cfg.onlyLongpolling) return;
+    var current = this.getFailCount() + 1;
+    this.setFailCount(current);
+    this.logger.warn('WebSocket failure counted', {
+      count: current,
+      threshold: this.cfg.wsFailureThreshold
+    });
+    if (current >= (this.cfg.wsFailureThreshold || 3)) {
+      var ttl = this.cfg.wsDegradeTTLms || 24 * 60 * 60 * 1000;
+      var until = Date.now() + ttl;
+      this.isDegraded = true;
+      this.setDegradeUntil(until);
+      this.setFailCount(0);
+      this.logger.error('Entering degraded mode: polling-only', {
+        until: until
+      });
+      try {
+        this.disconnect();
+      } finally {
+        this.connect();
+      }
+    }
+  };
+  return ConnectionManager;
+}();
+ConnectionManager.instance = null;
+
+var defaultContext = {
+  connection: null,
+  status: exports.ConnectionStatus.Disconnected,
+  connect: function connect() {},
+  disconnect: function disconnect() {},
+  sendMessage: function sendMessage() {
+    return null;
+  },
+  on: function on() {},
+  off: function off() {},
+  onError: function onError() {},
+  offError: function offError() {},
+  updateLogging: function updateLogging() {},
+  getLoggingConfig: function getLoggingConfig() {
+    return null;
+  }
+};
+var ConnectionContext = React.createContext(defaultContext);
+var ConnectionProvider = function ConnectionProvider(_ref) {
+  var children = _ref.children,
+    authConfig = _ref.authConfig,
+    api = _ref.api,
+    connectionOptions = _ref.connectionOptions,
+    _ref$autoConnect = _ref.autoConnect,
+    autoConnect = _ref$autoConnect === void 0 ? true : _ref$autoConnect;
+  var _useState = React.useState(null),
+    connection = _useState[0],
+    setConnection = _useState[1];
+  var _useState2 = React.useState(exports.ConnectionStatus.Disconnected),
+    status = _useState2[0],
+    setStatus = _useState2[1];
+  React.useEffect(function () {
+    if (!authConfig || !api) {
+      if (connection) {
+        connection.disconnect();
+        setConnection(null);
+        setStatus(exports.ConnectionStatus.Disconnected);
+      }
+      return;
+    }
+    var newConnection = ConnectionManager.getInstance(authConfig, api, connectionOptions);
+    newConnection.onStatusChange(setStatus);
+    setConnection(newConnection);
+    if (autoConnect) {
+      newConnection.connect();
+    }
+    return function () {
+      newConnection.disconnect();
+      ConnectionManager.resetInstance();
+    };
+  }, [authConfig, connectionOptions, autoConnect, api]);
+  var connect = React.useCallback(function () {
+    if (connection) {
+      connection.connect();
+    }
+  }, [connection]);
+  var disconnect = React.useCallback(function () {
+    if (connection) {
+      connection.disconnect();
+    }
+  }, [connection]);
+  var sendMessage = React.useCallback(function (message, maxAttempts) {
+    if (maxAttempts === void 0) {
+      maxAttempts = 3;
+    }
+    if (!connection) {
+      return null;
+    }
+    return connection.queueMessage(message, maxAttempts);
+  }, [connection]);
+  var on = React.useCallback(function (eventType, callback) {
+    if (connection) {
+      connection.on(eventType, callback);
+    }
+  }, [connection]);
+  var off = React.useCallback(function (eventType, callback) {
+    if (connection) {
+      connection.off(eventType, callback);
+    }
+  }, [connection]);
+  var onError = React.useCallback(function (cb) {
+    if (connection) {
+      connection.onError(cb);
+    }
+  }, [connection]);
+  var offError = React.useCallback(function (cb) {
+    if (connection) {
+      connection.offError(cb);
+    }
+  }, [connection]);
+  var updateLogging = React.useCallback(function (config) {
+    if (connection) {
+      connection.updateLogging(config);
+    }
+  }, [connection]);
+  var getLoggingConfig = React.useCallback(function () {
+    if (connection) {
+      return connection.getLoggingConfig();
+    }
+    return null;
+  }, [connection]);
+  var value = React.useMemo(function () {
+    return {
+      connection: connection,
+      status: status,
+      connect: connect,
+      disconnect: disconnect,
+      sendMessage: sendMessage,
+      on: on,
+      off: off,
+      onError: onError,
+      offError: offError,
+      updateLogging: updateLogging,
+      getLoggingConfig: getLoggingConfig
+    };
+  }, [connection, status, connect, disconnect, sendMessage, on, off, onError, offError, updateLogging, getLoggingConfig]);
+  return React__default.createElement(ConnectionContext.Provider, {
+    value: value
+  }, children);
+};
+var useConnectionContext = function useConnectionContext() {
+  return React.useContext(ConnectionContext);
+};
+
+var defaultContext$1 = {
+  api: null,
+  isInitialized: false,
+  isAuthenticated: false,
+  initialize: function initialize() {},
+  conversations: [],
+  refreshConversations: function () {
+    try {
+      return Promise.resolve([]);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  },
+  setConversations: function setConversations() {}
+};
+var ChatContext = React.createContext(defaultContext$1);
+var ChatProvider = function ChatProvider(_ref) {
+  var children = _ref.children,
+    config = _ref.config,
+    connectionOptions = _ref.connectionOptions;
+  var _useState = React.useState(null),
+    api = _useState[0],
+    setApi = _useState[1];
+  var _useState2 = React.useState(false),
+    isInitialized = _useState2[0],
+    setIsInitialized = _useState2[1];
+  var _useState3 = React.useState(false),
+    isAuthenticated = _useState3[0],
+    setIsAuthenticated = _useState3[1];
+  var _useState4 = React.useState([]),
+    conversations = _useState4[0],
+    setConversations = _useState4[1];
+  var initialize = React.useCallback(function (config) {
+    var chatApi = new ChatApi(config);
+    setApi(chatApi);
+    setIsInitialized(true);
+    setIsAuthenticated(true);
+  }, []);
+  var refreshConversations = React.useCallback(function (archived, clientIds) {
+    try {
+      var _temp2 = function _temp2(_result) {
+        return _exit ? _result : [];
+      };
+      var _exit = false;
+      if (!api) return Promise.resolve([]);
+      var _temp = _catch(function () {
+        return Promise.resolve(api.listConversations(archived, clientIds)).then(function (data) {
+          setConversations(data);
+          _exit = true;
+          return data;
+        });
+      }, function (error) {
+        console.error('Failed to fetch conversations:', error);
+      });
+      return Promise.resolve(_temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  React.useEffect(function () {
+    if (config) {
+      initialize(config);
+    }
+  }, [config]);
+  React.useEffect(function () {
+    if (isAuthenticated) {
+      refreshConversations();
+    }
+  }, [isAuthenticated]);
+  var value = React.useMemo(function () {
+    return {
+      api: api,
+      isInitialized: isInitialized,
+      isAuthenticated: isAuthenticated,
+      initialize: initialize,
+      conversations: conversations,
+      refreshConversations: refreshConversations,
+      setConversations: setConversations
+    };
+  }, [api, isInitialized, isAuthenticated, conversations, refreshConversations]);
+  return React__default.createElement(ChatContext.Provider, {
+    value: value
+  }, React__default.createElement(ConnectionProvider, {
+    authConfig: config,
+    api: api || undefined,
+    connectionOptions: connectionOptions,
+    autoConnect: isAuthenticated
+  }, children));
+};
+var useChatContext = function useChatContext() {
+  return React.useContext(ChatContext);
+};
+
+function useRealtime(eventType) {
+  var _useConnectionContext = useConnectionContext(),
+    on = _useConnectionContext.on,
+    off = _useConnectionContext.off;
+  var _useState = React.useState(null),
+    event = _useState[0],
+    setEvent = _useState[1];
+  var handleEvent = React.useCallback(function (newEvent) {
+    setEvent(newEvent);
+  }, []);
+  React.useEffect(function () {
+    on(eventType, handleEvent);
+    return function () {
+      off(eventType, handleEvent);
+    };
+  }, [eventType, on, off, handleEvent]);
+  var clearEvent = React.useCallback(function () {
+    setEvent(null);
+  }, []);
+  return {
+    event: event,
+    clearEvent: clearEvent
+  };
+}
+function useMessageSentEvents() {
+  return useRealtime(exports.EventType.MessageSent);
+}
+function useMessageEditedEvents() {
+  return useRealtime(exports.EventType.MessageEdited);
+}
+function useMessageDeletedEvents() {
+  return useRealtime(exports.EventType.MessageDeleted);
+}
+function useMessageReadEvents() {
+  return useRealtime(exports.EventType.MessageRead);
+}
+function useConversationReadEvents() {
+  return useRealtime(exports.EventType.ConversationRead);
+}
+function useAllMessageEvents(callback) {
+  var _useMessageSentEvents = useMessageSentEvents(),
+    messageSent = _useMessageSentEvents.event,
+    clearMessageSent = _useMessageSentEvents.clearEvent;
+  var _useMessageEditedEven = useMessageEditedEvents(),
+    messageEdited = _useMessageEditedEven.event,
+    clearMessageEdited = _useMessageEditedEven.clearEvent;
+  var _useMessageDeletedEve = useMessageDeletedEvents(),
+    messageDeleted = _useMessageDeletedEve.event,
+    clearMessageDeleted = _useMessageDeletedEve.clearEvent;
+  var _useMessageReadEvents = useMessageReadEvents(),
+    messageRead = _useMessageReadEvents.event,
+    clearMessageRead = _useMessageReadEvents.clearEvent;
+  var _useConversationReadE = useConversationReadEvents(),
+    conversationRead = _useConversationReadE.event,
+    clearConversationRead = _useConversationReadE.clearEvent;
+  var clearEvents = React.useCallback(function () {
+    clearMessageSent();
+    clearMessageEdited();
+    clearMessageDeleted();
+    clearMessageRead();
+    clearConversationRead();
+  }, [clearMessageSent, clearMessageEdited, clearMessageDeleted, clearMessageRead, clearConversationRead]);
+  React.useEffect(function () {
+    if (messageSent && callback) {
+      callback(exports.EventType.MessageSent, messageSent.data);
+    }
+  }, [messageSent, callback]);
+  React.useEffect(function () {
+    if (messageEdited && callback) {
+      callback(exports.EventType.MessageEdited, messageEdited.data);
+    }
+  }, [messageEdited, callback]);
+  React.useEffect(function () {
+    if (messageDeleted && callback) {
+      callback(exports.EventType.MessageDeleted, messageDeleted.data);
+    }
+  }, [messageDeleted, callback]);
+  React.useEffect(function () {
+    if (messageRead && callback) {
+      callback(exports.EventType.MessageRead, messageRead.data);
+    }
+  }, [messageRead, callback]);
+  React.useEffect(function () {
+    if (conversationRead && callback) {
+      callback(exports.EventType.ConversationRead, conversationRead.data);
+    }
+  }, [conversationRead, callback]);
+  return {
+    messageSent: messageSent,
+    messageEdited: messageEdited,
+    messageDeleted: messageDeleted,
+    messageRead: messageRead,
+    conversationRead: conversationRead,
+    clearEvents: clearEvents
+  };
+}
+
+var useConversations = function useConversations() {
+  var _useChatContext = useChatContext(),
+    api = _useChatContext.api,
+    conversations = _useChatContext.conversations,
+    refreshConversations = _useChatContext.refreshConversations,
+    setConversations = _useChatContext.setConversations;
+  var _useState = React.useState(false),
+    loading = _useState[0],
+    setLoading = _useState[1];
+  var _useState2 = React.useState(null),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var eventProcessorPipeline = React.useCallback(function () {
+    console.log('Message event received');
+    refreshConversations();
+  }, []);
+  useAllMessageEvents(eventProcessorPipeline);
+  var getConversations = React.useCallback(function (archived, clientIds) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve([]);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(refreshConversations(archived, clientIds));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to get conversations');
+          setError(error);
+          return [];
+        });
+      }, function (_wasThrown, _result) {
+        setLoading(false);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [refreshConversations, api]);
+  var deleteConversation = React.useCallback(function (conversationUid) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.deleteConversation(conversationUid)).then(function (response) {
+            return Promise.resolve(refreshConversations()).then(function () {
+              return response;
+            });
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to delete conversation');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown2, _result2) {
+        setLoading(false);
+        if (_wasThrown2) throw _result2;
+        return _result2;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, refreshConversations]);
+  var archiveConversation = React.useCallback(function (conversationUid) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.archiveConversation(conversationUid)).then(function (response) {
+            return Promise.resolve(refreshConversations()).then(function () {
+              return response;
+            });
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to archive conversation');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown3, _result3) {
+        setLoading(false);
+        if (_wasThrown3) throw _result3;
+        return _result3;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, refreshConversations]);
+  var unarchiveConversation = React.useCallback(function (conversationUid) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.unarchiveConversation(conversationUid)).then(function (response) {
+            return Promise.resolve(refreshConversations()).then(function () {
+              return response;
+            });
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to unarchive conversation');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown4, _result4) {
+        setLoading(false);
+        if (_wasThrown4) throw _result4;
+        return _result4;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, refreshConversations]);
+  var getConversationDetails = React.useCallback(function (conversationUid) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.getConversationDetails(conversationUid));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to get conversation details');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown5, _result5) {
+        setLoading(false);
+        if (_wasThrown5) throw _result5;
+        return _result5;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  var searchConversation = React.useCallback(function (conversationUid, term) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.searchConversation(conversationUid, term));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to search conversation');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown6, _result6) {
+        setLoading(false);
+        if (_wasThrown6) throw _result6;
+        return _result6;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  return {
+    conversations: conversations,
+    loading: loading,
+    error: error,
+    getConversations: getConversations,
+    deleteConversation: deleteConversation,
+    archiveConversation: archiveConversation,
+    unarchiveConversation: unarchiveConversation,
+    getConversationDetails: getConversationDetails,
+    searchConversation: searchConversation,
+    setConversations: setConversations
+  };
+};
+
+var useConnection = function useConnection() {
+  var _useConnectionContext = useConnectionContext(),
+    status = _useConnectionContext.status,
+    connect = _useConnectionContext.connect,
+    disconnect = _useConnectionContext.disconnect,
+    connection = _useConnectionContext.connection,
+    queueMessage = _useConnectionContext.sendMessage;
+  var connectToServer = React.useCallback(function () {
+    connect();
+  }, [connect]);
+  var disconnectFromServer = React.useCallback(function () {
+    disconnect();
+  }, [disconnect]);
+  var sendMessage = React.useCallback(function (message, maxAttempts) {
+    if (maxAttempts === void 0) {
+      maxAttempts = 3;
+    }
+    return queueMessage(message, maxAttempts);
+  }, [queueMessage]);
+  var isConnected = status === exports.ConnectionStatus.Connected;
+  var isConnecting = status === exports.ConnectionStatus.Connecting;
+  var hasError = status === exports.ConnectionStatus.Error;
+  return {
+    status: status,
+    isConnected: isConnected,
+    isConnecting: isConnecting,
+    hasError: hasError,
+    connect: connectToServer,
+    disconnect: disconnectFromServer,
+    sendMessage: sendMessage,
+    connection: connection
+  };
+};
+
+var QUEUE_STORAGE_KEY = 'message_queue';
+var MAX_RETRY_TIME = 60 * 1000;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var RETRY_DELAY = 2000;
+var useQueue = function useQueue(api) {
+  var _useState = React.useState([]),
+    queue = _useState[0],
+    setQueue = _useState[1];
+  var _useState2 = React.useState(false),
+    isProcessing = _useState2[0],
+    setIsProcessing = _useState2[1];
+  React.useEffect(function () {
+    try {
+      var storedQueue = localStorage.getItem(QUEUE_STORAGE_KEY);
+      if (storedQueue) {
+        var parsedQueue = JSON.parse(storedQueue);
+        var now = Date.now();
+        var validQueue = parsedQueue.filter(function (item) {
+          return now - item.timestamp <= MAX_RETRY_TIME;
+        });
+        setQueue(validQueue);
+      }
+    } catch (error) {
+      console.error('Failed to load message queue from localStorage:', error);
+    }
+  }, []);
+  React.useEffect(function () {
+    try {
+      localStorage.setItem(QUEUE_STORAGE_KEY, JSON.stringify(queue));
+    } catch (error) {
+      console.error('Failed to save message queue to localStorage:', error);
+    }
+  }, [queue]);
+  var enqueueMessage = React.useCallback(function (message) {
+    var id = "msg_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+    var queuedMessage = {
+      id: id,
+      message: message,
+      attempts: 0,
+      maxAttempts: DEFAULT_MAX_ATTEMPTS,
+      timestamp: Date.now()
+    };
+    setQueue(function (prevQueue) {
+      return [].concat(prevQueue, [queuedMessage]);
+    });
+    return id;
+  }, []);
+  var processQueue = React.useCallback(function () {
+    try {
+      if (!api || isProcessing || queue.length === 0) {
+        return Promise.resolve();
+      }
+      setIsProcessing(true);
+      var currentMessage = queue[0],
+        remainingMessages = queue.slice(1);
+      var now = Date.now();
+      if (now - currentMessage.timestamp > MAX_RETRY_TIME) {
+        setQueue(remainingMessages);
+        setIsProcessing(false);
+        return Promise.resolve();
+      }
+      var _temp = _finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.sendMessage(currentMessage.message)).then(function () {
+            setQueue(remainingMessages);
+          });
+        }, function () {
+          if (currentMessage.attempts < currentMessage.maxAttempts) {
+            var updatedMessage = _extends({}, currentMessage, {
+              attempts: currentMessage.attempts + 1
+            });
+            setQueue([].concat(remainingMessages, [updatedMessage]));
+          } else {
+            setQueue(remainingMessages);
+          }
+        });
+      }, function (_wasThrown, _result) {
+        setIsProcessing(false);
+        if (remainingMessages.length > 0) {
+          setTimeout(function () {
+            return processQueue();
+          }, RETRY_DELAY);
+        }
+        if (_wasThrown) throw _result;
+        return _result;
+      });
+      return Promise.resolve(_temp && _temp.then ? _temp.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, isProcessing, queue]);
+  React.useEffect(function () {
+    if (queue.length > 0 && api && !isProcessing) {
+      processQueue();
+    }
+  }, [queue, api, isProcessing, processQueue]);
+  var sendMessageWithRetry = React.useCallback(function (message) {
+    try {
+      if (!api) {
+        enqueueMessage(message);
+        return Promise.resolve(null);
+      }
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(api.sendMessage(message));
+      }, function () {
+        enqueueMessage(message);
+        return null;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, enqueueMessage]);
+  return {
+    enqueueMessage: enqueueMessage,
+    sendMessageWithRetry: sendMessageWithRetry,
+    queueLength: queue.length,
+    isProcessing: isProcessing
+  };
+};
+
+var useClientProfile = function useClientProfile() {
+  var _useChatContext = useChatContext(),
+    api = _useChatContext.api;
+  var _useState = React.useState(false),
+    loading = _useState[0],
+    setLoading = _useState[1];
+  var _useState2 = React.useState(null),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var _useState3 = React.useState(null),
+    profile = _useState3[0],
+    setProfile = _useState3[1];
+  var fetchProfile = React.useCallback(function () {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.getClientProfile()).then(function (response) {
+            setProfile(response);
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to fetch client profile');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown, _result) {
+        setLoading(false);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  React.useEffect(function () {
+    if (api) {
+      fetchProfile();
+    }
+  }, [api, fetchProfile]);
+  return {
+    loading: loading,
+    error: error,
+    profile: profile,
+    fetchProfile: fetchProfile
+  };
+};
+
+var useMessages = function useMessages(conversationUid) {
+  var _useChatContext = useChatContext(),
+    api = _useChatContext.api;
+  var _useClientProfile = useClientProfile(),
+    profile = _useClientProfile.profile;
+  var _useState = React.useState(false),
+    loading = _useState[0],
+    setLoading = _useState[1];
+  var _useState2 = React.useState(null),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var _useState3 = React.useState(null),
+    messages = _useState3[0],
+    setMessages = _useState3[1];
+  var _useState4 = React.useState(null),
+    preferences = _useState4[0],
+    setPreferences = _useState4[1];
+  var _useConnection = useConnection(),
+    isConnected = _useConnection.isConnected,
+    connection = _useConnection.connection;
+  var _useQueue = useQueue(api),
+    sendMessageWithRetry = _useQueue.sendMessageWithRetry,
+    queueLength = _useQueue.queueLength;
+  React.useEffect(function () {
+    var fetchPreferences = function fetchPreferences() {
+      try {
+        if (!api) {
+          setError(new Error('API not initialized'));
+          return Promise.resolve();
+        }
+        var _temp = _catch(function () {
+          return Promise.resolve(api.getClientPreferences()).then(function (response) {
+            setPreferences(response.preferences);
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to fetch preferences');
+          setError(error);
+        });
+        return Promise.resolve(_temp && _temp.then ? _temp.then(function () {}) : void 0);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    fetchPreferences();
+  }, [api]);
+  var clearDuplicateMessages = React.useCallback(function (messages) {
+    var uniqueMessages = new Map();
+    messages.forEach(function (message) {
+      uniqueMessages.set(message.id, message);
+    });
+    return Array.from(uniqueMessages.values());
+  }, []);
+  var getMessages = React.useCallback(function (conversationId, page, pageSize) {
+    if (conversationId === void 0) {
+      conversationId = conversationUid;
+    }
+    if (page === void 0) {
+      page = 1;
+    }
+    if (pageSize === void 0) {
+      pageSize = 20;
+    }
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      if (!conversationId) {
+        setError(new Error('Conversation ID is required'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.getMessages(conversationId, page, pageSize)).then(function (response) {
+            if (page === 1) setMessages(response);else setMessages(function (prev) {
+              return prev ? _extends({}, prev, {
+                messages: clearDuplicateMessages([].concat(prev.messages, response === null || response === void 0 ? void 0 : response.messages)),
+                pagination: response.pagination
+              }) : null;
+            });
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to get messages');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown, _result) {
+        setLoading(false);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [conversationUid]);
+  var markMessageAsRead = React.useCallback(function (messageId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.markMessageAsRead(messageId));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to mark message as read');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown2, _result2) {
+        setLoading(false);
+        if (_wasThrown2) throw _result2;
+        return _result2;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, []);
+  var sendMessage = React.useCallback(function (message) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      var messageWithConversation = _extends({}, message, {
+        conversation_uid: message.conversation_uid || conversationUid
+      });
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(sendMessageWithRetry(messageWithConversation));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to send message');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown3, _result3) {
+        setLoading(false);
+        if (_wasThrown3) throw _result3;
+        return _result3;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [conversationUid, sendMessageWithRetry]);
+  var markConversationAsRead = React.useCallback(function (conversationId) {
+    if (conversationId === void 0) {
+      conversationId = conversationUid;
+    }
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      if (!conversationId) {
+        setError(new Error('Conversation ID is required'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.markConversationAsRead(conversationId)).then(function (response) {
+            setMessages(function (prev) {
+              var _prev$messages;
+              return prev ? _extends({}, prev, {
+                messages: prev === null || prev === void 0 ? void 0 : (_prev$messages = prev.messages) === null || _prev$messages === void 0 ? void 0 : _prev$messages.map(function (item) {
+                  return _extends({}, item, {
+                    is_read: true
+                  });
+                })
+              }) : null;
+            });
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to mark conversation as read');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown4, _result4) {
+        setLoading(false);
+        if (_wasThrown4) throw _result4;
+        return _result4;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, conversationUid]);
+  var updateMessage = React.useCallback(function (messageId, update) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.updateMessage(messageId, update)).then(function (response) {
+            setMessages(function (prev) {
+              return prev ? _extends({}, prev, {
+                messages: prev.messages.map(function (item) {
+                  return item.id === messageId ? _extends({}, item, response.message) : item;
+                })
+              }) : null;
+            });
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to update message');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown5, _result5) {
+        setLoading(false);
+        if (_wasThrown5) throw _result5;
+        return _result5;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, conversationUid]);
+  var deleteMessage = React.useCallback(function (messageId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.deleteMessage(messageId)).then(function (response) {
+            setMessages(function (prev) {
+              return prev ? _extends({}, prev, {
+                messages: prev.messages.filter(function (item) {
+                  return item.id !== messageId;
+                })
+              }) : null;
+            });
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to delete message');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown6, _result6) {
+        setLoading(false);
+        if (_wasThrown6) throw _result6;
+        return _result6;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api, conversationUid]);
+  var updatePreferences = React.useCallback(function (enableRead) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(false);
+      }
+      setError(null);
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(api.updateClientPreferences({
+          preferences: {
+            enable_read: enableRead
+          }
+        })).then(function (response) {
+          setPreferences(response.preferences);
+          return true;
+        });
+      }, function (err) {
+        var error = err instanceof Error ? err : new Error('Failed to update preferences');
+        setError(error);
+        return false;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  React.useEffect(function () {
+    if (conversationUid) {
+      getMessages();
+    }
+  }, [isConnected, conversationUid]);
+  var handleMessageEvent = React.useCallback(function (eventType, data) {
+    if (!conversationUid || data.conversation_uid && data.conversation_uid !== conversationUid) {
+      return;
+    }
+    setMessages(function (prev) {
+      if (!prev) return prev;
+      switch (eventType) {
+        case exports.EventType.MessageSent:
+          {
+            var sentEvent = data;
+            var messageExists = prev.messages.some(function (msg) {
+              return msg.id === sentEvent.id;
+            });
+            if (messageExists) {
+              return prev;
+            }
+            console.log('arrived event', eventType);
+            return _extends({}, prev, {
+              messages: [].concat(prev.messages, [sentEvent]).sort(function (a, b) {
+                return new Date(b.sent_at).getTime() - new Date(a.sent_at).getTime();
+              })
+            });
+          }
+        case exports.EventType.MessageEdited:
+          {
+            var editEvent = data;
+            return _extends({}, prev, {
+              messages: prev.messages.map(function (msg) {
+                return msg.id === editEvent.msg_id ? _extends({}, msg, {
+                  message: editEvent.new_content,
+                  attachments: editEvent.new_attachments || msg.attachments
+                }) : msg;
+              })
+            });
+          }
+        case exports.EventType.MessageDeleted:
+          {
+            var deleteEvent = data;
+            return _extends({}, prev, {
+              messages: prev.messages.filter(function (msg) {
+                return msg.id !== deleteEvent.msg_id;
+              })
+            });
+          }
+        case exports.EventType.MessageRead:
+          {
+            var readEvent = data;
+            return _extends({}, prev, {
+              messages: prev.messages.map(function (msg) {
+                return msg.id === readEvent.message_id ? _extends({}, msg, {
+                  is_read: true
+                }) : msg;
+              })
+            });
+          }
+        case exports.EventType.ConversationRead:
+          {
+            var conversationReadEvent = data;
+            return _extends({}, prev, {
+              messages: prev.messages.map(function (msg) {
+                return conversationReadEvent.message_ids.includes(msg.id) ? _extends({}, msg, {
+                  is_read: true
+                }) : msg;
+              })
+            });
+          }
+        default:
+          return prev;
+      }
+    });
+  }, [conversationUid, profile]);
+  var sendReceivedEvent = React.useCallback(function (eventType, data) {
+    if (eventType === exports.EventType.MessageSent) {
+      var messageReceivedEvent = {
+        type: exports.EventType.MessageReceived,
+        data: data
+      };
+      connection.emit(messageReceivedEvent.type, messageReceivedEvent.data);
+    }
+  }, [connection]);
+  var eventProcessorPipeline = React.useCallback(function (eventType, data) {
+    markConversationAsRead(conversationUid);
+    handleMessageEvent(eventType, data);
+  }, [handleMessageEvent, conversationUid, sendReceivedEvent, preferences]);
+  useAllMessageEvents(eventProcessorPipeline);
+  return {
+    messages: (messages === null || messages === void 0 ? void 0 : messages.messages) || [],
+    pagination: messages === null || messages === void 0 ? void 0 : messages.pagination,
+    loading: loading,
+    error: error,
+    queueLength: queueLength,
+    getMessages: getMessages,
+    markMessageAsRead: markMessageAsRead,
+    sendMessage: sendMessage,
+    markConversationAsRead: markConversationAsRead,
+    updateMessage: updateMessage,
+    deleteMessage: deleteMessage,
+    setMessages: setMessages,
+    updatePreferences: updatePreferences,
+    preferences: preferences
+  };
+};
+
+var useFiles = function useFiles() {
+  var _useChatContext = useChatContext(),
+    api = _useChatContext.api;
+  var _useState = React.useState(false),
+    loading = _useState[0],
+    setLoading = _useState[1];
+  var _useState2 = React.useState(null),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var _useState3 = React.useState(0),
+    uploadProgress = _useState3[0],
+    setUploadProgress = _useState3[1];
+  var uploadFile = React.useCallback(function (file) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      setUploadProgress(0);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          var simulateProgress = function simulateProgress() {
+            var progress = 0;
+            var interval = setInterval(function () {
+              progress += 10;
+              if (progress > 90) {
+                clearInterval(interval);
+              } else {
+                setUploadProgress(progress);
+              }
+            }, 300);
+            return function () {
+              return clearInterval(interval);
+            };
+          };
+          var cleanup = simulateProgress();
+          return Promise.resolve(api.uploadFile(file)).then(function (response) {
+            cleanup();
+            setUploadProgress(100);
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to upload file');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown, _result) {
+        setLoading(false);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  return {
+    loading: loading,
+    error: error,
+    uploadProgress: uploadProgress,
+    uploadFile: uploadFile
+  };
+};
+
+var useConversationDetails = function useConversationDetails() {
+  var _useChatContext = useChatContext(),
+    api = _useChatContext.api;
+  var _useState = React.useState(false),
+    loading = _useState[0],
+    setLoading = _useState[1];
+  var _useState2 = React.useState(null),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var _useState3 = React.useState(null),
+    conversationDetails = _useState3[0],
+    setConversationDetails = _useState3[1];
+  var _useState4 = React.useState(null),
+    receiverId = _useState4[0],
+    setReceiverId = _useState4[1];
+  var getConversationWithReceiver = React.useCallback(function (receiverId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve({
+          details: null,
+          receiverId: receiverId
+        });
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.getConversationWithReceiver(receiverId)).then(function (details) {
+            setConversationDetails(details);
+            setReceiverId(receiverId);
+            return {
+              details: details,
+              receiverId: receiverId
+            };
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to get conversation details');
+          setError(error);
+          return {
+            details: null,
+            receiverId: receiverId
+          };
+        });
+      }, function (_wasThrown, _result) {
+        setLoading(false);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  return {
+    conversationDetails: conversationDetails,
+    receiverId: receiverId,
+    loading: loading,
+    error: error,
+    getConversationWithReceiver: getConversationWithReceiver
+  };
+};
+
+function useConversationManagement() {
+  var _useState = React.useState(''),
+    selectedConversationId = _useState[0],
+    setSelectedConversationId = _useState[1];
+  var _useConversations = useConversations(),
+    conversations = _useConversations.conversations,
+    conversationsLoading = _useConversations.loading,
+    getConversations = _useConversations.getConversations,
+    deleteConversation = _useConversations.deleteConversation,
+    unarchiveConversation = _useConversations.unarchiveConversation,
+    archiveConversation = _useConversations.archiveConversation,
+    setConversations = _useConversations.setConversations;
+  var selectedConversation = React.useMemo(function () {
+    return conversations.find(function (conversation) {
+      return conversation.id === selectedConversationId;
+    });
+  }, [conversations, selectedConversationId]);
+  React.useEffect(function () {
+    getConversations();
+  }, [getConversations]);
+  var handleSelectConversation = React.useCallback(function (conversation) {
+    if (conversation === null) {
+      setSelectedConversationId('');
+      return;
+    }
+    setSelectedConversationId(conversation.id);
+    setConversations(function (prevState) {
+      return prevState.map(function (item) {
+        return item.id === conversation.id ? _extends({}, conversation, {
+          unreadCount: 0
+        }) : item;
+      });
+    });
+  }, [setConversations]);
+  return {
+    conversations: conversations,
+    conversationsLoading: conversationsLoading,
+    selectedConversationId: selectedConversationId,
+    selectedConversation: selectedConversation,
+    deleteConversation: deleteConversation,
+    archiveConversation: archiveConversation,
+    unarchiveConversation: unarchiveConversation,
+    handleSelectConversation: handleSelectConversation,
+    getConversations: getConversations
+  };
+}
+
+var useBans = function useBans() {
+  var _useChatContext = useChatContext(),
+    api = _useChatContext.api;
+  var _useState = React.useState(false),
+    loading = _useState[0],
+    setLoading = _useState[1];
+  var _useState2 = React.useState(null),
+    error = _useState2[0],
+    setError = _useState2[1];
+  var _useState3 = React.useState(null),
+    banStatus = _useState3[0],
+    setBanStatus = _useState3[1];
+  var banClient = React.useCallback(function (clientId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          var request = {
+            client_id: clientId
+          };
+          return Promise.resolve(api.banClient(request));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to ban client');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown, _result) {
+        setLoading(false);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  var unbanClient = React.useCallback(function (clientId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          var request = {
+            client_id: clientId
+          };
+          return Promise.resolve(api.unbanClient(request));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to unban client');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown2, _result2) {
+        setLoading(false);
+        if (_wasThrown2) throw _result2;
+        return _result2;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  var adminBanClient = React.useCallback(function (clientId, reason, durationDays) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          var request = {
+            client_id: clientId,
+            reason: reason,
+            duration_days: durationDays
+          };
+          return Promise.resolve(api.adminBanClient(request));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to admin ban client');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown3, _result3) {
+        setLoading(false);
+        if (_wasThrown3) throw _result3;
+        return _result3;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  var adminUnbanClient = React.useCallback(function (clientId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          var request = {
+            client_id: clientId
+          };
+          return Promise.resolve(api.adminUnbanClient(request));
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to admin unban client');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown4, _result4) {
+        setLoading(false);
+        if (_wasThrown4) throw _result4;
+        return _result4;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  var checkBanStatus = React.useCallback(function (clientId) {
+    try {
+      if (!api) {
+        setError(new Error('API not initialized'));
+        return Promise.resolve(null);
+      }
+      setLoading(true);
+      setError(null);
+      return Promise.resolve(_finallyRethrows(function () {
+        return _catch(function () {
+          return Promise.resolve(api.checkBanStatus(clientId)).then(function (response) {
+            setBanStatus(response);
+            return response;
+          });
+        }, function (err) {
+          var error = err instanceof Error ? err : new Error('Failed to check ban status');
+          setError(error);
+          return null;
+        });
+      }, function (_wasThrown5, _result5) {
+        setLoading(false);
+        if (_wasThrown5) throw _result5;
+        return _result5;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [api]);
+  return {
+    loading: loading,
+    error: error,
+    banStatus: banStatus,
+    banClient: banClient,
+    unbanClient: unbanClient,
+    adminBanClient: adminBanClient,
+    adminUnbanClient: adminUnbanClient,
+    checkBanStatus: checkBanStatus
+  };
+};
+
+function useMessageManagement(selectedConversationId) {
+  var _useState = React.useState(1),
+    page = _useState[0],
+    setPage = _useState[1];
+  var _useState2 = React.useState(true),
+    hasMore = _useState2[0],
+    setHasMore = _useState2[1];
+  var _useClientProfile = useClientProfile(),
+    profile = _useClientProfile.profile;
+  var _useMessages = useMessages(selectedConversationId),
+    messages = _useMessages.messages,
+    messagesLoading = _useMessages.loading,
+    sendMessage = _useMessages.sendMessage,
+    getMessages = _useMessages.getMessages,
+    markConversationAsRead = _useMessages.markConversationAsRead,
+    deleteMessage = _useMessages.deleteMessage,
+    updateMessage = _useMessages.updateMessage,
+    setMessages = _useMessages.setMessages,
+    preferences = _useMessages.preferences,
+    updatePreferences = _useMessages.updatePreferences;
+  var _useAllMessageEvents = useAllMessageEvents$1(),
+    messageSent = _useAllMessageEvents.messageSent,
+    messageEdited = _useAllMessageEvents.messageEdited,
+    messageDeleted = _useAllMessageEvents.messageDeleted,
+    clearEvents = _useAllMessageEvents.clearEvents;
+  var _useFiles = useFiles(),
+    uploadFile = _useFiles.uploadFile,
+    fileLoading = _useFiles.loading,
+    uploadProgress = _useFiles.uploadProgress;
+  React.useEffect(function () {
+    setPage(1);
+    setHasMore(true);
+  }, [selectedConversationId]);
+  React.useEffect(function () {
+    if (selectedConversationId) {
+      markConversationAsRead();
+    }
+  }, [selectedConversationId, markConversationAsRead]);
+  React.useEffect(function () {
+    if (messageSent || messageEdited || messageDeleted) {
+      clearEvents();
+    }
+  }, [messageSent, messageEdited, messageDeleted, clearEvents]);
+  var loadMoreMessages = React.useCallback(function () {
+    try {
+      if (messagesLoading || !hasMore) return Promise.resolve();
+      var _temp = _catch(function () {
+        var nextPage = page + 1;
+        return Promise.resolve(getMessages(selectedConversationId, nextPage)).then(function (result) {
+          if (!result || result.messages.length === 0) {
+            setHasMore(false);
+          } else {
+            setPage(nextPage);
+          }
+        });
+      }, function (error) {
+        console.error('Failed to load more messages:', error);
+        setHasMore(false);
+      });
+      return Promise.resolve(_temp && _temp.then ? _temp.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [messagesLoading, hasMore, getMessages, page, selectedConversationId]);
+  var handleSendMessage = React.useCallback(function (content, receiver) {
+    try {
+      if (!content.trim() || !selectedConversationId || !profile) return Promise.resolve();
+      var tempMessageId = "temp-" + Date.now();
+      var newMessage = {
+        attachments: [],
+        conversation_uid: tempMessageId,
+        sent_at: new Date().toISOString().replace('Z', '000'),
+        message: content.trim(),
+        messageType: 0,
+        sender: profile,
+        receiver: receiver,
+        is_read: false,
+        status: 'sending'
+      };
+      setMessages(function (prevMessages) {
+        var prevMessageArray = (prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || [];
+        return _extends({}, prevMessages, {
+          messages: [newMessage].concat(prevMessageArray)
+        });
+      });
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(sendMessage({
+          receiver_client_id: receiver.id,
+          content: content,
+          conversation_uid: selectedConversationId
+        })).then(function (success) {
+          if (!success) {
+            setMessages(function (prevMessages) {
+              return _extends({}, prevMessages, {
+                messages: ((prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || []).map(function (msg) {
+                  return msg.conversation_uid === tempMessageId ? _extends({}, msg, {
+                    status: 'failed'
+                  }) : msg;
+                })
+              });
+            });
+            return false;
+          } else {
+            setMessages(function (prevMessages) {
+              return _extends({}, prevMessages, {
+                messages: ((prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || []).map(function (msg) {
+                  return msg.conversation_uid === tempMessageId ? _extends({}, msg, {
+                    status: 'sent',
+                    id: success.message.id,
+                    is_read: success.message.is_read
+                  }) : msg;
+                })
+              });
+            });
+            return true;
+          }
+        });
+      }, function (error) {
+        setMessages(function (prevMessages) {
+          return _extends({}, prevMessages, {
+            messages: ((prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || []).filter(function (msg) {
+              return msg.conversation_uid !== tempMessageId;
+            })
+          });
+        });
+        console.error('Failed to send message:', error);
+        return false;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [sendMessage, selectedConversationId, profile === null || profile === void 0 ? void 0 : profile.id, setMessages]);
+  var handleSendFileMessage = React.useCallback(function (content, fileId, receiver, filename, url) {
+    try {
+      if (!selectedConversationId) return Promise.resolve();
+      var tempMessageId = "temp-file-" + Date.now();
+      var newMessage = {
+        attachments: [{
+          filename: filename,
+          url: url,
+          id: fileId
+        }],
+        conversation_uid: tempMessageId,
+        sent_at: new Date().toISOString().replace('Z', '000'),
+        message: content,
+        messageType: 0,
+        sender: profile,
+        receiver: receiver,
+        is_read: false,
+        status: 'sending'
+      };
+      setMessages(function (prevMessages) {
+        var prevMessageArray = (prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || [];
+        return _extends({}, prevMessages, {
+          messages: [newMessage].concat(prevMessageArray)
+        });
+      });
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(sendMessage({
+          receiver_client_id: receiver.id,
+          content: content,
+          attachments: [fileId],
+          conversation_uid: selectedConversationId
+        })).then(function (success) {
+          if (success) {
+            setMessages(function (prevMessages) {
+              return _extends({}, prevMessages, {
+                messages: ((prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || []).map(function (msg) {
+                  return msg.conversation_uid === tempMessageId ? _extends({}, msg, {
+                    status: 'sent',
+                    id: success.message.id,
+                    is_read: success.message.is_read
+                  }) : msg;
+                })
+              });
+            });
+            return true;
+          } else {
+            setMessages(function (prevMessages) {
+              return _extends({}, prevMessages, {
+                messages: ((prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || []).map(function (msg) {
+                  return msg.conversation_uid === tempMessageId ? _extends({}, msg, {
+                    status: 'failed'
+                  }) : msg;
+                })
+              });
+            });
+            return false;
+          }
+        });
+      }, function (error) {
+        setMessages(function (prevMessages) {
+          return _extends({}, prevMessages, {
+            messages: ((prevMessages === null || prevMessages === void 0 ? void 0 : prevMessages.messages) || []).filter(function (msg) {
+              return msg.conversation_uid !== tempMessageId;
+            })
+          });
+        });
+        console.error('Failed to send file message:', error);
+        return false;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, [sendMessage, selectedConversationId, profile === null || profile === void 0 ? void 0 : profile.id, setMessages]);
+  return {
+    messages: messages,
+    messagesLoading: messagesLoading,
+    fileLoading: fileLoading,
+    uploadProgress: uploadProgress,
+    uploadFile: uploadFile,
+    handleSendMessage: handleSendMessage,
+    handleSendFileMessage: handleSendFileMessage,
+    deleteMessage: deleteMessage,
+    updateMessage: updateMessage,
+    getMessages: getMessages,
+    loadMoreMessages: loadMoreMessages,
+    hasMore: hasMore,
+    setMessages: setMessages,
+    preferences: preferences,
+    updatePreferences: updatePreferences
+  };
+}
+
+function useCustomEvents() {
+  var _useConnectionContext = useConnectionContext(),
+    on = _useConnectionContext.on,
+    off = _useConnectionContext.off,
+    connection = _useConnectionContext.connection;
+  var customEventsRef = React.useRef(new Map());
+  var registerCustomEventListener = React.useCallback(function (key, eventType, callback) {
+    if (!customEventsRef.current.has(key)) {
+      customEventsRef.current.set(key, []);
+    }
+    customEventsRef.current.get(key).push(callback);
+    var eventHandler = function eventHandler(event) {
+      var listeners = customEventsRef.current.get(key);
+      if (listeners) {
+        listeners.forEach(function (listener) {
+          try {
+            listener(event.data);
+          } catch (err) {
+            console.error("Error in custom event listener " + key + ":", err);
+          }
+        });
+      }
+    };
+    on(eventType, eventHandler);
+    return function () {
+      var listeners = customEventsRef.current.get(key);
+      if (listeners) {
+        var index = listeners.indexOf(callback);
+        if (index !== -1) {
+          listeners.splice(index, 1);
+        }
+      }
+      off(eventType, eventHandler);
+    };
+  }, [on, off]);
+  var unregisterCustomEventListener = React.useCallback(function (key, callback) {
+    var listeners = customEventsRef.current.get(key);
+    if (listeners) {
+      var index = listeners.indexOf(callback);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+  }, []);
+  var unregisterAllCustomEventListeners = React.useCallback(function (key) {
+    customEventsRef.current["delete"](key);
+  }, []);
+  var emitCustomEvent = React.useCallback(function (eventType, data) {
+    if (connection) {
+      connection.emit(eventType, data);
+    }
+  }, [connection]);
+  return {
+    registerCustomEventListener: registerCustomEventListener,
+    unregisterCustomEventListener: unregisterCustomEventListener,
+    unregisterAllCustomEventListeners: unregisterAllCustomEventListeners,
+    emitCustomEvent: emitCustomEvent
+  };
+}
+
+function useLogging() {
+  var _useConnectionContext = useConnectionContext(),
+    updateLogging = _useConnectionContext.updateLogging,
+    getLoggingConfig = _useConnectionContext.getLoggingConfig;
+  var enableLogging = React.useCallback(function (level) {
+    if (level === void 0) {
+      level = exports.LogLevel.INFO;
+    }
+    updateLogging({
+      enabled: true,
+      level: level
+    });
+  }, [updateLogging]);
+  var disableLogging = React.useCallback(function () {
+    updateLogging({
+      enabled: false
+    });
+  }, [updateLogging]);
+  var setLogLevel = React.useCallback(function (level) {
+    updateLogging({
+      level: level
+    });
+  }, [updateLogging]);
+  var updateLoggingConfig = React.useCallback(function (config) {
+    updateLogging(config);
+  }, [updateLogging]);
+  return {
+    enableLogging: enableLogging,
+    disableLogging: disableLogging,
+    setLogLevel: setLogLevel,
+    updateLoggingConfig: updateLoggingConfig,
+    getLoggingConfig: getLoggingConfig
+  };
+}
+
+var useAllMessageEvents$1 = useAllMessageEvents;
+var ChatClient = function ChatClient(_ref) {
+  var children = _ref.children,
+    token = _ref.token,
+    client_id = _ref.client_id,
+    _ref$baseUrl = _ref.baseUrl,
+    baseUrl = _ref$baseUrl === void 0 ? 'https://api.example.com' : _ref$baseUrl,
+    _ref$socketBaseUrl = _ref.socketBaseUrl,
+    socketBaseUrl = _ref$socketBaseUrl === void 0 ? 'wss://api.example.com' : _ref$socketBaseUrl,
+    connectionOptions = _ref.connectionOptions;
+  var config = React.useMemo(function () {
+    if (token) {
+      return {
+        token: token,
+        baseUrl: baseUrl,
+        client_id: client_id,
+        socketBaseUrl: socketBaseUrl
+      };
+    }
+    return undefined;
+  }, [token, baseUrl, client_id]);
+  return React.createElement(ChatProvider, {
+    config: config,
+    connectionOptions: connectionOptions
+  }, children);
+};
+
+exports.ChatApi = ChatApi;
+exports.ChatClient = ChatClient;
+exports.ChatProvider = ChatProvider;
+exports.useAllMessageEvents = useAllMessageEvents$1;
+exports.useBans = useBans;
+exports.useChatContext = useChatContext;
+exports.useClientProfile = useClientProfile;
+exports.useConnection = useConnection;
+exports.useConversationDetails = useConversationDetails;
+exports.useConversationManagement = useConversationManagement;
+exports.useConversations = useConversations;
+exports.useCustomEvents = useCustomEvents;
+exports.useFiles = useFiles;
+exports.useLogging = useLogging;
+exports.useMessageDeletedEvents = useMessageDeletedEvents;
+exports.useMessageEditedEvents = useMessageEditedEvents;
+exports.useMessageManagement = useMessageManagement;
+exports.useMessageSentEvents = useMessageSentEvents;
+exports.useMessages = useMessages;
+exports.useRealtime = useRealtime;
+//# sourceMappingURL=index.js.map