current work complete

whatsapp-web.js/src/structures/Base.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Represents a WhatsApp data structure
+ */
+class Base {
+    constructor(client) {
+        /**
+         * The client that instantiated this
+         * @readonly
+         */
+        Object.defineProperty(this, 'client', { value: client });
+    }
+
+    _clone() {
+        return Object.assign(Object.create(this), this);
+    }
+    
+    _patch(data) { return data; }
+}
+
+module.exports = Base;

whatsapp-web.js/src/structures/BusinessContact.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const Contact = require('./Contact');
+
+/**
+ * Represents a Business Contact on WhatsApp
+ * @extends {Contact}
+ */
+class BusinessContact extends Contact {
+    _patch(data) {
+        /**
+         * The contact's business profile
+         */
+        this.businessProfile = data.businessProfile;
+
+        return super._patch(data);
+    }
+
+}
+
+module.exports = BusinessContact;

whatsapp-web.js/src/structures/Chat.js

@@ -0,0 +1,176 @@
+'use strict';
+
+const Base = require('./Base');
+const Message = require('./Message');
+
+/**
+ * Represents a Chat on WhatsApp
+ * @extends {Base}
+ */
+class Chat extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if (data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * ID that represents the chat
+         * @type {object}
+         */
+        this.id = data.id;
+
+        /**
+         * Title of the chat
+         * @type {string}
+         */
+        this.name = data.formattedTitle;
+
+        /**
+         * Indicates if the Chat is a Group Chat
+         * @type {boolean}
+         */
+        this.isGroup = data.isGroup;
+
+        /**
+         * Indicates if the Chat is readonly
+         * @type {boolean}
+         */
+        this.isReadOnly = data.isReadOnly;
+
+        /**
+         * Amount of messages unread
+         * @type {number}
+         */
+        this.unreadCount = data.unreadCount;
+
+        /**
+         * Unix timestamp for when the chat was created
+         * @type {number}
+         */
+        this.timestamp = data.t;
+
+        /**
+         * Indicates if the Chat is archived
+         * @type {boolean}
+         */
+        this.archived = data.archive;
+
+        return super._patch(data);
+    }
+
+    /**
+     * Send a message to this chat
+     * @param {string|MessageMedia|Location} content
+     * @param {object} options 
+     * @returns {Promise<Message>} Message that was just sent
+     */
+    async sendMessage(content, options) {
+        return this.client.sendMessage(this.id._serialized, content, options);
+    }
+
+    /**
+     * Set the message as seen
+     * @returns {Promise<Boolean>} result
+     */
+    async sendSeen() {
+        return this.client.sendSeen(this.id._serialized);
+    }
+
+    /**
+     * Clears all messages from the chat
+     * @returns {Promise<Boolean>} result
+     */
+    async clearMessages() {
+        return this.client.pupPage.evaluate(chatId => {
+            return window.WWebJS.sendClearChat(chatId);
+        }, this.id._serialized);
+    }
+
+    /**
+     * Deletes the chat
+     * @returns {Promise<Boolean>} result
+     */
+    async delete() {
+        return this.client.pupPage.evaluate(chatId => {
+            return window.WWebJS.sendDeleteChat(chatId);
+        }, this.id._serialized);
+    }
+
+    /**
+     * Archives this chat
+     */
+    async archive() {
+        return this.client.archiveChat(this.id._serialized);
+    }
+
+    /**
+     * un-archives this chat
+     */
+    async unarchive() {
+        return this.client.unarchiveChat(this.id._serialized);
+    }
+
+    /**
+     * Loads chat messages, sorted from earliest to latest.
+     * @param {Object} searchOptions Options for searching messages. Right now only limit is supported.
+     * @param {Number} [searchOptions.limit=50] The amount of messages to return. 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.
+     * @returns {Promise<Array<Message>>}
+     */
+    async fetchMessages(searchOptions) {
+        if(!searchOptions || !searchOptions.limit) {
+            searchOptions = {limit: 50};
+        }
+        let messages = await this.client.pupPage.evaluate(async (chatId, limit) => {
+            const msgFilter = m => !m.isNotification; // dont include notification messages
+            
+            const chat = window.Store.Chat.get(chatId);
+            let msgs = chat.msgs.models.filter(msgFilter);
+            
+            while(msgs.length < limit) {
+                const loadedMessages = await chat.loadEarlierMsgs();
+                if(!loadedMessages) break;
+                msgs = [...loadedMessages.filter(msgFilter), ...msgs];
+            }
+
+            msgs.sort((a, b) => (a.t > b.t) ? 1 : -1);
+            return msgs.splice(msgs.length - limit).map(m => m.serialize());
+
+        }, this.id._serialized, searchOptions.limit);
+
+        return messages.map(m => new Message(this.client, m));
+    }
+   
+    /**
+     * Simulate typing in chat. This will last for 25 seconds.
+     */
+    async sendStateTyping() {
+        return this.client.pupPage.evaluate(chatId => {
+            window.WWebJS.sendChatstate('typing', chatId);
+            return true;
+        }, this.id._serialized);
+    }
+    
+    /**
+     * Simulate recording audio in chat. This will last for 25 seconds.
+     */
+    async sendStateRecording() {
+        return this.client.pupPage.evaluate(chatId => {
+            window.WWebJS.sendChatstate('recording', chatId);
+            return true;
+        }, this.id._serialized);
+    }
+
+    /**
+     * Stops typing or recording in chat immediately.
+     */
+    async clearState() {
+        return this.client.pupPage.evaluate(chatId => {
+            window.WWebJS.sendChatstate('stop', chatId);
+            return true;
+        }, this.id._serialized);
+    }
+}
+
+module.exports = Chat;

whatsapp-web.js/src/structures/ClientInfo.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Current connection information
+ * @extends {Base}
+ */
+class ClientInfo extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if(data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * Name configured to be shown in push notifications
+         * @type {string}
+         */
+        this.pushname = data.pushname;
+
+        /**
+         * Current user ID
+         * @type {object}
+         */
+        this.me = data.me;
+
+        /**
+         * Information about the phone this client is connected to
+         * @type {object}
+         * @property {string} wa_version WhatsApp Version running on the phone
+         * @property {string} os_version OS Version running on the phone (iOS or Android version)
+         * @property {string} device_manufacturer Device manufacturer
+         * @property {string} device_model Device model
+         * @property {string} os_build_number OS build number
+         */
+        this.phone = data.phone;
+
+        /**
+         * Platform the phone is running on
+         * @type {string}
+         */
+        this.platform = data.platform;
+
+        return super._patch(data);
+    }
+
+}
+
+module.exports = ClientInfo;

whatsapp-web.js/src/structures/Contact.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Represents a Contact on WhatsApp
+ * @extends {Base}
+ */
+class Contact extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if(data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * ID that represents the contact
+         * @type {object}
+         */
+        this.id = data.id;
+
+        /**
+         * Contact's phone number
+         * @type {string}
+         */
+        this.number = data.userid;
+
+        /**
+         * Indicates if the contact is a business contact
+         * @type {boolean}
+         */
+        this.isBusiness = data.isBusiness;
+
+        /**
+         * Indicates if the contact is an enterprise contact
+         * @type {boolean}
+         */
+        this.isEnterprise = data.isEnterprise;
+
+        this.labels = data.labels;
+
+        /**
+         * The contact's name, as saved by the current user
+         * @type {?string}
+         */
+        this.name = data.name;
+
+        /**
+         * The name that the contact has configured to be shown publically
+         * @type {string}
+         */
+        this.pushname = data.pushname;
+
+        this.sectionHeader = data.sectionHeader;
+
+        /**
+         * A shortened version of name
+         * @type {?string}
+         */
+        this.shortName = data.shortName;
+
+        this.statusMute = data.statusMute;
+        this.type = data.type;
+        this.verifiedLevel = data.verifiedLevel;
+        this.verifiedName = data.verifiedName;
+
+        /**
+         * Indicates if the contact is the current user's contact
+         * @type {boolean}
+         */
+        this.isMe = data.isMe;
+
+        /**
+         * Indicates if the contact is a user contact
+         * @type {boolean}
+         */
+        this.isUser = data.isUser;
+
+        /**
+         * Indicates if the contact is a group contact
+         * @type {boolean}
+         */
+        this.isGroup = data.isGroup;
+
+        /**
+         * Indicates if the number is registered on WhatsApp
+         * @type {boolean}
+         */
+        this.isWAContact = data.isWAContact;
+
+        /**
+         * Indicates if the number is saved in the current phone's contacts
+         * @type {boolean}
+         */
+        this.isMyContact = data.isMyContact;
+
+        return super._patch(data);
+    }
+
+    /**
+     * Returns the contact's profile picture URL, if privacy settings allow it
+     * @returns {Promise<string>}
+     */
+    async getProfilePicUrl() {
+        const profilePic = await this.client.pupPage.evaluate((contactId) => {
+            return window.Store.Wap.profilePicFind(contactId);
+        }, this.id._serialized);
+
+        return profilePic ? profilePic.eurl : undefined;
+    }
+    
+}
+
+module.exports = Contact;

whatsapp-web.js/src/structures/GroupChat.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const Chat = require('./Chat');
+
+/**
+ * Represents a Group Chat on WhatsApp
+ * @extends {Chat}
+ */
+class GroupChat extends Chat {
+    _patch(data) {
+        this.groupMetadata = data.groupMetadata;
+
+        return super._patch(data);
+    }
+
+    /**
+     * Gets the group owner
+     */
+    get owner() {
+        return this.groupMetadata.owner;
+    }
+    
+    /**
+     * Gets the date at which the group was created
+     * @type {date}
+     */
+    get createdAt() {
+        return new Date(this.groupMetadata.creation * 1000);
+    }
+
+    /** 
+     * Gets the group description
+     * @type {string}
+     */
+    get description() {
+        return this.groupMetadata.desc;
+    }
+    /**
+     * Gets the group participants
+     * @type {array}
+     */
+    get participants() {
+        return this.groupMetadata.participants;
+    }
+
+    /**
+     * Adds a list of participants by ID to the group
+     * @param {Array<string>} participantIds 
+     */
+    async addParticipants(participantIds) {
+        return await this.client.pupPage.evaluate((chatId, participantIds) => {
+            return window.Store.Wap.addParticipants(chatId, participantIds);
+        }, this.id._serialized, participantIds);
+    }
+
+    /**
+     * Removes a list of participants by ID to the group
+     * @param {Array<string>} participantIds 
+     */
+    async removeParticipants(participantIds) {
+        return await this.client.pupPage.evaluate((chatId, participantIds) => {
+            return window.Store.Wap.removeParticipants(chatId, participantIds);
+        }, this.id._serialized, participantIds);
+    }
+
+    /**
+     * Promotes participants by IDs to admins
+     * @param {Array<string>} participantIds 
+     */
+    async promoteParticipants(participantIds) {
+        return await this.client.pupPage.evaluate((chatId, participantIds) => {
+            return window.Store.Wap.promoteParticipants(chatId, participantIds);
+        }, this.id._serialized, participantIds);
+    }
+
+    /**
+     * Demotes participants by IDs to regular users
+     * @param {Array<string>} participantIds 
+     */
+    async demoteParticipants(participantIds) {
+        return await this.client.pupPage.evaluate((chatId, participantIds) => {
+            return window.Store.Wap.demoteParticipants(chatId, participantIds);
+        }, this.id._serialized, participantIds);
+    }
+
+    /**
+     * Updates the group subject
+     * @param {string} subject 
+     */
+    async setSubject(subject) {
+        let res = await this.client.pupPage.evaluate((chatId, subject) => {
+            return window.Store.Wap.changeSubject(chatId, subject);
+        }, this.id._serialized, subject);
+
+        if(res.status == 200) {
+            this.name = subject;
+        }
+    }
+
+    /**
+     * Updates the group description
+     * @param {string} description 
+     */
+    async setDescription(description) {
+        let res = await this.client.pupPage.evaluate((chatId, description) => {
+            let descId = window.Store.GroupMetadata.get(chatId).descId;
+            return window.Store.Wap.setGroupDescription(chatId, description, window.Store.genId(), descId);
+        }, this.id._serialized, description);
+
+        if (res.status == 200) {
+            this.groupMetadata.desc = description;
+        }
+    }
+
+    /**
+     * Gets the invite code for a specific group
+     */
+    async getInviteCode() {
+        let res = await this.client.pupPage.evaluate(chatId => {
+            return window.Store.Wap.groupInviteCode(chatId);
+        }, this.id._serialized);
+
+        if (res.status == 200) {
+            return res.code;
+        } 
+
+        throw new Error('Not authorized');
+    }
+    
+    /**
+     * Invalidates the current group invite code and generates a new one
+     */
+    async revokeInvite() {
+        return await this.client.pupPage.evaluate(chatId => {
+            return window.Store.Wap.revokeGroupInvite(chatId);
+        }, this.id._serialized);
+    }
+
+    /**
+     * Returns an object with information about the invite code's group
+     * @param {string} inviteCode 
+     * @returns {Promise<object>} Invite information
+     */
+    static async getInviteInfo(inviteCode) {
+        return await this.client.pupPage.evaluate(inviteCode => {
+            return window.Store.Wap.groupInviteInfo(inviteCode);
+        }, inviteCode);
+    }
+
+    /**
+     * Joins a group with an invite code
+     * @param {string} inviteCode 
+     */
+    static async join(inviteCode) {
+        return await this.client.pupPage.evaluate(inviteCode => {
+            return window.Store.Wap.acceptGroupInvite(inviteCode);
+        }, inviteCode);
+    }
+
+    /**
+     * Makes the bot leave the group
+     */
+    async leave() {
+        return await this.client.pupPage.evaluate(chatId => {
+            return window.Store.Wap.leaveGroup(chatId);
+        }, this.id._serialized);
+    }
+
+}
+
+module.exports = GroupChat;

whatsapp-web.js/src/structures/GroupNotification.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Represents a GroupNotification on WhatsApp
+ * @extends {Base}
+ */
+class GroupNotification extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if(data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * ID that represents the groupNotification
+         * @type {object}
+         */
+        this.id = data.id;
+
+        /**
+         * Extra content
+         * @type {string}
+         */
+        this.body = data.body || '';
+
+        /** 
+         * GroupNotification type
+         * @type {GroupNotificationTypes}
+         */
+        this.type = data.subtype;
+        
+        /**
+         * Unix timestamp for when the groupNotification was created
+         * @type {number}
+         */
+        this.timestamp = data.t;
+
+        /**
+         * ID for the Chat that this groupNotification was sent for.
+         * 
+         * @type {string}
+         */
+        this.chatId = typeof (data.to) === 'object' ? data.to._serialized : data.to;
+
+        /**
+         * ContactId for the user that produced the GroupNotification.
+         * @type {string}
+         */
+        this.author = typeof (data.author) === 'object' ? data.author._serialized : data.author;
+        
+        /**
+         * Contact IDs for the users that were affected by this GroupNotification.
+         * @type {Array<string>}
+         */
+        this.recipientIds = [];
+
+        if (data.recipients) {
+            this.recipientIds = data.recipients;
+        }
+
+        return super._patch(data);
+    }
+
+    /**
+     * Returns the Chat this groupNotification was sent in
+     * @returns {Promise<Chat>}
+     */
+    getChat() {
+        return this.client.getChatById(this.chatId);
+    }
+
+    /**
+     * Returns the Contact this GroupNotification was produced by
+     * @returns {Promise<Contact>}
+     */
+    getContact() {
+        return this.client.getContactById(this.author);
+    }
+
+    /**
+     * Returns the Contacts affected by this GroupNotification.
+     * @returns {Promise<Array<Contact>>}
+     */
+    async getRecipients() {
+        return await Promise.all(this.recipientIds.map(async m => await this.client.getContactById(m)));
+    }
+
+    /**
+     * Sends a message to the same chat this GroupNotification was produced in.
+     * 
+     * @param {string|MessageMedia|Location} content 
+     * @param {object} options
+     * @returns {Promise<Message>}
+     */
+    async reply(content, options={}) {
+        return this.client.sendMessage(this.chatId, content, options);
+    }
+    
+}
+
+module.exports = GroupNotification;

whatsapp-web.js/src/structures/Location.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Location information
+ */
+class Location {
+    /**
+     * @param {number} latitude
+     * @param {number} longitude
+     * @param {?string} description
+     */
+    constructor(latitude, longitude, description) {
+        /**
+         * Location latitude
+         * @type {number}
+         */
+        this.latitude = latitude;
+
+        /**
+         * Location longitude
+         * @type {number}
+         */
+        this.longitude = longitude;
+
+        /**
+         * Name for the location
+         * @type {?string}
+         */
+        this.description = description;
+    }
+}
+
+module.exports = Location;

whatsapp-web.js/src/structures/Message.js

@@ -0,0 +1,223 @@
+'use strict';
+
+const Base = require('./Base');
+const MessageMedia = require('./MessageMedia');
+const Location = require('./Location');
+const { MessageTypes } = require('../util/Constants');
+
+/**
+ * Represents a Message on WhatsApp
+ * @extends {Base}
+ */
+class Message extends Base {
+    constructor(client, data) {
+        super(client);
+
+        if(data) this._patch(data);
+    }
+
+    _patch(data) {
+        /**
+         * ID that represents the message
+         * @type {object}
+         */
+        this.id = data.id;
+
+        /**
+         * Indicates if the message has media available for download
+         * @type {boolean}
+         */
+        this.hasMedia = data.clientUrl ? true : false;
+
+        /**
+         * Message content
+         * @type {string}
+         */
+        this.body = this.hasMedia ? data.caption || '' : data.body || '';
+
+        /** 
+         * Message type
+         * @type {MessageTypes}
+         */
+        this.type = data.type;
+
+        /**
+         * Unix timestamp for when the message was created
+         * @type {number}
+         */
+        this.timestamp = data.t;
+
+        /**
+         * ID for the Chat that this message was sent to, except if the message was sent by the current user.
+         * @type {string}
+         */
+        this.from = typeof (data.from) === 'object' ? data.from._serialized : data.from;
+
+        /**
+         * ID for who this message is for.
+         * 
+         * If the message is sent by the current user, it will be the Chat to which the message is being sent.
+         * If the message is sent by another user, it will be the ID for the current user. 
+         * @type {string}
+         */
+        this.to = typeof (data.to) === 'object' ? data.to._serialized : data.to;
+
+        /**
+         * If the message was sent to a group, this field will contain the user that sent the message.
+         * @type {string}
+         */
+        this.author = typeof (data.author) === 'object' ? data.author._serialized : data.author;
+
+        /**
+         * Indicates if the message was forwarded
+         * @type {boolean}
+         */
+        this.isForwarded = data.isForwarded;
+
+        /**
+         * Indicates if the message was a broadcast
+         * @type {boolean}
+         */
+        this.broadcast = data.broadcast;
+
+        /** 
+         * Indicates if the message was sent by the current user
+         * @type {boolean}
+         */
+        this.fromMe = data.id.fromMe;
+        
+        /**
+         * Indicates if the message was sent as a reply to another message.
+         * @type {boolean}
+         */
+        this.hasQuotedMsg = data.quotedMsg ? true : false;
+
+        /**
+         * Location information contained in the message, if the message is type "location"
+         * @type {Location}
+         */
+        this.location = data.type === MessageTypes.LOCATION ? new Location(data.lat, data.lng, data.loc) : undefined;
+
+        /**
+         * Indicates the mentions in the message body.
+         * @type {Array<string>}
+         */
+        this.mentionedIds = [];
+
+        if (data.mentionedJidList) {
+            this.mentionedIds = data.mentionedJidList;
+        }
+
+        return super._patch(data);
+    }
+
+    _getChatId() {
+        return this.fromMe ? this.to : this.from;
+    }
+
+    /**
+     * Returns the Chat this message was sent in
+     * @returns {Promise<Chat>}
+     */
+    getChat() {
+        return this.client.getChatById(this._getChatId());
+    }
+
+    /**
+     * Returns the Contact this message was sent from
+     * @returns {Promise<Contact>}
+     */
+    getContact() {
+        return this.client.getContactById(this.author || this.from);
+    }
+
+    /**
+     * Returns the Contacts mentioned in this message
+     * @returns {Promise<Array<Contact>>}
+     */
+    async getMentions() {
+        return await Promise.all(this.mentionedIds.map(async m => await this.client.getContactById(m)));
+    }
+
+    /**
+     * Returns the quoted message, if any
+     * @returns {Promise<Message>}
+     */
+    async getQuotedMessage() {
+        if (!this.hasQuotedMsg) return undefined;
+
+        const quotedMsg = await this.client.pupPage.evaluate((msgId) => {
+            let msg = window.Store.Msg.get(msgId);
+            return msg.quotedMsgObj().serialize();
+        }, this.id._serialized);
+
+        return new Message(this.client, quotedMsg);
+    }
+
+    /**
+     * Sends a message as a reply to this message. If chatId is specified, it will be sent 
+     * through the specified Chat. If not, it will send the message 
+     * in the same Chat as the original message was sent.
+     * 
+     * @param {string|MessageMedia|Location} content 
+     * @param {?string} chatId 
+     * @param {object} options
+     * @returns {Promise<Message>}
+     */
+    async reply(content, chatId, options={}) {
+        if (!chatId) {
+            chatId = this._getChatId();
+        }
+
+        options = {
+            ...options,
+            quotedMessageId: this.id._serialized
+        };
+
+        return this.client.sendMessage(chatId, content, options);
+    }
+
+    /**
+     * Downloads and returns the attatched message media
+     * @returns {Promise<MessageMedia>}
+     */
+    async downloadMedia() {
+        if (!this.hasMedia) {
+            return undefined;
+        }
+
+        const {data, mimetype, filename} = await this.client.pupPage.evaluate(async (msgId) => {
+            const msg = window.Store.Msg.get(msgId);
+            const buffer = await window.WWebJS.downloadBuffer(msg.clientUrl);
+            const decrypted = await window.Store.CryptoLib.decryptE2EMedia(msg.type, buffer, msg.mediaKey, msg.mimetype);
+            const data = await window.WWebJS.readBlobAsync(decrypted._blob);
+            
+            return {
+                data: data.split(',')[1],
+                mimetype: msg.mimetype,
+                filename: msg.filename
+            };
+
+        }, this.id._serialized);
+
+        return new MessageMedia(mimetype, data, filename);
+    }
+
+    /**
+     * Deletes a message from the chat
+     * @param {?boolean} everyone If true and the message is sent by the current user, will delete it for everyone in the chat.
+     */
+    async delete(everyone) {
+        await this.client.pupPage.evaluate((msgId, everyone) => {
+            let msg = window.Store.Msg.get(msgId);
+
+            if(everyone && msg.id.fromMe && msg.canRevoke()) {
+                return window.Store.Cmd.sendRevokeMsgs(msg.chat, [msg], true);
+            } 
+            
+            return window.Store.Cmd.sendDeleteMsgs(msg.chat, [msg], true);
+        }, this.id._serialized, everyone);
+    }
+}
+
+module.exports = Message;

whatsapp-web.js/src/structures/MessageMedia.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Media attached to a message
+ * @param {string} mimetype MIME type of the attachment
+ * @param {string} data Base64-encoded data of the file
+ * @param {?string} filename Document file name
+ */
+class MessageMedia {
+    constructor(mimetype, data, filename) {
+        /**
+         * MIME type of the attachment
+         * @type {string}
+         */
+        this.mimetype = mimetype;
+
+        /**
+         * Base64 encoded data that represents the file
+         * @type {string}
+         */
+        this.data = data;
+
+        /**
+         * Name of the file (for documents)
+         * @type {?string}
+         */
+        this.filename = filename;
+    }
+}
+
+module.exports = MessageMedia;

whatsapp-web.js/src/structures/PrivateChat.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const Chat = require('./Chat');
+
+/**
+ * Represents a Private Chat on WhatsApp
+ * @extends {Chat}
+ */
+class PrivateChat extends Chat {
+
+}
+
+module.exports = PrivateChat;

whatsapp-web.js/src/structures/PrivateContact.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const Contact = require('./Contact');
+
+/**
+ * Represents a Private Contact on WhatsApp
+ * @extends {Contact}
+ */
+class PrivateContact extends Contact {
+
+}
+
+module.exports = PrivateContact;

whatsapp-web.js/src/structures/index.js

@@ -0,0 +1,13 @@
+module.exports = {
+    Base: require('./Base'),
+    BusinessContact: require('./BusinessContact'),
+    Chat: require('./Chat'),
+    ClientInfo: require('./ClientInfo'),
+    Contact: require('./Contact'),
+    GroupChat: require('./GroupChat'),
+    Location: require('./Location'),
+    Message: require('./Message'),
+    MessageMedia: require('./MessageMedia'),
+    PrivateChat: require('./PrivateChat'),
+    PrivateContact: require('./PrivateContact'),
+};