whatsapp-web.js 1.28.0 → 1.29.0

package/src/factories/ChatFactory.js

@@ -2,15 +2,20 @@
 
 const PrivateChat = require('../structures/PrivateChat');
 const GroupChat = require('../structures/GroupChat');
+const Channel = require('../structures/Channel');
 
 class ChatFactory {
     static create(client, data) {
-        if(data.isGroup) {
+        if (data.isGroup) {
             return new GroupChat(client, data);
         }
+        
+        if (data.isChannel) {
+            return new Channel(client, data);
+        }
 
         return new PrivateChat(client, data);
     }
 }
 
-module.exports = ChatFactory;
+module.exports = ChatFactory;

package/src/structures/Broadcast.js

@@ -43,7 +43,7 @@ class Broadcast extends Base {
          * Messages statuses
          * @type {Message[]}
          */
-        this.msgs = data.msgs.map(msg => new Message(this.client, msg));
+        this.msgs = data.msgs?.map(msg => new Message(this.client, msg));
 
         return super._patch(data);
     }

package/src/structures/Channel.js

@@ -0,0 +1,382 @@
+'use strict';
+
+const Base = require('./Base');
+const Message = require('./Message');
+
+/**
+ * Channel ID structure
+ * @typedef {Object} ChannelId
+ * @property {string} server
+ * @property {string} user
+ * @property {string} _serialized
+ */
+
+/**
+ * Represents a Channel on WhatsApp
+ * @extends {Base}
+ */
+class Channel extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if (data) this._patch(data);
+    }
+
+    _patch(data) {
+        this.channelMetadata = data.channelMetadata;
+
+        /**
+         * ID that represents the channel
+         * @type {ChannelId}
+         */
+        this.id = data.id;
+
+        /**
+         * Title of the channel
+         * @type {string}
+         */
+        this.name = data.name;
+
+        /** 
+         * The channel description
+         * @type {string}
+         */
+        this.description = data.channelMetadata.description;
+
+        /**
+         * Indicates if it is a Channel
+         * @type {boolean}
+         */
+        this.isChannel = data.isChannel;
+
+        /**
+         * Indicates if it is a Group
+         * @type {boolean}
+         */
+        this.isGroup = data.isGroup;
+
+        /**
+         * Indicates if the channel is readonly
+         * @type {boolean}
+         */
+        this.isReadOnly = data.isReadOnly;
+
+        /**
+         * Amount of messages unread
+         * @type {number}
+         */
+        this.unreadCount = data.unreadCount;
+
+        /**
+         * Unix timestamp for when the last activity occurred
+         * @type {number}
+         */
+        this.timestamp = data.t;
+
+        /**
+         * Indicates if the channel is muted or not
+         * @type {boolean}
+         */
+        this.isMuted = data.isMuted;
+
+        /**
+         * Unix timestamp for when the mute expires
+         * @type {number}
+         */
+        this.muteExpiration = data.muteExpiration;
+
+        /**
+         * Last message in the channel
+         * @type {Message}
+         */
+        this.lastMessage = data.lastMessage ? new Message(super.client, data.lastMessage) : undefined;
+
+        return super._patch(data);
+    }
+
+    /**
+     * Gets the subscribers of the channel (only those who are in your contact list)
+     * @param {?number} limit Optional parameter to specify the limit of subscribers to retrieve
+     * @returns {Promise<{contact: Contact, role: string}[]>} Returns an array of objects that handle the subscribed contacts and their roles in the channel
+     */
+    async getSubscribers(limit) {
+        return await this.client.pupPage.evaluate(async (channelId, limit) => {
+            const channel = await window.WWebJS.getChat(channelId, { getAsModel: false });
+            if (!channel) return [];
+            !limit && (limit = window.Store.ChannelUtils.getMaxSubscriberNumber());
+            const response = await window.Store.ChannelSubscribers.mexFetchNewsletterSubscribers(channelId, limit);
+            const contacts = window.Store.ChannelSubscribers.getSubscribersInContacts(response.subscribers);
+            return Promise.all(contacts.map((obj) => ({
+                ...obj,
+                contact: window.WWebJS.getContactModel(obj.contact)
+            })));
+        }, this.id._serialized, limit);
+    }
+
+    /**
+     * Updates the channel subject
+     * @param {string} newSubject 
+     * @returns {Promise<boolean>} Returns true if the subject was properly updated. This can return false if the user does not have the necessary permissions.
+     */
+    async setSubject(newSubject) {
+        const success = await this._setChannelMetadata({ name: newSubject }, { editName: true });
+        success && (this.name = newSubject);
+        return success;
+    }
+
+    /**
+     * Updates the channel description
+     * @param {string} newDescription 
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async setDescription(newDescription) {
+        const success = await this._setChannelMetadata({ description: newDescription }, { editDescription: true });
+        success && (this.description = newDescription);
+        return success;
+    }
+
+    /**
+     * Updates the channel profile picture
+     * @param {MessageMedia} newProfilePicture 
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async setProfilePicture(newProfilePicture) {
+        return await this._setChannelMetadata({ picture: newProfilePicture }, { editPicture: true });
+    }
+
+    /**
+     * Updates available reactions to use in the channel
+     * 
+     * Valid values for passing to the method are:
+     * 0 for NONE reactions to be avaliable
+     * 1 for BASIC reactions to be available: 👍, ❤️, 😂, 😮, 😢, 🙏
+     * 2 for ALL reactions to be available
+     * @param {number} reactionCode 
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async setReactionSetting(reactionCode) {
+        if (![0, 1, 2].includes(reactionCode)) return false;
+        const reactionMapper = {
+            0: 3,
+            1: 1,
+            2: 0
+        };
+        const success = await this._setChannelMetadata(
+            { reactionCodesSetting: reactionMapper[reactionCode] },
+            { editReactionCodesSetting: true }
+        );
+        success && (this.channelMetadata.reactionCodesSetting = reactionCode);
+        return success;
+    }
+
+    /**
+     * Mutes the channel
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async mute() {
+        const success = await this._muteUnmuteChannel('MUTE');
+        if (success) {
+            this.isMuted = true;
+            this.muteExpiration = -1;
+        }
+        return success;
+    }
+    
+    /**
+     * Unmutes the channel
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async unmute() {
+        const success = await this._muteUnmuteChannel('UNMUTE');
+        if (success) {
+            this.isMuted = false;
+            this.muteExpiration = 0;
+        }
+        return success;
+    }
+
+    /**
+     * Message options
+     * @typedef {Object} MessageSendOptions
+     * @property {?string} caption Image or video caption
+     * @property {?string[]} mentions User IDs of user that will be mentioned in the message
+     * @property {?MessageMedia} media Image or video to be sent
+     */
+
+    /**
+     * Sends a message to this channel
+     * @param {string|MessageMedia} content
+     * @param {?MessageSendOptions} options
+     * @returns {Promise<Message>} Message that was just sent
+     */
+    async sendMessage(content, options) {
+        return this.client.sendMessage(this.id._serialized, content, options);
+    }
+
+    /**
+     * Sets the channel as seen
+     * @returns {Promise<boolean>}
+     */
+    async sendSeen() {
+        return this.client.sendSeen(this.id._serialized);
+    }
+
+    /**
+     * @typedef {Object} SendChannelAdminInviteOptions
+     * @property {?string} comment The comment to be added to an invitation
+     */
+
+    /**
+     * Sends a channel admin invitation to a user, allowing them to become an admin of the channel
+     * @param {string} chatId The ID of a user to send the channel admin invitation to
+     * @param {SendChannelAdminInviteOptions} options 
+     * @returns {Promise<boolean>} Returns true if an invitation was sent successfully, false otherwise
+     */
+    async sendChannelAdminInvite(chatId, options = {}) {
+        return this.client.sendChannelAdminInvite(chatId, this.id._serialized, options);
+    }
+
+    /**
+     * Accepts a channel admin invitation and promotes the current user to a channel admin
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async acceptChannelAdminInvite() {
+        return this.client.acceptChannelAdminInvite(this.id._serialized);
+    }
+
+    /**
+     * Revokes a channel admin invitation sent to a user by a channel owner
+     * @param {string} userId The user ID the invitation was sent to
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async revokeChannelAdminInvite(userId) {
+        return this.client.revokeChannelAdminInvite(this.id._serialized, userId);
+    }
+
+    /**
+     * Demotes a channel admin to a regular subscriber (can be used also for self-demotion)
+     * @param {string} userId The user ID to demote
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async demoteChannelAdmin(userId) {
+        return this.client.demoteChannelAdmin(this.id._serialized, userId);
+    }
+
+    /**
+     * Options for transferring a channel ownership to another user
+     * @typedef {Object} TransferChannelOwnershipOptions
+     * @property {boolean} [shouldDismissSelfAsAdmin = false] If true, after the channel ownership is being transferred to another user, the current user will be dismissed as a channel admin and will become to a channel subscriber.
+     */
+
+    /**
+     * Transfers a channel ownership to another user.
+     * Note: the user you are transferring the channel ownership to must be a channel admin.
+     * @param {string} newOwnerId
+     * @param {TransferChannelOwnershipOptions} options
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async transferChannelOwnership(newOwnerId, options = {}) {
+        return this.client.transferChannelOwnership(this.id._serialized, newOwnerId, options);
+    }
+
+    /**
+     * Loads channel messages, sorted from earliest to latest
+     * @param {Object} searchOptions Options for searching messages. Right now only limit and fromMe is supported
+     * @param {Number} [searchOptions.limit] The amount of messages to return. If no limit is specified, the available messages will be returned. Note that the actual number of returned messages may be smaller if there aren't enough messages in the conversation. Set this to Infinity to load all messages
+     * @param {Boolean} [searchOptions.fromMe] Return only messages from the bot number or vise versa. To get all messages, leave the option undefined
+     * @returns {Promise<Array<Message>>}
+     */
+    async fetchMessages(searchOptions) {
+        let messages = await this.client.pupPage.evaluate(async (channelId, searchOptions) => {
+            const msgFilter = (m) => {
+                if (m.isNotification || m.type === 'newsletter_notification') {
+                    return false; // dont include notification messages
+                }
+                if (searchOptions && searchOptions.fromMe !== undefined && m.id.fromMe !== searchOptions.fromMe) {
+                    return false;
+                }
+                return true;
+            };
+
+            const channel = await window.WWebJS.getChat(channelId, { getAsModel: false });
+            let msgs = channel.msgs.getModelsArray().filter(msgFilter);
+
+            if (searchOptions && searchOptions.limit > 0) {
+                while (msgs.length < searchOptions.limit) {
+                    const loadedMessages = await window.Store.ConversationMsgs.loadEarlierMsgs(channel);
+                    if (!loadedMessages || !loadedMessages.length) break;
+                    msgs = [...loadedMessages.filter(msgFilter), ...msgs];
+                }
+                
+                if (msgs.length > searchOptions.limit) {
+                    msgs.sort((a, b) => (a.t > b.t) ? 1 : -1);
+                    msgs = msgs.splice(msgs.length - searchOptions.limit);
+                }
+            }
+
+            return msgs.map(m => window.WWebJS.getMessageModel(m));
+
+        }, this.id._serialized, searchOptions);
+
+        return messages.map((msg) => new Message(this.client, msg));
+    }
+
+    /**
+     * Deletes the channel you created
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async deleteChannel() {
+        return this.client.deleteChannel(this.id._serialized);
+    }
+
+    /**
+     * Internal method to change the channel metadata
+     * @param {string|number|MessageMedia} value The new value to set
+     * @param {string} property The property of a channel metadata to change
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async _setChannelMetadata(value, property) {
+        return await this.client.pupPage.evaluate(async (channelId, value, property) => {
+            const channel = await window.WWebJS.getChat(channelId, { getAsModel: false });
+            if (!channel) return false;
+            if (property.editPicture) {
+                value.picture = value.picture
+                    ? await window.WWebJS.cropAndResizeImage(value.picture, {
+                        asDataUrl: true,
+                        mimetype: 'image/jpeg',
+                        size: 640,
+                        quality: 1
+                    })
+                    : null;
+            }
+            try {
+                await window.Store.ChannelUtils.editNewsletterMetadataAction(channel, property, value);
+                return true;
+            } catch (err) {
+                if (err.name === 'ServerStatusCodeError') return false;
+                throw err;
+            }
+        }, this.id._serialized, value, property);
+    }
+
+    /**
+     * Internal method to mute or unmute the channel
+     * @param {string} action The action: 'MUTE' or 'UNMUTE'
+     * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
+     */
+    async _muteUnmuteChannel(action) {
+        return await this.client.pupPage.evaluate(async (channelId, action) => {
+            try {
+                action === 'MUTE'
+                    ? await window.Store.ChannelUtils.muteNewsletter([channelId])
+                    : await window.Store.ChannelUtils.unmuteNewsletter([channelId]);
+                return true;
+            } catch (err) {
+                if (err.name === 'ServerStatusCodeError') return false;
+                throw err;
+            }
+        }, this.id._serialized, action);
+    }
+}
+
+module.exports = Channel;

package/src/structures/Chat.js

@@ -95,7 +95,7 @@ class Chat extends Base {
     }
 
     /**
-     * Set the message as seen
+     * Sets the chat as seen
      * @returns {Promise<Boolean>} result
      */
     async sendSeen() {
@@ -104,7 +104,7 @@ class Chat extends Base {
 
     /**
      * Clears all messages from the chat
-     * @returns {Promise<Boolean>} result
+     * @returns {Promise<boolean>} result
      */
     async clearMessages() {
         return this.client.pupPage.evaluate(chatId => {
@@ -154,17 +154,25 @@ class Chat extends Base {
 
     /**
      * Mutes this chat forever, unless a date is specified
-     * @param {?Date} unmuteDate Date at which the Chat will be unmuted, leave as is to mute forever
+     * @param {?Date} unmuteDate Date when the chat will be unmuted, don't provide a value to mute forever
+     * @returns {Promise<{isMuted: boolean, muteExpiration: number}>}
      */
     async mute(unmuteDate) {
-        return this.client.muteChat(this.id._serialized, unmuteDate);
+        const result = await this.client.muteChat(this.id._serialized, unmuteDate);
+        this.isMuted = result.isMuted;
+        this.muteExpiration = result.muteExpiration;
+        return result;
     }
 
     /**
      * Unmutes this chat
+     * @returns {Promise<{isMuted: boolean, muteExpiration: number}>}
      */
     async unmute() {
-        return this.client.unmuteChat(this.id._serialized);
+        const result = await this.client.unmuteChat(this.id._serialized);
+        this.isMuted = result.isMuted;
+        this.muteExpiration = result.muteExpiration;
+        return result;
     }
 
     /**
@@ -193,7 +201,7 @@ class Chat extends Base {
                 return true;
             };
 
-            const chat = window.Store.Chat.get(chatId);
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
             let msgs = chat.msgs.getModelsArray().filter(msgFilter);
 
             if (searchOptions && searchOptions.limit > 0) {

package/src/structures/GroupChat.js

@@ -191,8 +191,7 @@ class GroupChat extends Chat {
      */
     async removeParticipants(participantIds) {
         return await this.client.pupPage.evaluate(async (chatId, participantIds) => {
-            const chatWid = window.Store.WidFactory.createWid(chatId);
-            const chat = await window.Store.Chat.find(chatWid);
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
             const participants = participantIds.map(p => {
                 return chat.groupMetadata.participants.get(p);
             }).filter(p => Boolean(p));
@@ -208,8 +207,7 @@ class GroupChat extends Chat {
      */
     async promoteParticipants(participantIds) {
         return await this.client.pupPage.evaluate(async (chatId, participantIds) => {
-            const chatWid = window.Store.WidFactory.createWid(chatId);
-            const chat = await window.Store.Chat.find(chatWid);
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
             const participants = participantIds.map(p => {
                 return chat.groupMetadata.participants.get(p);
             }).filter(p => Boolean(p));
@@ -225,8 +223,7 @@ class GroupChat extends Chat {
      */
     async demoteParticipants(participantIds) {
         return await this.client.pupPage.evaluate(async (chatId, participantIds) => {
-            const chatWid = window.Store.WidFactory.createWid(chatId);
-            const chat = await window.Store.Chat.find(chatWid);
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
             const participants = participantIds.map(p => {
                 return chat.groupMetadata.participants.get(p);
             }).filter(p => Boolean(p));
@@ -466,8 +463,7 @@ class GroupChat extends Chat {
      */
     async leave() {
         await this.client.pupPage.evaluate(async chatId => {
-            const chatWid = window.Store.WidFactory.createWid(chatId);
-            const chat = await window.Store.Chat.find(chatWid);
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
             return window.Store.GroupUtils.sendExitGroup(chat);
         }, this.id._serialized);
     }

package/src/structures/Location.js

@@ -6,6 +6,7 @@
  * @property {string} [name] Location name
  * @property {string} [address] Location address
  * @property {string} [url] URL address to be shown within a location message
+ * @property {string} [description] Location full description
  */
 
 /**

package/src/structures/Message.js

@@ -45,7 +45,7 @@ class Message extends Base {
          * Indicates if the message has media available for download
          * @type {boolean}
          */
-        this.hasMedia = Boolean(data.mediaKey && data.directPath);
+        this.hasMedia = Boolean(data.directPath);
 
         /**
          * Message content
@@ -498,23 +498,26 @@ class Message extends Base {
     /**
      * Deletes a message from the chat
      * @param {?boolean} everyone If true and the message is sent by the current user or the user is an admin, will delete it for everyone in the chat.
+     * @param {?boolean} [clearMedia = true] If true, any associated media will also be deleted from a device.
      */
-    async delete(everyone) {
-        await this.client.pupPage.evaluate(async (msgId, everyone) => {
+    async delete(everyone, clearMedia = true) {
+        await this.client.pupPage.evaluate(async (msgId, everyone, clearMedia) => {
             const msg = window.Store.Msg.get(msgId) || (await window.Store.Msg.getMessagesById([msgId]))?.messages?.[0];
-            let chat = await window.Store.Chat.find(msg.id.remote);
+            const chat = window.Store.Chat.get(msg.id.remote) || (await window.Store.Chat.find(msg.id.remote));
             
-            const canRevoke = window.Store.MsgActionChecks.canSenderRevokeMsg(msg) || window.Store.MsgActionChecks.canAdminRevokeMsg(msg);
+            const canRevoke =
+                window.Store.MsgActionChecks.canSenderRevokeMsg(msg) || window.Store.MsgActionChecks.canAdminRevokeMsg(msg);
+
             if (everyone && canRevoke) {
-                if (window.compareWwebVersions(window.Debug.VERSION, '>=', '2.3000.0')) {
-                    return window.Store.Cmd.sendRevokeMsgs(chat, { list: [msg], type: 'message' }, { clearMedia: true });
-                } else {
-                    return window.Store.Cmd.sendRevokeMsgs(chat, [msg], { clearMedia: true, type: msg.id.fromMe ? 'Sender' : 'Admin' });
-                }
+                return window.compareWwebVersions(window.Debug.VERSION, '>=', '2.3000.0')
+                    ? window.Store.Cmd.sendRevokeMsgs(chat, { list: [msg], type: 'message' }, { clearMedia: clearMedia })
+                    : window.Store.Cmd.sendRevokeMsgs(chat, [msg], { clearMedia: true, type: msg.id.fromMe ? 'Sender' : 'Admin' });
             }
 
-            return window.Store.Cmd.sendDeleteMsgs(chat, [msg], true);
-        }, this.id._serialized, everyone);
+            return window.compareWwebVersions(window.Debug.VERSION, '>=', '2.3000.0')
+                ? window.Store.Cmd.sendDeleteMsgs(chat, { list: [msg], type: 'message' }, clearMedia)
+                : window.Store.Cmd.sendDeleteMsgs(chat, [msg], clearMedia);
+        }, this.id._serialized, everyone, clearMedia);
     }
 
     /**

package/src/structures/index.js

@@ -5,6 +5,7 @@ module.exports = {
     ClientInfo: require('./ClientInfo'),
     Contact: require('./Contact'),
     GroupChat: require('./GroupChat'),
+    Channel: require('./Channel'),
     Location: require('./Location'),
     Message: require('./Message'),
     MessageMedia: require('./MessageMedia'),

package/src/util/Injected/Store.js

@@ -65,7 +65,6 @@ exports.ExposeStore = () => {
     window.Store.SendSeen = window.require('WAWebUpdateUnreadChatAction');
     window.Store.User = window.require('WAWebUserPrefsMeUser');
     window.Store.ContactMethods = window.require('WAWebContactGetters');
-    window.Store.UploadUtils = window.require('WAWebUploadManager');
     window.Store.UserConstructor = window.require('WAWebWid');
     window.Store.Validators = window.require('WALinkify');
     window.Store.VCard = window.require('WAWebFrontendVcardUtils');
@@ -84,7 +83,7 @@ exports.ExposeStore = () => {
     window.Store.LinkPreview = window.require('WAWebLinkPreviewChatAction');
     window.Store.Socket = window.require('WADeprecatedSendIq');
     window.Store.SocketWap = window.require('WAWap');
-    window.Store.SearchContext = window.require('WAWebChatMessageSearch').getSearchContext;
+    window.Store.SearchContext = window.require('WAWebChatMessageSearch');
     window.Store.DrawerManager = window.require('WAWebDrawerManager').DrawerManager;
     window.Store.LidUtils = window.require('WAWebApiContact');
     window.Store.WidToJid = window.require('WAWebWidToJid');
@@ -93,23 +92,26 @@ exports.ExposeStore = () => {
     window.Store.pinUnpinMsg = window.require('WAWebSendPinMessageAction').sendPinInChatMsg;
     window.Store.QueryExist = window.require('WAWebQueryExistsJob').queryWidExists;
     window.Store.ReplyUtils = window.require('WAWebMsgReply');
-    window.Store.Settings = window.require('WAWebUserPrefsGeneral');
     window.Store.BotSecret = window.require('WAWebBotMessageSecret');
     window.Store.BotProfiles = window.require('WAWebBotProfileCollection');
+    window.Store.ContactCollection = window.require('WAWebContactCollection').ContactCollection;
     window.Store.DeviceList = window.require('WAWebApiDeviceList');
     window.Store.HistorySync = window.require('WAWebSendNonMessageDataRequest');
-    if (window.compareWwebVersions(window.Debug.VERSION, '>=', '2.3000.1014111620')) 
-        window.Store.AddonReactionTable = window.require('WAWebAddonReactionTableMode').reactionTableMode;
+    window.Store.AddonReactionTable = window.require('WAWebAddonReactionTableMode').reactionTableMode;
+    window.Store.ChatGetters = window.require('WAWebChatGetters');
     
+    window.Store.Settings = {
+        ...window.require('WAWebUserPrefsGeneral'),
+        ...window.require('WAWebUserPrefsNotifications'),
+        setPushname: window.require('WAWebSetPushnameConnAction').setPushname
+    };
     window.Store.NumberInfo = {
         ...window.require('WAPhoneUtils'),
         ...window.require('WAPhoneFindCC')
     };
-    
     window.Store.ForwardUtils = {
         ...window.require('WAWebForwardMessagesToChat')
     };
-
     window.Store.StickerTools = {
         ...window.require('WAWebImageUtils'),
         ...window.require('WAWebAddWebpMetadata')
@@ -137,6 +139,41 @@ exports.ExposeStore = () => {
         ...window.require('WAWebApiMembershipApprovalRequestStore'),
         ...window.require('WASmaxGroupsMembershipRequestsActionRPC')
     };
+    window.Store.ChannelUtils = {
+        ...window.require('WAWebLoadNewsletterPreviewChatAction'),
+        ...window.require('WAWebNewsletterMetadataQueryJob'),
+        ...window.require('WAWebNewsletterCreateQueryJob'),
+        ...window.require('WAWebEditNewsletterMetadataAction'),
+        ...window.require('WAWebNewsletterDeleteAction'),
+        ...window.require('WAWebNewsletterSubscribeAction'),
+        ...window.require('WAWebNewsletterUnsubscribeAction'),
+        ...window.require('WAWebNewsletterDirectorySearchAction'),
+        ...window.require('WAWebNewsletterToggleMuteStateJob'),
+        ...window.require('WAWebNewsletterGatingUtils'),
+        ...window.require('WAWebNewsletterModelUtils'),
+        ...window.require('WAWebMexAcceptNewsletterAdminInviteJob'),
+        ...window.require('WAWebMexRevokeNewsletterAdminInviteJob'),
+        ...window.require('WAWebChangeNewsletterOwnerAction'),
+        ...window.require('WAWebDemoteNewsletterAdminAction'),
+        ...window.require('WAWebNewsletterDemoteAdminJob'),
+        countryCodesIso: window.require('WAWebCountriesNativeCountryNames'),
+        currentRegion: window.require('WAWebL10N').getRegion(),
+    };
+    window.Store.SendChannelMessage = {
+        ...window.require('WAWebNewsletterUpdateMsgsRecordsJob'),
+        ...window.require('WAWebMsgDataFromModel'),
+        ...window.require('WAWebNewsletterSendMessageJob'),
+        ...window.require('WAWebNewsletterSendMsgAction'),
+        ...window.require('WAMediaCalculateFilehash')
+    };
+    window.Store.ChannelSubscribers = {
+        ...window.require('WAWebMexFetchNewsletterSubscribersJob'),
+        ...window.require('WAWebNewsletterSubscriberListAction')
+    };
+    window.Store.AddressbookContactUtils = {
+        ...window.require('WAWebSaveContactAction'),
+        ...window.require('WAWebDeleteContactAction')
+    };
 
     if (!window.Store.Chat._find || !window.Store.Chat.findImpl) {
         window.Store.Chat._find = e => {