mezon-js 2.14.2 → 2.14.4

package/dist/mezon-js.esm.mjs

@@ -35015,30 +35015,30 @@ function createChannelMessageFromEvent(message) {
   var channelMessage = {
     id: message.id || message.channel_message.message_id,
     avatar: message.channel_message.avatar,
-    channelId: message.channel_message.channel_id,
+    channel_id: message.channel_message.channel_id,
     mode: message.channel_message.mode,
-    channelLabel: message.channel_message.channel_label,
-    clanId: message.channel_message.clan_id,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
     code: message.channel_message.code,
-    messageId: message.channel_message.message_id,
-    senderId: message.channel_message.sender_id,
-    clanLogo: message.channel_message.clan_logo,
-    categoryName: message.channel_message.category_name,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
     username: message.channel_message.username,
-    clanNick: message.channel_message.clan_nick,
-    clanAvatar: message.channel_message.clan_avatar,
-    displayName: message.channel_message.display_name,
+    clan_nick: message.channel_message.clan_nick,
+    clan_avatar: message.channel_message.clan_avatar,
+    display_name: message.channel_message.display_name,
     content,
     reactions,
     mentions,
     attachments,
-    referencedMessage: [],
+    referenced_message: [],
     references,
-    hideEditted: message.channel_message.hide_editted,
-    isPublic: message.channel_message.is_public,
-    createTimeSeconds: message.channel_message.create_time_seconds,
-    updateTimeSeconds: message.channel_message.update_time_seconds,
-    topicId: message.channel_message.topic_id
+    hide_editted: message.channel_message.hide_editted,
+    is_public: message.channel_message.is_public,
+    create_time_seconds: message.channel_message.create_time_seconds,
+    update_time_seconds: message.channel_message.update_time_seconds,
+    topic_id: message.channel_message.topic_id
   };
   return channelMessage;
 }
@@ -35100,11 +35100,12 @@ var _DefaultSocket = class _DefaultSocket {
       }
       if (!message.cid) {
         if (message.notifications) {
-          console.log("Received notifications: %o", message.notifications);
-          message.notifications.notifications.forEach((n) => {
-            n.content = n.content ? safeJSONParse(n.content) : void 0;
-            this.onnotification(n);
-          });
+          message.notifications.notifications.forEach(
+            (n) => {
+              n.content = n.content ? safeJSONParse(n.content) : void 0;
+              this.onnotification(n);
+            }
+          );
         } else if (message.voice_started_event) {
           this.onvoicestarted(message.voice_started_event);
         } else if (message.voice_ended_event) {
@@ -35122,9 +35123,7 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.event_emoji) {
           this.oneventemoji(message.event_emoji);
         } else if (message.noti_user_channel) {
-          this.oneventnotiuserchannel(
-            message.noti_user_channel
-          );
+          this.oneventnotiuserchannel(message.noti_user_channel);
         } else if (message.webhook_event) {
           this.oneventwebhook(message.webhook_event);
         } else if (message.channel_deleted_event) {
@@ -35142,44 +35141,58 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.delete_account_event) {
           this.ondeleteaccount(message.delete_account_event);
         } else if (message.clan_profile_updated_event) {
-          this.onclanprofileupdated(
-            message.clan_profile_updated_event
-          );
+          this.onclanprofileupdated(message.clan_profile_updated_event);
         } else if (message.clan_updated_event) {
           this.onclanupdated(message.clan_updated_event);
         } else if (message.last_seen_message_event) {
-          this.onlastseenupdated(
-            message.last_seen_message_event
-          );
+          this.onlastseenupdated(message.last_seen_message_event);
         } else if (message.status_presence_event) {
-          this.onstatuspresence(message.status_presence_event);
+          this.onstatuspresence(
+            message.status_presence_event
+          );
         } else if (message.stream_presence_event) {
-          this.onstreampresence(message.stream_presence_event);
+          this.onstreampresence(
+            message.stream_presence_event
+          );
         } else if (message.stream_data) {
           this.onstreamdata(message.stream_data);
         } else if (message.channel_message) {
           const channelMessage = createChannelMessageFromEvent(message);
           this.onchannelmessage(channelMessage);
         } else if (message.message_typing_event) {
-          this.onmessagetyping(message.message_typing_event);
+          this.onmessagetyping(
+            message.message_typing_event
+          );
         } else if (message.message_reaction_event) {
-          this.onmessagereaction(message.message_reaction_event);
+          this.onmessagereaction(
+            message.message_reaction_event
+          );
         } else if (message.channel_presence_event) {
-          this.onchannelpresence(message.channel_presence_event);
+          this.onchannelpresence(
+            message.channel_presence_event
+          );
         } else if (message.last_pin_message_event) {
-          this.onpinmessage(message.last_pin_message_event);
+          this.onpinmessage(
+            message.last_pin_message_event
+          );
         } else if (message.custom_status_event) {
           this.oncustomstatus(message.custom_status_event);
         } else if (message.canvas_event) {
           this.oncanvasevent(message.canvas_event);
         } else if (message.user_channel_added_event) {
-          this.onuserchanneladded(message.user_channel_added_event);
+          this.onuserchanneladded(
+            message.user_channel_added_event
+          );
         } else if (message.add_clan_user_event) {
           this.onuserclanadded(message.add_clan_user_event);
         } else if (message.user_profile_updated_event) {
-          this.onuserprofileupdate(message.user_profile_updated_event);
+          this.onuserprofileupdate(
+            message.user_profile_updated_event
+          );
         } else if (message.user_channel_removed_event) {
-          this.onuserchannelremoved(message.user_channel_removed_event);
+          this.onuserchannelremoved(
+            message.user_channel_removed_event
+          );
         } else if (message.block_friend) {
           this.onblockfriend(message.block_friend);
         } else if (message.un_block_friend) {
@@ -35189,7 +35202,9 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.remove_friend) {
           this.onremovefriend(message.remove_friend);
         } else if (message.user_clan_removed_event) {
-          this.onuserclanremoved(message.user_clan_removed_event);
+          this.onuserclanremoved(
+            message.user_clan_removed_event
+          );
         } else if (message.clan_event_created) {
           this.oneventcreated(message.clan_event_created);
         } else if (message.give_coffee_event) {
@@ -35197,31 +35212,49 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.role_assign_event) {
           this.onroleassign(message.role_assign_event);
         } else if (message.streaming_started_event) {
-          this.onstreamingchannelstarted(message.streaming_started_event);
+          this.onstreamingchannelstarted(
+            message.streaming_started_event
+          );
         } else if (message.streaming_ended_event) {
-          this.onstreamingchannelended(message.streaming_ended_event);
+          this.onstreamingchannelended(
+            message.streaming_ended_event
+          );
         } else if (message.streaming_joined_event) {
-          this.onstreamingchanneljoined(message.streaming_joined_event);
+          this.onstreamingchanneljoined(
+            message.streaming_joined_event
+          );
         } else if (message.streaming_leaved_event) {
-          this.onstreamingchannelleaved(message.streaming_leaved_event);
+          this.onstreamingchannelleaved(
+            message.streaming_leaved_event
+          );
         } else if (message.permission_set_event) {
           this.onpermissionset(message.permission_set_event);
         } else if (message.permission_changed_event) {
-          this.onpermissionchanged(message.permission_changed_event);
+          this.onpermissionchanged(
+            message.permission_changed_event
+          );
         } else if (message.unmute_event) {
           this.onunmuteevent(message.unmute_event);
         } else if (message.token_sent_event) {
           this.ontokensent(message.token_sent_event);
         } else if (message.message_button_clicked) {
-          this.onmessagebuttonclicked(message.message_button_clicked);
+          this.onmessagebuttonclicked(
+            message.message_button_clicked
+          );
         } else if (message.dropdown_box_selected) {
-          this.onmessagedropdownboxselected(message.dropdown_box_selected);
+          this.onmessagedropdownboxselected(
+            message.dropdown_box_selected
+          );
         } else if (message.mark_as_read) {
           this.onmarkasread(message.mark_as_read);
         } else if (message.voice_reaction_send) {
-          this.onvoicereactionmessage(message.voice_reaction_send);
+          this.onvoicereactionmessage(
+            message.voice_reaction_send
+          );
         } else if (message.webrtc_signaling_fwd) {
-          this.onwebrtcsignalingfwd(message.webrtc_signaling_fwd);
+          this.onwebrtcsignalingfwd(
+            message.webrtc_signaling_fwd
+          );
         } else if (message.list_activity) {
           this.onactivityupdated(message.list_activity);
         } else if (message.sd_topic_event) {
@@ -35231,19 +35264,29 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.user_status_event) {
           this.onuserstatusevent(message.user_status_event);
         } else if (message.join_channel_app_data) {
-          this.onjoinchannelappevent(message.join_channel_app_data);
+          this.onjoinchannelappevent(
+            message.join_channel_app_data
+          );
         } else if (message.unpin_message_event) {
-          this.onunpinmessageevent(message.unpin_message_event);
+          this.onunpinmessageevent(
+            message.unpin_message_event
+          );
         } else if (message.quick_menu_event) {
           this.onquickmenuevent(message.quick_menu_event);
         } else if (message.meet_participant_event) {
-          this.onmeetparticipantevent(message.meet_participant_event);
+          this.onmeetparticipantevent(
+            message.meet_participant_event
+          );
         } else if (message.transfer_ownership_event) {
-          this.ontransferownership(message.transfer_ownership_event);
+          this.ontransferownership(
+            message.transfer_ownership_event
+          );
         } else if (message.ban_user_event) {
           this.onbanneduser(message.ban_user_event);
         } else if (message.allow_anonymous_event) {
-          this.onallowanonymousevent(message.allow_anonymous_event);
+          this.onallowanonymousevent(
+            message.allow_anonymous_event
+          );
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -35717,14 +35760,14 @@ var _DefaultSocket = class _DefaultSocket {
       return response.status;
     });
   }
-  joinClanChat(clanId) {
+  joinClanChat(clan_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         clan_join: {
-          clan_id: clanId
+          clan_id
         }
       });
-      return response.clanJoin;
+      return response.clan_join;
     });
   }
   follower() {
@@ -35732,57 +35775,57 @@ var _DefaultSocket = class _DefaultSocket {
       const response = yield this.send({
         follow_event: {}
       });
-      return response.followEvent;
+      return response.follow_event;
     });
   }
-  joinChat(clanId, channelId, channelType, isPublic) {
+  joinChat(clan_id, channel_id, channel_type, is_public) {
     return __async(this, null, function* () {
       const response = yield this.send({
         channel_join: {
-          clan_id: clanId,
-          channel_id: channelId,
-          channel_type: channelType,
-          is_public: isPublic
+          clan_id,
+          channel_id,
+          channel_type,
+          is_public
         }
       });
       return response.channel;
     });
   }
-  handleParticipantMeetState(clanId, channelId, displayName, state, roomName) {
+  handleParticipantMeetState(clan_id, channel_id, display_name, state, room_name) {
     return __async(this, null, function* () {
       const response = yield this.send({
         handle_participant_meet_state_event: {
-          clan_id: clanId,
-          channel_id: channelId,
-          display_name: displayName,
+          clan_id,
+          channel_id,
+          display_name,
           state,
-          room_name: roomName
+          room_name
         }
       });
-      return response.handleParticipantMeetStateEvent;
+      return response.handle_participant_meet_state_event;
     });
   }
-  leaveChat(clanId, channelId, channelType, isPublic) {
+  leaveChat(clan_id, channel_id, channel_type, is_public) {
     return this.send({
       channel_leave: {
-        clan_id: clanId,
-        channel_id: channelId,
-        channel_type: channelType,
-        is_public: isPublic
+        clan_id,
+        channel_id,
+        channel_type,
+        is_public
       }
     });
   }
-  removeChatMessage(clanId, channelId, mode, isPublic, messageId, hasAttachment, topicId, mentions, references) {
+  removeChatMessage(clan_id, channel_id, mode, is_public, message_id, has_attachment, topic_id, mentions, references) {
     return __async(this, null, function* () {
       const response = yield this.send({
         channel_message_remove: {
-          clan_id: clanId,
-          channel_id: channelId,
+          clan_id,
+          channel_id,
           mode,
-          message_id: messageId,
-          is_public: isPublic,
-          has_attachment: hasAttachment,
-          topic_id: topicId,
+          message_id,
+          is_public,
+          has_attachment,
+          topic_id,
           mentions,
           references
         }
@@ -35790,37 +35833,37 @@ var _DefaultSocket = class _DefaultSocket {
       return response.channel_message_ack;
     });
   }
-  rpc(id, payload, httpKey) {
+  rpc(id, payload, http_key) {
     return __async(this, null, function* () {
       const response = yield this.send({
         rpc: {
           id,
           payload,
-          http_key: httpKey
+          http_key
         }
       });
       return response.rpc;
     });
   }
-  unfollowUsers(userIds) {
-    return this.send({ status_unfollow: { user_ids: userIds } });
+  unfollowUsers(user_ids) {
+    return this.send({ status_unfollow: { user_ids } });
   }
-  updateChatMessage(clanId, channelId, mode, isPublic, messageId, content, mentions, attachments, hideEditted, topicId, isUpdateMsgTopic, oldMentions) {
+  updateChatMessage(clan_id, channel_id, mode, is_public, message_id, content, mentions, attachments, hide_editted, topic_id, is_update_msg_topic, old_mentions) {
     return __async(this, null, function* () {
       const response = yield this.send({
         channel_message_update: {
-          clan_id: clanId,
-          channel_id: channelId,
-          message_id: messageId,
+          clan_id,
+          channel_id,
+          message_id,
           content,
           mentions,
           attachments,
           mode,
-          is_public: isPublic,
-          hide_editted: hideEditted,
-          topic_id: topicId,
-          is_update_msg_topic: isUpdateMsgTopic,
-          old_mentions: oldMentions
+          is_public,
+          hide_editted,
+          topic_id,
+          is_update_msg_topic,
+          old_mentions
         }
       });
       return response.channel_message_ack;
@@ -35829,50 +35872,50 @@ var _DefaultSocket = class _DefaultSocket {
   updateStatus(status) {
     return this.send({ status_update: { status } });
   }
-  writeQuickMenuEvent(menuName, clanId, channelId, mode, isPublic, content, mentions, attachments, references, anonymousMessage, mentionEveryone, avatar, code, topicId) {
+  writeQuickMenuEvent(menu_name, clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         quick_menu_event: {
-          menuName,
+          menu_name,
           message: {
-            clan_id: clanId,
-            channel_id: channelId,
+            clan_id,
+            channel_id,
             mode,
-            is_public: isPublic,
+            is_public,
             content,
             mentions,
             attachments,
             references,
-            anonymous_message: anonymousMessage,
-            mention_everyone: mentionEveryone,
+            anonymous_message,
+            mention_everyone,
             avatar,
             code,
-            topic_id: topicId
+            topic_id
           }
         }
       });
-      return response.quick_menu_event;
+      return response.ephemeral_message_send;
     });
   }
-  writeEphemeralMessage(receiverId, clanId, channelId, mode, isPublic, content, mentions, attachments, references, anonymousMessage, mentionEveryone, avatar, code, topicId, id) {
+  writeEphemeralMessage(receiver_id, clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id, id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         ephemeral_message_send: {
-          receiver_id: receiverId,
+          receiver_id,
           message: {
-            clan_id: clanId,
-            channel_id: channelId,
+            clan_id,
+            channel_id,
             mode,
-            is_public: isPublic,
+            is_public,
             content,
             mentions,
             attachments,
             references,
-            anonymous_message: anonymousMessage,
-            mention_everyone: mentionEveryone,
+            anonymous_message,
+            mention_everyone,
             avatar,
             code,
-            topic_id: topicId,
+            topic_id,
             id
           }
         }
@@ -35880,24 +35923,24 @@ var _DefaultSocket = class _DefaultSocket {
       return response.ephemeral_message_send;
     });
   }
-  writeChatMessage(clanId, channelId, mode, isPublic, content, mentions, attachments, references, anonymousMessage, mentionEveryone, avatar, code, topicId) {
+  writeChatMessage(clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id) {
     return __async(this, null, function* () {
       const response = yield this.send(
         {
           channel_message_send: {
-            clan_id: clanId,
-            channel_id: channelId,
+            clan_id,
+            channel_id,
             mode,
-            is_public: isPublic,
+            is_public,
             content,
             mentions,
             attachments,
             references,
-            anonymous_message: anonymousMessage,
-            mention_everyone: mentionEveryone,
+            anonymous_message,
+            mention_everyone,
             avatar,
             code,
-            topic_id: topicId
+            topic_id
           }
         },
         Infinity
@@ -35905,192 +35948,192 @@ var _DefaultSocket = class _DefaultSocket {
       return response.channel_message_ack;
     });
   }
-  writeMessageReaction(id, clanId, channelId, mode, isPublic, messageId, emojiId, emoji, count, messageSenderId, action_delete, topicId, emojiRecentId, senderName) {
+  writeMessageReaction(id, clan_id, channel_id, mode, is_public, message_id, emoji_id, emoji, count, message_sender_id, action_delete, topic_id, emoji_recent_id, sender_name) {
     return __async(this, null, function* () {
       const response = yield this.send({
         message_reaction_event: {
           id,
-          clan_id: clanId,
-          channel_id: channelId,
+          clan_id,
+          channel_id,
           mode,
-          is_public: isPublic,
-          message_id: messageId,
-          emoji_id: emojiId,
+          is_public,
+          message_id,
+          emoji_id,
           emoji,
           count,
-          message_sender_id: messageSenderId,
+          message_sender_id,
           action: action_delete,
-          topic_id: topicId,
-          emoji_recent_id: emojiRecentId,
-          sender_name: senderName
+          topic_id,
+          emoji_recent_id,
+          sender_name
         }
       });
       return response.message_reaction_event;
     });
   }
-  writeMessageTyping(clanId, channelId, mode, isPublic, senderDisplayName, topicId) {
+  writeMessageTyping(clan_id, channel_id, mode, is_public, sender_display_name, topic_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         message_typing_event: {
-          clan_id: clanId,
-          channel_id: channelId,
+          clan_id,
+          channel_id,
           mode,
-          is_public: isPublic,
-          sender_display_name: senderDisplayName,
-          topic_id: topicId
+          is_public,
+          sender_display_name,
+          topic_id
         }
       });
       return response.message_typing_event;
     });
   }
-  writeLastSeenMessage(clanId, channelId, mode, messageId, timestampSeconds, badgeCount) {
+  writeLastSeenMessage(clan_id, channel_id, mode, message_id, timestamp_seconds, badge_count) {
     return __async(this, null, function* () {
       const response = yield this.send({
         last_seen_message_event: {
-          clan_id: clanId,
-          channel_id: channelId,
+          clan_id,
+          channel_id,
           mode,
-          message_id: messageId,
-          timestamp_seconds: timestampSeconds,
-          badge_count: badgeCount
+          message_id,
+          timestamp_seconds,
+          badge_count
         }
       });
       return response.last_seen_message_event;
     });
   }
-  writeLastPinMessage(clanId, channelId, mode, isPublic, messageId, timestampSeconds, operation, messageSenderAvatar, messageSenderId, messageSenderUsername, messageContent, messageAttachment, messageCreatedTime) {
+  writeLastPinMessage(clan_id, channel_id, mode, is_public, message_id, timestamp_seconds, operation, message_sender_avatar, message_sender_id, message_sender_username, message_content, message_attachment, message_created_time) {
     return __async(this, null, function* () {
       const response = yield this.send({
         last_pin_message_event: {
-          clan_id: clanId,
-          channel_id: channelId,
+          clan_id,
+          channel_id,
           mode,
-          is_public: isPublic,
-          message_id: messageId,
-          timestamp_seconds: timestampSeconds,
+          is_public,
+          message_id,
+          timestamp_seconds,
           operation,
-          message_sender_avatar: messageSenderAvatar,
-          message_sender_id: messageSenderId,
-          message_sender_username: messageSenderUsername,
-          message_content: messageContent,
-          message_attachment: messageAttachment,
-          message_created_time: messageCreatedTime
+          message_sender_avatar,
+          message_sender_id,
+          message_sender_username,
+          message_content,
+          message_attachment,
+          message_created_time
         }
       });
       return response.last_pin_message_event;
     });
   }
-  writeCustomStatus(clanId, status, timeReset, noClear) {
+  writeCustomStatus(clan_id, status, time_reset, no_clear) {
     return __async(this, null, function* () {
       const response = yield this.send({
         custom_status_event: {
-          clan_id: clanId,
+          clan_id,
           status,
-          time_reset: timeReset,
-          no_clear: noClear
+          time_reset,
+          no_clear
         }
       });
       return response.custom_status_event;
     });
   }
-  writeActiveArchivedThread(clanId, channelId) {
+  writeActiveArchivedThread(clan_id, channel_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         active_archived_thread: {
-          clan_id: clanId,
-          channel_id: channelId
+          clan_id,
+          channel_id
         }
       });
       return response.active_archived_thread;
     });
   }
-  checkDuplicateName(name, condition_id, type, clanId) {
+  checkDuplicateName(name, condition_id, type, clan_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         check_name_existed_event: {
           name,
           condition_id,
           type,
-          clan_id: clanId
+          clan_id
         }
       });
       return response.check_name_existed_event;
     });
   }
-  writeVoiceReaction(emojis, channelId) {
+  writeVoiceReaction(emojis, channel_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         voice_reaction_send: {
           emojis,
-          channel_id: channelId
+          channel_id
         }
       });
       return response.voice_reaction_send;
     });
   }
-  forwardWebrtcSignaling(receiverId, dataType, jsonData, channelId, callerId) {
+  forwardWebrtcSignaling(receiver_id, data_type, json_data, channel_id, caller_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         webrtc_signaling_fwd: {
-          receiver_id: receiverId,
-          data_type: dataType,
-          json_data: jsonData,
-          channel_id: channelId,
-          caller_id: callerId
+          receiver_id,
+          data_type,
+          json_data,
+          channel_id,
+          caller_id
         }
       });
       return response.webrtc_signaling_fwd;
     });
   }
-  makeCallPush(receiverId, jsonData, channelId, callerId) {
+  makeCallPush(receiver_id, json_data, channel_id, caller_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
         incoming_call_push: {
-          receiver_id: receiverId,
-          json_data: jsonData,
-          channel_id: channelId,
-          caller_id: callerId
+          receiver_id,
+          json_data,
+          channel_id,
+          caller_id
         }
       });
       return response.incoming_call_push;
     });
   }
-  handleDropdownBoxSelected(messageId, channelId, selectboxId, senderId, userId, value) {
+  handleDropdownBoxSelected(message_id, channel_id, selectbox_id, sender_id, user_id, value) {
     return __async(this, null, function* () {
       const response = yield this.send({
         dropdown_box_selected: {
-          message_id: messageId,
-          channel_id: channelId,
-          selectbox_id: selectboxId,
-          sender_id: senderId,
-          user_id: userId,
+          message_id,
+          channel_id,
+          selectbox_id,
+          sender_id,
+          user_id,
           value
         }
       });
       return response.dropdown_box_selected;
     });
   }
-  handleMessageButtonClick(messageId, channelId, buttonId, senderId, userId, extraData) {
+  handleMessageButtonClick(message_id, channel_id, button_id, sender_id, user_id, extra_data) {
     return __async(this, null, function* () {
       const response = yield this.send({
         message_button_clicked: {
-          message_id: messageId,
-          channel_id: channelId,
-          button_id: buttonId,
-          sender_id: senderId,
-          user_id: userId,
-          extra_data: extraData
+          message_id,
+          channel_id,
+          button_id,
+          sender_id,
+          user_id,
+          extra_data
         }
       });
       return response.webrtc_signaling_fwd;
     });
   }
-  writeChannelAppEvent(clanId, channelId, action) {
+  writeChannelAppEvent(clan_id, channel_id, action) {
     return __async(this, null, function* () {
       const response = yield this.send({
         channel_app_event: {
-          clan_id: clanId,
-          channel_id: channelId,
+          clan_id,
+          channel_id,
           action
         }
       });