mezon-js 2.12.14 → 2.12.16

package/dist/mezon-js.cjs.js

@@ -6856,6 +6856,70 @@ var WebSocketAdapterText = class {
 };
 
 // socket.ts
+function CreateChannelMessageFromEvent(message) {
+  var content, reactions, mentions, attachments, references, referencedMessags;
+  try {
+    content = safeJSONParse(message.channel_message.content);
+  } catch (e2) {
+    console.log("content is invalid", e2);
+  }
+  try {
+    reactions = safeJSONParse(message.channel_message.reactions);
+  } catch (e2) {
+    console.log("reactions is invalid", e2);
+  }
+  try {
+    mentions = safeJSONParse(message.channel_message.mentions);
+  } catch (e2) {
+    console.log("mentions is invalid", e2);
+  }
+  try {
+    attachments = safeJSONParse(message.channel_message.attachments);
+  } catch (e2) {
+    console.log("attachments is invalid", e2);
+  }
+  try {
+    references = safeJSONParse(message.channel_message.references);
+  } catch (e2) {
+    console.log("references is invalid", e2);
+  }
+  try {
+    referencedMessags = safeJSONParse(message.channel_message.referenced_message);
+  } catch (e2) {
+    console.log("referenced messages is invalid", e2);
+  }
+  var e = {
+    id: message.id || message.channel_message.message_id,
+    avatar: message.channel_message.avatar,
+    channel_id: message.channel_message.channel_id,
+    mode: message.channel_message.mode,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
+    code: message.channel_message.code,
+    create_time: message.channel_message.create_time,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    update_time: message.channel_message.update_time,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
+    username: message.channel_message.username,
+    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,
+    referenced_message: referencedMessags,
+    references,
+    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 e;
+}
 var _DefaultSocket = class _DefaultSocket {
   constructor(host, port, useSSL = false, verbose = false, adapter = new WebSocketAdapterText(), sendTimeoutMs = _DefaultSocket.DefaultSendTimeoutMs) {
     this.host = host;
@@ -6957,68 +7021,11 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.stream_data) {
           this.onstreamdata(message.stream_data);
         } else if (message.channel_message) {
-          var content, reactions, mentions, attachments, references, referencedMessags;
-          try {
-            content = safeJSONParse(message.channel_message.content);
-          } catch (e2) {
-            console.log("content is invalid", e2);
-          }
-          try {
-            reactions = safeJSONParse(message.channel_message.reactions);
-          } catch (e2) {
-            console.log("reactions is invalid", e2);
-          }
-          try {
-            mentions = safeJSONParse(message.channel_message.mentions);
-          } catch (e2) {
-            console.log("mentions is invalid", e2);
-          }
-          try {
-            attachments = safeJSONParse(message.channel_message.attachments);
-          } catch (e2) {
-            console.log("attachments is invalid", e2);
-          }
-          try {
-            references = safeJSONParse(message.channel_message.references);
-          } catch (e2) {
-            console.log("references is invalid", e2);
-          }
-          try {
-            referencedMessags = safeJSONParse(message.channel_message.referenced_message);
-          } catch (e2) {
-            console.log("referenced messages is invalid", e2);
-          }
-          var e = {
-            id: message.id || message.channel_message.message_id,
-            avatar: message.channel_message.avatar,
-            channel_id: message.channel_message.channel_id,
-            mode: message.channel_message.mode,
-            channel_label: message.channel_message.channel_label,
-            clan_id: message.channel_message.clan_id,
-            code: message.channel_message.code,
-            create_time: message.channel_message.create_time,
-            message_id: message.channel_message.message_id,
-            sender_id: message.channel_message.sender_id,
-            update_time: message.channel_message.update_time,
-            clan_logo: message.channel_message.clan_logo,
-            category_name: message.channel_message.category_name,
-            username: message.channel_message.username,
-            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,
-            referenced_message: referencedMessags,
-            references,
-            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
-          };
-          this.onchannelmessage(e);
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onchannelmessage(channelMessage);
+        } else if (message.ephemeral_message_send) {
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onephemeralmessage(channelMessage);
         } else if (message.message_typing_event) {
           this.onmessagetyping(
             message.message_typing_event
@@ -7053,6 +7060,8 @@ var _DefaultSocket = class _DefaultSocket {
           this.onuserchannelremoved(
             message.user_channel_removed_event
           );
+        } else if (message.block_friend) {
+          this.onblockfriend(message.block_friend);
         } else if (message.remove_friend) {
           this.onremovefriend(message.remove_friend);
         } else if (message.user_clan_removed_event) {
@@ -7194,6 +7203,11 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(channelMessage);
     }
   }
+  onephemeralmessage(ephemeralMessage) {
+    if (this.verbose && window && window.console) {
+      console.log(ephemeralMessage);
+    }
+  }
   onchannelpresence(channelPresence) {
     if (this.verbose && window && window.console) {
       console.log(channelPresence);
@@ -7224,6 +7238,11 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(user);
     }
   }
+  onblockfriend(user) {
+    if (this.verbose && window && window.console) {
+      console.log(user);
+    }
+  }
   onuserclanremoved(user) {
     if (this.verbose && window && window.console) {
       console.log(user);
@@ -7477,6 +7496,7 @@ var _DefaultSocket = class _DefaultSocket {
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
     const untypedMessage = message;
     return new Promise((resolve, reject) => {
+      var _a;
       if (!this.adapter.isOpen()) {
         reject("Socket connection has not been established yet.");
       } else {
@@ -7488,6 +7508,10 @@ var _DefaultSocket = class _DefaultSocket {
           untypedMessage.channel_message_update.content = JSON.stringify(
             untypedMessage.channel_message_update.content
           );
+        } else if (untypedMessage.ephemeral_message_send) {
+          untypedMessage.ephemeral_message_send.message.content = JSON.stringify(
+            (_a = untypedMessage.ephemeral_message_send.message) == null ? void 0 : _a.content
+          );
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
@@ -7613,6 +7637,31 @@ var _DefaultSocket = class _DefaultSocket {
   updateStatus(status) {
     return this.send({ status_update: { status } });
   }
+  writeEphemeralMessage(receiver_id, 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({
+        ephemeral_message_send: {
+          receiver_id,
+          message: {
+            clan_id,
+            channel_id,
+            mode,
+            is_public,
+            content,
+            mentions,
+            attachments,
+            references,
+            anonymous_message,
+            mention_everyone,
+            avatar,
+            code,
+            topic_id
+          }
+        }
+      });
+      return response.channel_message_ack;
+    });
+  }
   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({

package/dist/mezon-js.esm.mjs

@@ -6822,6 +6822,70 @@ var WebSocketAdapterText = class {
 };
 
 // socket.ts
+function CreateChannelMessageFromEvent(message) {
+  var content, reactions, mentions, attachments, references, referencedMessags;
+  try {
+    content = safeJSONParse(message.channel_message.content);
+  } catch (e2) {
+    console.log("content is invalid", e2);
+  }
+  try {
+    reactions = safeJSONParse(message.channel_message.reactions);
+  } catch (e2) {
+    console.log("reactions is invalid", e2);
+  }
+  try {
+    mentions = safeJSONParse(message.channel_message.mentions);
+  } catch (e2) {
+    console.log("mentions is invalid", e2);
+  }
+  try {
+    attachments = safeJSONParse(message.channel_message.attachments);
+  } catch (e2) {
+    console.log("attachments is invalid", e2);
+  }
+  try {
+    references = safeJSONParse(message.channel_message.references);
+  } catch (e2) {
+    console.log("references is invalid", e2);
+  }
+  try {
+    referencedMessags = safeJSONParse(message.channel_message.referenced_message);
+  } catch (e2) {
+    console.log("referenced messages is invalid", e2);
+  }
+  var e = {
+    id: message.id || message.channel_message.message_id,
+    avatar: message.channel_message.avatar,
+    channel_id: message.channel_message.channel_id,
+    mode: message.channel_message.mode,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
+    code: message.channel_message.code,
+    create_time: message.channel_message.create_time,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    update_time: message.channel_message.update_time,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
+    username: message.channel_message.username,
+    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,
+    referenced_message: referencedMessags,
+    references,
+    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 e;
+}
 var _DefaultSocket = class _DefaultSocket {
   constructor(host, port, useSSL = false, verbose = false, adapter = new WebSocketAdapterText(), sendTimeoutMs = _DefaultSocket.DefaultSendTimeoutMs) {
     this.host = host;
@@ -6923,68 +6987,11 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.stream_data) {
           this.onstreamdata(message.stream_data);
         } else if (message.channel_message) {
-          var content, reactions, mentions, attachments, references, referencedMessags;
-          try {
-            content = safeJSONParse(message.channel_message.content);
-          } catch (e2) {
-            console.log("content is invalid", e2);
-          }
-          try {
-            reactions = safeJSONParse(message.channel_message.reactions);
-          } catch (e2) {
-            console.log("reactions is invalid", e2);
-          }
-          try {
-            mentions = safeJSONParse(message.channel_message.mentions);
-          } catch (e2) {
-            console.log("mentions is invalid", e2);
-          }
-          try {
-            attachments = safeJSONParse(message.channel_message.attachments);
-          } catch (e2) {
-            console.log("attachments is invalid", e2);
-          }
-          try {
-            references = safeJSONParse(message.channel_message.references);
-          } catch (e2) {
-            console.log("references is invalid", e2);
-          }
-          try {
-            referencedMessags = safeJSONParse(message.channel_message.referenced_message);
-          } catch (e2) {
-            console.log("referenced messages is invalid", e2);
-          }
-          var e = {
-            id: message.id || message.channel_message.message_id,
-            avatar: message.channel_message.avatar,
-            channel_id: message.channel_message.channel_id,
-            mode: message.channel_message.mode,
-            channel_label: message.channel_message.channel_label,
-            clan_id: message.channel_message.clan_id,
-            code: message.channel_message.code,
-            create_time: message.channel_message.create_time,
-            message_id: message.channel_message.message_id,
-            sender_id: message.channel_message.sender_id,
-            update_time: message.channel_message.update_time,
-            clan_logo: message.channel_message.clan_logo,
-            category_name: message.channel_message.category_name,
-            username: message.channel_message.username,
-            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,
-            referenced_message: referencedMessags,
-            references,
-            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
-          };
-          this.onchannelmessage(e);
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onchannelmessage(channelMessage);
+        } else if (message.ephemeral_message_send) {
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onephemeralmessage(channelMessage);
         } else if (message.message_typing_event) {
           this.onmessagetyping(
             message.message_typing_event
@@ -7019,6 +7026,8 @@ var _DefaultSocket = class _DefaultSocket {
           this.onuserchannelremoved(
             message.user_channel_removed_event
           );
+        } else if (message.block_friend) {
+          this.onblockfriend(message.block_friend);
         } else if (message.remove_friend) {
           this.onremovefriend(message.remove_friend);
         } else if (message.user_clan_removed_event) {
@@ -7160,6 +7169,11 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(channelMessage);
     }
   }
+  onephemeralmessage(ephemeralMessage) {
+    if (this.verbose && window && window.console) {
+      console.log(ephemeralMessage);
+    }
+  }
   onchannelpresence(channelPresence) {
     if (this.verbose && window && window.console) {
       console.log(channelPresence);
@@ -7190,6 +7204,11 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(user);
     }
   }
+  onblockfriend(user) {
+    if (this.verbose && window && window.console) {
+      console.log(user);
+    }
+  }
   onuserclanremoved(user) {
     if (this.verbose && window && window.console) {
       console.log(user);
@@ -7443,6 +7462,7 @@ var _DefaultSocket = class _DefaultSocket {
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
     const untypedMessage = message;
     return new Promise((resolve, reject) => {
+      var _a;
       if (!this.adapter.isOpen()) {
         reject("Socket connection has not been established yet.");
       } else {
@@ -7454,6 +7474,10 @@ var _DefaultSocket = class _DefaultSocket {
           untypedMessage.channel_message_update.content = JSON.stringify(
             untypedMessage.channel_message_update.content
           );
+        } else if (untypedMessage.ephemeral_message_send) {
+          untypedMessage.ephemeral_message_send.message.content = JSON.stringify(
+            (_a = untypedMessage.ephemeral_message_send.message) == null ? void 0 : _a.content
+          );
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
@@ -7579,6 +7603,31 @@ var _DefaultSocket = class _DefaultSocket {
   updateStatus(status) {
     return this.send({ status_update: { status } });
   }
+  writeEphemeralMessage(receiver_id, 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({
+        ephemeral_message_send: {
+          receiver_id,
+          message: {
+            clan_id,
+            channel_id,
+            mode,
+            is_public,
+            content,
+            mentions,
+            attachments,
+            references,
+            anonymous_message,
+            mention_everyone,
+            avatar,
+            code,
+            topic_id
+          }
+        }
+      });
+      return response.channel_message_ack;
+    });
+  }
   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({

package/dist/socket.d.ts

@@ -236,6 +236,29 @@ interface ChannelMessageSend {
         topic_id?: string;
     };
 }
+interface EphemeralMessageSend {
+    ephemeral_message_send: {
+        receiver_id: string;
+        message: {
+            /** Clan Id */
+            clan_id: string;
+            /** The server-assigned channel ID. */
+            channel_id: string;
+            mode: number;
+            channel_label: string;
+            /** The content payload. */
+            content: any;
+            mentions?: Array<ApiMessageMention>;
+            attachments?: Array<ApiMessageAttachment>;
+            anonymous_message?: boolean;
+            mention_everyone?: boolean;
+            avatar: string;
+            is_public: boolean;
+            code: number;
+            topic_id?: string;
+        };
+    };
+}
 /** Update a message previously sent to a realtime chat channel. */
 interface ChannelMessageUpdate {
     channel_message_update: {
@@ -578,6 +601,9 @@ export interface UserEmojiUsage {
 export interface RemoveFriend {
     user_id: string;
 }
+export interface BlockFriend {
+    user_id: string;
+}
 export interface AddUserEmojiUsageEvent {
     emoji_id: string;
     clan_id: string;
@@ -779,6 +805,8 @@ export interface Socket {
     updateStatus(status?: string): Promise<void>;
     /** Send a chat message to a chat channel on the server. */
     writeChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, content?: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
+    /** Send a chat message to a chat channel on the server. */
+    writeEphemeralMessage(receiver_id: string, clan_id: string, channel_id: string, mode: number, is_public: boolean, content?: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
     /** Send message typing */
     writeMessageTyping(clan_id: string, channel_id: string, mode: number, is_public: boolean, sender_display_name: string): Promise<MessageTypingEvent>;
     /** Send message reaction */
@@ -821,6 +849,8 @@ export interface Socket {
     oncanvasevent: (canvasEvent: ChannelCanvas) => void;
     /** Receive channel message. */
     onchannelmessage: (channelMessage: ChannelMessage) => void;
+    /** Receive channel message. */
+    onephemeralmessage: (ephemeralMessage: ChannelMessage) => void;
     /** Receive typing event */
     onmessagetyping: (messageTypingEvent: MessageTypingEvent) => void;
     /** Receive reaction event */
@@ -838,6 +868,7 @@ export interface Socket {
     /** Receive channel removed user event */
     onuserchannelremoved: (user: UserChannelRemovedEvent) => void;
     onremovefriend: (user: RemoveFriend) => void;
+    onblockfriend: (user: BlockFriend) => void;
     /** Receive clan removed user event */
     onuserclanremoved: (user: UserClanRemovedEvent) => void;
     onvoicestarted: (voice: VoiceStartedEvent) => void;
@@ -915,12 +946,14 @@ export declare class DefaultSocket implements Socket {
     onmessagetyping(messagetyping: MessageTypingEvent): void;
     onmessagereaction(messagereaction: ApiMessageReaction): void;
     onchannelmessage(channelMessage: ChannelMessage): void;
+    onephemeralmessage(ephemeralMessage: ChannelMessage): void;
     onchannelpresence(channelPresence: ChannelPresenceEvent): void;
     onuserchanneladded(user: UserChannelAddedEvent): void;
     onuserclanadded(user: AddClanUserEvent): void;
     onuserprofileupdate(user: UserProfileUpdatedEvent): void;
     onuserchannelremoved(user: UserChannelRemovedEvent): void;
     onremovefriend(user: RemoveFriend): void;
+    onblockfriend(user: BlockFriend): void;
     onuserclanremoved(user: UserClanRemovedEvent): void;
     onnotification(notification: ApiNotification): void;
     onstatuspresence(statusPresence: StatusPresenceEvent): void;
@@ -971,7 +1004,7 @@ export declare class DefaultSocket implements Socket {
     onuserstatusevent(user_status_event: UserStatusEvent): void;
     onJoinChannelAppEvent(join_channel_app_data: JoinChannelAppData): void;
     onUnpinMessageEvent(unpin_message_event: UnpinMessageEvent): void;
-    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping | WebrtcSignalingFwd | IncomingCallPush | MessageButtonClicked | DropdownBoxSelected | ChannelAppEvent, sendTimeout?: number): Promise<any>;
+    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping | WebrtcSignalingFwd | IncomingCallPush | MessageButtonClicked | DropdownBoxSelected | ChannelAppEvent | EphemeralMessageSend, sendTimeout?: number): Promise<any>;
     followUsers(userIds: string[]): Promise<Status>;
     joinClanChat(clan_id: string): Promise<ClanJoin>;
     follower(): Promise<void>;
@@ -983,6 +1016,7 @@ export declare class DefaultSocket implements Socket {
     unfollowUsers(user_ids: string[]): Promise<void>;
     updateChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, message_id: string, content: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, hideEditted?: boolean, topic_id?: string, is_update_msg_topic?: boolean): Promise<ChannelMessageAck>;
     updateStatus(status?: string): Promise<void>;
+    writeEphemeralMessage(receiver_id: string, clan_id: string, channel_id: string, mode: number, is_public: boolean, content: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: Boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
     writeChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, content: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: Boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
     writeMessageReaction(id: string, clan_id: string, channel_id: string, mode: number, is_public: boolean, message_id: string, emoji_id: string, emoji: string, count: number, message_sender_id: string, action_delete: boolean, topic_id?: string, emoji_recent_id?: string): Promise<ApiMessageReaction>;
     writeMessageTyping(clan_id: string, channel_id: string, mode: number, is_public: boolean, sender_display_name: string): Promise<MessageTypingEvent>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mezon-js",
 
-  "version": "2.12.14",
+  "version": "2.12.16",
 
   "scripts": {
     "build": "npx tsc && npx rollup -c --bundleConfigAsCjs && node build.mjs"

package/socket.ts

@@ -348,6 +348,40 @@ interface ChannelMessageSend {
   };
 }
 
+interface EphemeralMessageSend {
+  ephemeral_message_send: {
+    receiver_id: string,
+    message: {
+      /** Clan Id */
+      clan_id: string;
+      /** The server-assigned channel ID. */
+      channel_id: string;
+      // The mode
+      mode: number;
+      // channel label
+      channel_label: string;
+      /** The content payload. */
+      content: any;
+      //
+      mentions?: Array<ApiMessageMention>;
+      //
+      attachments?: Array<ApiMessageAttachment>;
+      //
+      anonymous_message?: boolean;
+      //
+      mention_everyone?: boolean;
+      //
+      avatar: string;
+      // Is public
+      is_public: boolean;
+      // code
+      code: number;
+      //
+      topic_id?: string;
+    }
+  }
+}
+
 /** Update a message previously sent to a realtime chat channel. */
 interface ChannelMessageUpdate {
   channel_message_update: {
@@ -863,6 +897,11 @@ export interface RemoveFriend {
   user_id: string;
 }
 
+export interface BlockFriend {
+  //
+  user_id: string;
+}
+
 export interface AddUserEmojiUsageEvent {
   emoji_id: string;
   clan_id: string;
@@ -1062,6 +1101,72 @@ export interface ChannelCanvas {
   status?: number;
 }
 
+function CreateChannelMessageFromEvent(message: any) {
+  var content, reactions, mentions, attachments, references, referencedMessags;
+  try {
+    content = safeJSONParse(message.channel_message.content);
+  } catch (e) {
+    console.log("content is invalid", e);
+  }
+  try {
+    reactions = safeJSONParse(message.channel_message.reactions);
+  } catch (e) {
+    console.log("reactions is invalid", e);
+  }
+  try {
+    mentions = safeJSONParse(message.channel_message.mentions);
+  } catch (e) {
+    console.log("mentions is invalid", e);
+  }
+  try {
+    attachments = safeJSONParse(message.channel_message.attachments);
+  } catch (e) {
+    console.log("attachments is invalid", e);
+  }
+  try {
+    references = safeJSONParse(message.channel_message.references);
+  } catch (e) {
+    console.log("references is invalid", e);
+  }
+  try {
+    referencedMessags = safeJSONParse(message.channel_message.referenced_message);
+  } catch (e) {
+    console.log("referenced messages is invalid", e);
+  }
+  var e: ChannelMessage = {
+    id: message.id || message.channel_message.message_id,
+    avatar: message.channel_message.avatar,
+    channel_id: message.channel_message.channel_id,
+    mode: message.channel_message.mode,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
+    code: message.channel_message.code,
+    create_time: message.channel_message.create_time,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    update_time: message.channel_message.update_time,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
+    username: message.channel_message.username,
+    clan_nick: message.channel_message.clan_nick,
+    clan_avatar: message.channel_message.clan_avatar,
+    display_name: message.channel_message.display_name,
+    content: content,
+    reactions: reactions,
+    mentions: mentions,
+    attachments: attachments,
+    referenced_message: referencedMessags,
+    references: references,
+    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 e;
+}
+
 /** A socket connection to Mezon server. */
 export interface Socket {
   /** Connection is Open */
@@ -1163,6 +1268,24 @@ export interface Socket {
     topic_id?: string
   ): Promise<ChannelMessageAck>;
 
+  /** Send a chat message to a chat channel on the server. */
+  writeEphemeralMessage(
+    receiver_id: string,
+    clan_id: string,
+    channel_id: string,
+    mode: number,
+    is_public: boolean,
+    content?: any,
+    mentions?: Array<ApiMessageMention>,
+    attachments?: Array<ApiMessageAttachment>,
+    references?: Array<ApiMessageRef>,
+    anonymous_message?: boolean,
+    mention_everyone?: boolean,
+    avatar?: string,
+    code?: number,
+    topic_id?: string
+  ): Promise<ChannelMessageAck>;
+
   /** Send message typing */
   writeMessageTyping(
     clan_id: string,
@@ -1310,6 +1433,9 @@ export interface Socket {
   /** Receive channel message. */
   onchannelmessage: (channelMessage: ChannelMessage) => void;
 
+  /** Receive channel message. */
+  onephemeralmessage: (ephemeralMessage: ChannelMessage) => void;
+
   /** Receive typing event */
   onmessagetyping: (messageTypingEvent: MessageTypingEvent) => void;
 
@@ -1336,6 +1462,8 @@ export interface Socket {
 
   onremovefriend: (user: RemoveFriend) => void;
 
+  onblockfriend: (user: BlockFriend) => void;
+
   /** Receive clan removed user event */
   onuserclanremoved: (user: UserClanRemovedEvent) => void;
 
@@ -1576,69 +1704,12 @@ export class DefaultSocket implements Socket {
           );
         } else if (message.stream_data) {
           this.onstreamdata(<StreamData>message.stream_data);
-        } else if (message.channel_message) {
-          var content, reactions, mentions, attachments, references, referencedMessags;
-          try {
-            content = safeJSONParse(message.channel_message.content);
-          } catch (e) {
-            console.log("content is invalid", e);
-          }
-          try {
-            reactions = safeJSONParse(message.channel_message.reactions);
-          } catch (e) {
-            console.log("reactions is invalid", e);
-          }
-          try {
-            mentions = safeJSONParse(message.channel_message.mentions);
-          } catch (e) {
-            console.log("mentions is invalid", e);
-          }
-          try {
-            attachments = safeJSONParse(message.channel_message.attachments);
-          } catch (e) {
-            console.log("attachments is invalid", e);
-          }
-          try {
-            references = safeJSONParse(message.channel_message.references);
-          } catch (e) {
-            console.log("references is invalid", e);
-          }
-          try {
-            referencedMessags = safeJSONParse(message.channel_message.referenced_message);
-          } catch (e) {
-            console.log("referenced messages is invalid", e);
-          }
-          var e: ChannelMessage = {
-            id: message.id || message.channel_message.message_id,
-            avatar: message.channel_message.avatar,
-            channel_id: message.channel_message.channel_id,
-            mode: message.channel_message.mode,
-            channel_label: message.channel_message.channel_label,
-            clan_id: message.channel_message.clan_id,
-            code: message.channel_message.code,
-            create_time: message.channel_message.create_time,
-            message_id: message.channel_message.message_id,
-            sender_id: message.channel_message.sender_id,
-            update_time: message.channel_message.update_time,
-            clan_logo: message.channel_message.clan_logo,
-            category_name: message.channel_message.category_name,
-            username: message.channel_message.username,
-            clan_nick: message.channel_message.clan_nick,
-            clan_avatar: message.channel_message.clan_avatar,
-            display_name: message.channel_message.display_name,
-            content: content,
-            reactions: reactions,
-            mentions: mentions,
-            attachments: attachments,
-            referenced_message: referencedMessags,
-            references: references,
-            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,
-          };
-          this.onchannelmessage(e);
+        } else if (message.channel_message) {          
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onchannelmessage(channelMessage);
+        } else if (message.ephemeral_message_send) {
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onephemeralmessage(channelMessage);
         } else if (message.message_typing_event) {
           this.onmessagetyping(
             <MessageTypingEvent>message.message_typing_event
@@ -1673,6 +1744,8 @@ export class DefaultSocket implements Socket {
           this.onuserchannelremoved(
             <UserChannelRemovedEvent>message.user_channel_removed_event
           );
+        } else if (message.block_friend) {
+          this.onblockfriend(<BlockFriend>message.block_friend);
         } else if (message.remove_friend) {
           this.onremovefriend(<RemoveFriend>message.remove_friend);
         } else if (message.user_clan_removed_event) {
@@ -1828,6 +1901,12 @@ export class DefaultSocket implements Socket {
     }
   }
 
+  onephemeralmessage(ephemeralMessage: ChannelMessage) {
+    if (this.verbose && window && window.console) {
+      console.log(ephemeralMessage)
+    }
+  }
+
   onchannelpresence(channelPresence: ChannelPresenceEvent) {
     if (this.verbose && window && window.console) {
       console.log(channelPresence);
@@ -1864,6 +1943,12 @@ export class DefaultSocket implements Socket {
     }
   }
 
+  onblockfriend(user: BlockFriend) {
+    if (this.verbose && window && window.console) {
+      console.log(user);
+    }
+  }
+
   onuserclanremoved(user: UserClanRemovedEvent) {
     if (this.verbose && window && window.console) {
       console.log(user);
@@ -2183,7 +2268,8 @@ export class DefaultSocket implements Socket {
       | IncomingCallPush
       | MessageButtonClicked
       | DropdownBoxSelected
-      | ChannelAppEvent,
+      | ChannelAppEvent
+      | EphemeralMessageSend,
     sendTimeout = DefaultSocket.DefaultSendTimeoutMs
   ): Promise<any> {
     const untypedMessage = message as any;
@@ -2200,6 +2286,10 @@ export class DefaultSocket implements Socket {
           untypedMessage.channel_message_update.content = JSON.stringify(
             untypedMessage.channel_message_update.content
           );
+        } else if (untypedMessage.ephemeral_message_send) {
+          untypedMessage.ephemeral_message_send.message.content = JSON.stringify(
+            untypedMessage.ephemeral_message_send.message?.content
+          ); 
         }
 
         const cid = this.generatecid();
@@ -2365,6 +2455,45 @@ export class DefaultSocket implements Socket {
     return this.send({ status_update: { status: status } });
   }
 
+  async writeEphemeralMessage(
+    receiver_id: string,
+    clan_id: string,
+    channel_id: string,
+    mode: number,
+    is_public: boolean,
+    content: any,
+    mentions?: Array<ApiMessageMention>,
+    attachments?: Array<ApiMessageAttachment>,
+    references?: Array<ApiMessageRef>,
+    anonymous_message?: boolean,
+    mention_everyone?: Boolean,
+    avatar?: string,
+    code?: number,
+    topic_id?: string
+  ): Promise<ChannelMessageAck> {
+    const response = await this.send({
+      ephemeral_message_send: {
+        receiver_id: receiver_id,
+        message: {
+          clan_id: clan_id,
+          channel_id: channel_id,
+          mode: mode,
+          is_public: is_public,
+          content: content,
+          mentions: mentions,
+          attachments: attachments,
+          references: references,
+          anonymous_message: anonymous_message,
+          mention_everyone: mention_everyone,
+          avatar: avatar,
+          code: code,
+          topic_id: topic_id,
+        }
+      }
+    });
+    return response.channel_message_ack;
+  }
+
   async writeChatMessage(
     clan_id: string,
     channel_id: string,
@@ -2666,3 +2795,4 @@ export class DefaultSocket implements Socket {
     setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
   }
 }
+