@raphaelvserafim/client-api-whatsapp 1.0.9 → 1.3.0

package/dist/WhatsApp.d.ts

@@ -1,33 +1,61 @@
-import { Init, WebhookBody, TypeMessage, StatusPresence, Contact, Section, InfoInstance, SendMessageRoot, Connect, Location, Buttons, Items } from './types';
+import { Init, WebhookBody, TypeMessage, StatusPresence, Contact, Section, Location, Buttons, Items, HeaderMedia, DownloadableMessage, Product, CommunityCreate, CommunityUpdate, GroupParticipantsAction, ApiResponse, PairingCodeResponse, MobileRegisterData, EventData, InfoInstance, SendMessageRoot, Connect, RegisteredResponse, ContactInfo, GroupInfo, InviteCodeResponse, ChatInfo, LabelInfo, CommunityInfo, CatalogResponse, WebhookStatistics, ListMessagesResponse, DownloadMediaResponse, CallResponse, MessageData, GroupParticipant, LiveLocationData, SendContactsData, ProductMessageData, GroupInviteMessageData, CommunityGroupCreate } from './types';
+import { IHttpClient } from './client/IHttpClient';
+import { InstanceService } from './services/InstanceService';
+import { MessageService } from './services/MessageService';
+import { ChatService } from './services/ChatService';
+import { CallService } from './services/CallService';
+import { LabelService } from './services/LabelService';
+import { ActionService } from './services/ActionService';
+import { ContactService } from './services/ContactService';
+import { GroupService } from './services/GroupService';
+import { CommunityService } from './services/CommunityService';
+import { BusinessService } from './services/BusinessService';
+import { NewsletterService } from './services/NewsletterService';
+import { StatusService } from './services/StatusService';
 export declare class WhatsApp {
-    private readonly server;
-    private readonly key;
-    private route;
-    private method;
-    private body;
-    constructor(data: Init);
-    private request;
+    readonly instance: InstanceService;
+    readonly message: MessageService;
+    readonly chat: ChatService;
+    readonly call: CallService;
+    readonly label: LabelService;
+    readonly action: ActionService;
+    readonly contact: ContactService;
+    readonly group: GroupService;
+    readonly community: CommunityService;
+    readonly business: BusinessService;
+    readonly newsletter: NewsletterService;
+    readonly status: StatusService;
+    constructor(data: Init, httpClient?: IHttpClient);
     connect(): Promise<Connect>;
     info(): Promise<InfoInstance>;
-    logout(): Promise<any>;
-    setting({ markMessageRead, saveMedia, receiveStatusMessage, receivePresence }: {
+    logout(): Promise<ApiResponse>;
+    setting(data: {
         markMessageRead: boolean;
+        saveMedia: boolean;
         receiveStatusMessage: boolean;
         receivePresence: boolean;
-        saveMedia: boolean;
-    }): Promise<{
-        status: number;
-        message: string;
-    }>;
-    updateWebhook(body: WebhookBody): Promise<any>;
+    }): Promise<ApiResponse>;
+    updateWebhook(body: WebhookBody): Promise<ApiResponse>;
+    pairingCode(phoneNumber: string): Promise<PairingCodeResponse>;
+    addMongoDb(uri: string, dbName: string): Promise<ApiResponse>;
+    setProxy(proxy: string): Promise<ApiResponse>;
+    resync(): Promise<ApiResponse>;
+    restart(): Promise<ApiResponse>;
+    updateProfileStatus(text: string): Promise<ApiResponse>;
+    updateProfilePicture(url: string): Promise<ApiResponse>;
+    removeProfilePicture(): Promise<ApiResponse>;
+    updateProfileName(name: string): Promise<ApiResponse>;
+    mobileRegisterPrepare(data: MobileRegisterData): Promise<ApiResponse>;
+    mobileRequestCode(method: string): Promise<ApiResponse>;
+    mobileVerifyCode(code: string): Promise<ApiResponse>;
+    webhookStatistics(): Promise<WebhookStatistics>;
+    listMessages(phoneNumber: string, page?: number, limit?: number): Promise<ListMessagesResponse>;
     sendMessage(data: {
         type: TypeMessage;
         body: {
             to: string;
             msgId?: string;
-            header?: {
-                title?: string;
-            };
+            header?: HeaderMedia;
             status?: StatusPresence;
             text?: string;
             url?: string;
@@ -56,19 +84,135 @@ export declare class WhatsApp {
             items?: Items[];
         };
     }, reply?: boolean): Promise<SendMessageRoot>;
-    forwardingMessage(to: string, msgId: string): Promise<any>;
-    rejectCall(id: string, from: string): Promise<any>;
-    pairingCode(phoneNumber: string): Promise<any>;
-    checkRegisteredWhatsapp(number: string): Promise<any>;
-    contacts(): Promise<any>;
-    contactProfile(id: string): Promise<any>;
-    groups(): Promise<any>;
-    infoGroup(id: string): Promise<any>;
-    getInviteGroup(id: string): Promise<any>;
-    updateGroup(id: string, name: string, description: string): Promise<any>;
-    updateGroupPicture(id: string, url: string): Promise<any>;
-    leaveGroup(id: string): Promise<any>;
-    createGroup(name: string, participants: string[]): Promise<any>;
-    addParticipantsGroup(id: string, participants: string[]): Promise<any>;
+    forwardingMessage(to: string, msgId: string): Promise<SendMessageRoot>;
+    sendSticker(to: string, url: string): Promise<SendMessageRoot>;
+    sendVideoNote(to: string, url: string): Promise<SendMessageRoot>;
+    sendPoll(to: string, name: string, values: Array<string | number | boolean>, selectableCount?: number): Promise<SendMessageRoot>;
+    sendEvent(data: EventData): Promise<SendMessageRoot>;
+    pinMessage(id: string, duration?: number): Promise<ApiResponse>;
+    unpinMessage(id: string): Promise<ApiResponse>;
+    sendCallLink(to: string, type: string, caption?: string): Promise<SendMessageRoot>;
+    sendImageBase64(to: string, base64: string, caption?: string): Promise<SendMessageRoot>;
+    sendAudioBase64(to: string, base64: string): Promise<SendMessageRoot>;
+    sendDocumentBase64(to: string, base64: string, mimetype: string, fileName?: string, caption?: string): Promise<SendMessageRoot>;
+    sendContacts(data: SendContactsData): Promise<SendMessageRoot>;
+    sendLiveLocation(data: LiveLocationData): Promise<SendMessageRoot>;
+    getMessageDetails(messageId: string): Promise<ApiResponse>;
+    getMessageMedia(messageId: string, format?: string): Promise<ApiResponse>;
+    sendProduct(data: ProductMessageData): Promise<SendMessageRoot>;
+    sendGroupInvite(data: GroupInviteMessageData): Promise<SendMessageRoot>;
+    requestPhone(to: string): Promise<ApiResponse>;
+    createCallLink(type: string): Promise<ApiResponse>;
+    getChats(): Promise<{
+        status: number;
+        data: ChatInfo[];
+    }>;
+    modifyChat(id: string, action: 'markRead' | 'pin', value: boolean): Promise<ApiResponse>;
+    deleteChat(chatId: string): Promise<ApiResponse>;
+    getChatMessages(chatId: string, page?: number, limit?: number): Promise<{
+        status: number;
+        data: MessageData[];
+    }>;
+    presenceSubscribe(jid: string): Promise<ApiResponse>;
+    setDisappearing(jid: string, expiration: number): Promise<ApiResponse>;
+    getPrivacy(): Promise<ApiResponse>;
+    makeCall(to: string, isVideo?: boolean): Promise<CallResponse>;
+    rejectCall(id: string, from: string): Promise<ApiResponse>;
+    acceptCall(callId: string, callFrom: string): Promise<ApiResponse>;
+    endCall(callId: string, peerJid: string): Promise<ApiResponse>;
+    getLabels(): Promise<{
+        status: number;
+        data: LabelInfo[];
+    }>;
+    createLabel(name: string, labelId?: string): Promise<ApiResponse>;
+    getChatLabel(labelId: string): Promise<{
+        status: number;
+        data: ChatInfo[];
+    }>;
+    addChatLabel(labelId: string, to: string): Promise<ApiResponse>;
+    deleteLabel(labelId: string): Promise<ApiResponse>;
+    removeChatLabel(labelId: string, to: string): Promise<ApiResponse>;
+    checkRegisteredWhatsapp(number: string): Promise<RegisteredResponse>;
+    downloadMedia(type: 'image' | 'video' | 'sticker' | 'audio' | 'document', message: DownloadableMessage): Promise<DownloadMediaResponse>;
+    deleteStorage(): Promise<ApiResponse>;
+    contacts(): Promise<{
+        status: number;
+        data: ContactInfo[];
+    }>;
+    addContact(number: string, name: string): Promise<ApiResponse>;
+    contactProfile(id: string): Promise<{
+        status: number;
+        data: ContactInfo;
+    }>;
+    removeContact(number: string): Promise<ApiResponse>;
+    blockContact(number: string, action: 'block' | 'unblock'): Promise<ApiResponse>;
+    clearContactSession(number: string): Promise<ApiResponse>;
+    getContactStatus(number: string): Promise<ApiResponse>;
+    listBlockedContacts(): Promise<ApiResponse>;
+    resolveLids(lids: string[]): Promise<ApiResponse>;
+    groups(): Promise<{
+        status: number;
+        data: GroupInfo[];
+    }>;
+    infoGroup(id: string): Promise<{
+        status: number;
+        data: GroupInfo;
+    }>;
+    createGroup(name: string, participants: string[]): Promise<{
+        status: number;
+        data: GroupInfo;
+    }>;
+    updateGroup(id: string, name: string, description: string): Promise<ApiResponse>;
+    changeGroupSettings(id: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked'): Promise<ApiResponse>;
+    leaveGroup(id: string): Promise<ApiResponse>;
+    getGroupMembers(id: string): Promise<{
+        status: number;
+        data: GroupParticipant[];
+    }>;
+    getGroupInviteInfo(code: string): Promise<ApiResponse>;
+    getInviteGroup(id: string): Promise<InviteCodeResponse>;
+    updateGroupPicture(id: string, url: string): Promise<ApiResponse>;
+    removeGroupPicture(id: string): Promise<ApiResponse>;
+    addParticipantsGroup(id: string, participants: string[]): Promise<ApiResponse>;
+    removeParticipantsGroup(id: string, participants: string[]): Promise<ApiResponse>;
+    updateGroupParticipantRole(id: string, action: 'promote' | 'demote', participants: string[]): Promise<ApiResponse>;
+    getGroupRequestParticipants(id: string): Promise<{
+        status: number;
+        data: GroupParticipant[];
+    }>;
+    updateGroupRequestParticipants(id: string, data: GroupParticipantsAction): Promise<ApiResponse>;
+    listCommunities(): Promise<{
+        status: number;
+        data: CommunityInfo[];
+    }>;
+    createCommunity(data: CommunityCreate): Promise<{
+        status: number;
+        data: CommunityInfo;
+    }>;
+    infoCommunity(id: string): Promise<{
+        status: number;
+        data: CommunityInfo;
+    }>;
+    updateCommunity(id: string, data: CommunityUpdate): Promise<ApiResponse>;
+    leaveCommunity(id: string): Promise<ApiResponse>;
+    updateCommunityPicture(id: string, url: string): Promise<ApiResponse>;
+    getCommunityInviteCode(id: string): Promise<InviteCodeResponse>;
+    removeCommunityParticipants(id: string, participants: string[]): Promise<ApiResponse>;
+    getCommunityRequestParticipants(id: string): Promise<{
+        status: number;
+        data: GroupParticipant[];
+    }>;
+    updateCommunityRequestParticipants(id: string, data: GroupParticipantsAction): Promise<ApiResponse>;
+    acceptCommunityInvite(code: string): Promise<ApiResponse>;
+    getCommunityInviteInfo(code: string): Promise<ApiResponse>;
+    createCommunityGroup(id: string, data: CommunityGroupCreate): Promise<ApiResponse>;
+    setCommunityEphemeral(id: string, expiration: number): Promise<ApiResponse>;
+    updateCommunitySettings(id: string, setting: string): Promise<ApiResponse>;
+    setCommunityMemberAddMode(id: string, mode: string): Promise<ApiResponse>;
+    setCommunityJoinApproval(id: string, mode: string): Promise<ApiResponse>;
+    getCatalog(limit?: number, cursor?: string): Promise<CatalogResponse>;
+    createProduct(product: Product): Promise<ApiResponse>;
+    updateProduct(productId: string, product: Product): Promise<ApiResponse>;
+    deleteProduct(productId: string): Promise<ApiResponse>;
 }
 export default WhatsApp;

package/dist/WhatsApp.js

@@ -1,174 +1,153 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsApp = void 0;
-const tslib_1 = require("tslib");
-const axios_1 = tslib_1.__importDefault(require("axios"));
-const types_1 = require("./types");
+const HttpClient_1 = require("./client/HttpClient");
+const InstanceService_1 = require("./services/InstanceService");
+const MessageService_1 = require("./services/MessageService");
+const ChatService_1 = require("./services/ChatService");
+const CallService_1 = require("./services/CallService");
+const LabelService_1 = require("./services/LabelService");
+const ActionService_1 = require("./services/ActionService");
+const ContactService_1 = require("./services/ContactService");
+const GroupService_1 = require("./services/GroupService");
+const CommunityService_1 = require("./services/CommunityService");
+const BusinessService_1 = require("./services/BusinessService");
+const NewsletterService_1 = require("./services/NewsletterService");
+const StatusService_1 = require("./services/StatusService");
 class WhatsApp {
-    server;
-    key;
-    route;
-    method = null;
-    body = null;
-    constructor(data) {
-        this.server = data.server;
-        this.key = data.key;
-    }
-    async request() {
-        if (!this.route || !this.method) {
-            throw new Error('Path and method must be defined before making a request.');
-        }
-        const options = {
-            url: `${this.server}/${this.key}/${this.route}`,
-            method: this.method,
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        };
-        if ((this.method === 'POST' || this.method === 'PUT') && this.body) {
-            options.data = JSON.stringify(this.body);
-        }
-        try {
-            const response = await (0, axios_1.default)(options);
-            return response.data;
-        }
-        catch (error) {
-            throw new Error(`HTTP Request Error: ${error.message} (status: ${error.response?.status})`);
-        }
-    }
-    async connect() {
-        this.route = types_1.Routes.INSTANCES;
-        this.method = types_1.HttpMethod.POST;
-        return await this.request();
-    }
-    async info() {
-        this.route = types_1.Routes.INSTANCES;
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async logout() {
-        this.route = types_1.Routes.INSTANCES;
-        this.method = types_1.HttpMethod.DELETE;
-        return await this.request();
-    }
-    async setting({ markMessageRead, saveMedia, receiveStatusMessage, receivePresence }) {
-        this.route = types_1.Routes.INSTANCES + `/?markMessageRead=${markMessageRead}&saveMedia=${saveMedia}&receiveStatusMessage=${receiveStatusMessage}&receivePresence=${receivePresence}`;
-        this.method = types_1.HttpMethod.PATCH;
-        return await this.request();
-    }
-    async updateWebhook(body) {
-        this.route = types_1.Routes.INSTANCES;
-        this.method = types_1.HttpMethod.PUT;
-        this.body = body;
-        return await this.request();
-    }
-    async sendMessage(data, reply = false) {
-        if (data.type === types_1.TypeMessage.BUTTON_PIX) {
-            const { key, keyType, merchantName, subtotal, totalAmount, items } = data.body;
-            if (!key || !keyType || !merchantName || !subtotal || !totalAmount || !items || items.length === 0) {
-                throw new Error("Campos obrigatórios para pagamento via PIX estão ausentes.");
-            }
-        }
-        if (reply) {
-            this.route = types_1.Routes.MESSAGES + "/" + data.body.msgId + "/" + data.type;
-        }
-        else {
-            this.route = types_1.Routes.MESSAGES + "/" + data.type;
-        }
-        this.method = types_1.HttpMethod.POST;
-        this.body = data.body;
-        return await this.request();
-    }
-    async forwardingMessage(to, msgId) {
-        this.route = types_1.Routes.MESSAGES + "/" + msgId + "/forwarding";
-        this.method = types_1.HttpMethod.POST;
-        this.body = {
-            to,
-        };
-        return await this.request();
-    }
-    async rejectCall(id, from) {
-        this.route = types_1.Routes.CALL + `/${id}/${from}`;
-        this.method = types_1.HttpMethod.DELETE;
-        return await this.request();
-    }
-    async pairingCode(phoneNumber) {
-        this.route = types_1.Routes.INSTANCES + "/pairing-code";
-        this.body = {
-            phoneNumber,
-        };
-        this.method = types_1.HttpMethod.POST;
-        return await this.request();
-    }
-    async checkRegisteredWhatsapp(number) {
-        this.route = types_1.Routes.ACTIONS + "/registered?number=" + number;
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async contacts() {
-        this.route = types_1.Routes.CONTACTS;
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async contactProfile(id) {
-        this.route = types_1.Routes.CONTACTS + "/" + id;
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async groups() {
-        this.route = types_1.Routes.GROUPS;
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async infoGroup(id) {
-        this.route = types_1.Routes.GROUPS + "/" + id;
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async getInviteGroup(id) {
-        this.route = types_1.Routes.GROUPS + "/" + id + "/invite";
-        this.method = types_1.HttpMethod.GET;
-        return await this.request();
-    }
-    async updateGroup(id, name, description) {
-        this.route = types_1.Routes.GROUPS + "/" + id;
-        this.method = types_1.HttpMethod.PUT;
-        this.body = {
-            name,
-            description
-        };
-        return await this.request();
-    }
-    async updateGroupPicture(id, url) {
-        this.route = types_1.Routes.GROUPS + "/" + id + "/picture";
-        this.method = types_1.HttpMethod.PUT;
-        this.body = {
-            url
-        };
-        return await this.request();
-    }
-    async leaveGroup(id) {
-        this.route = types_1.Routes.GROUPS + "/" + id;
-        this.method = types_1.HttpMethod.DELETE;
-        return await this.request();
-    }
-    async createGroup(name, participants) {
-        this.route = types_1.Routes.GROUPS;
-        this.method = types_1.HttpMethod.POST;
-        this.body = {
-            name,
-            participants
-        };
-        return await this.request();
-    }
-    async addParticipantsGroup(id, participants) {
-        this.route = types_1.Routes.GROUPS + "/" + id + "/participants";
-        this.method = types_1.HttpMethod.POST;
-        this.body = {
-            participants
-        };
-        return await this.request();
-    }
+    constructor(data, httpClient) {
+        const client = httpClient ?? new HttpClient_1.HttpClient(`${data.server}/${data.key}`);
+        this.instance = new InstanceService_1.InstanceService(client);
+        this.message = new MessageService_1.MessageService(client);
+        this.chat = new ChatService_1.ChatService(client);
+        this.call = new CallService_1.CallService(client);
+        this.label = new LabelService_1.LabelService(client);
+        this.action = new ActionService_1.ActionService(client);
+        this.contact = new ContactService_1.ContactService(client);
+        this.group = new GroupService_1.GroupService(client);
+        this.community = new CommunityService_1.CommunityService(client);
+        this.business = new BusinessService_1.BusinessService(client);
+        this.newsletter = new NewsletterService_1.NewsletterService(client);
+        this.status = new StatusService_1.StatusService(client);
+    }
+    // ==================== Backward Compatibility ====================
+    // These methods delegate to the corresponding services.
+    // Use wa.instance.*, wa.message.*, wa.group.*, etc. for the new API.
+    // Instance
+    connect() { return this.instance.connect(); }
+    info() { return this.instance.info(); }
+    logout() { return this.instance.logout(); }
+    setting(data) { return this.instance.setting(data); }
+    updateWebhook(body) { return this.instance.updateWebhook(body); }
+    pairingCode(phoneNumber) { return this.instance.pairingCode(phoneNumber); }
+    addMongoDb(uri, dbName) { return this.instance.addMongoDb(uri, dbName); }
+    setProxy(proxy) { return this.instance.setProxy(proxy); }
+    resync() { return this.instance.resync(); }
+    restart() { return this.instance.restart(); }
+    updateProfileStatus(text) { return this.instance.updateProfileStatus(text); }
+    updateProfilePicture(url) { return this.instance.updateProfilePicture(url); }
+    removeProfilePicture() { return this.instance.removeProfilePicture(); }
+    updateProfileName(name) { return this.instance.updateProfileName(name); }
+    mobileRegisterPrepare(data) { return this.instance.mobileRegisterPrepare(data); }
+    mobileRequestCode(method) { return this.instance.mobileRequestCode(method); }
+    mobileVerifyCode(code) { return this.instance.mobileVerifyCode(code); }
+    webhookStatistics() { return this.instance.webhookStatistics(); }
+    // Messages
+    listMessages(phoneNumber, page, limit) { return this.message.list(phoneNumber, page, limit); }
+    sendMessage(data, reply) { return this.message.send(data, reply); }
+    forwardingMessage(to, msgId) { return this.message.forward(to, msgId); }
+    sendSticker(to, url) { return this.message.sendSticker(to, url); }
+    sendVideoNote(to, url) { return this.message.sendVideoNote(to, url); }
+    sendPoll(to, name, values, selectableCount) { return this.message.sendPoll(to, name, values, selectableCount); }
+    sendEvent(data) { return this.message.sendEvent(data); }
+    pinMessage(id, duration) { return this.message.pin(id, duration); }
+    unpinMessage(id) { return this.message.unpin(id); }
+    sendCallLink(to, type, caption) { return this.message.sendCallLink(to, type, caption); }
+    sendImageBase64(to, base64, caption) { return this.message.sendImageBase64(to, base64, caption); }
+    sendAudioBase64(to, base64) { return this.message.sendAudioBase64(to, base64); }
+    sendDocumentBase64(to, base64, mimetype, fileName, caption) { return this.message.sendDocumentBase64(to, base64, mimetype, fileName, caption); }
+    sendContacts(data) { return this.message.sendContacts(data); }
+    sendLiveLocation(data) { return this.message.sendLiveLocation(data); }
+    getMessageDetails(messageId) { return this.message.getDetails(messageId); }
+    getMessageMedia(messageId, format) { return this.message.getMedia(messageId, format); }
+    sendProduct(data) { return this.message.sendProduct(data); }
+    sendGroupInvite(data) { return this.message.sendGroupInvite(data); }
+    requestPhone(to) { return this.message.requestPhone(to); }
+    createCallLink(type) { return this.message.createCallLink(type); }
+    // Chat
+    getChats() { return this.chat.list(); }
+    modifyChat(id, action, value) { return this.chat.modify(id, action, value); }
+    deleteChat(chatId) { return this.chat.delete(chatId); }
+    getChatMessages(chatId, page, limit) { return this.chat.messages(chatId, page, limit); }
+    presenceSubscribe(jid) { return this.chat.presenceSubscribe(jid); }
+    setDisappearing(jid, expiration) { return this.chat.disappearing(jid, expiration); }
+    getPrivacy() { return this.chat.privacy(); }
+    // Call
+    makeCall(to, isVideo) { return this.call.call(to, isVideo); }
+    rejectCall(id, from) { return this.call.reject(id, from); }
+    acceptCall(callId, callFrom) { return this.call.accept(callId, callFrom); }
+    endCall(callId, peerJid) { return this.call.end(callId, peerJid); }
+    // Labels
+    getLabels() { return this.label.list(); }
+    createLabel(name, labelId) { return this.label.create(name, labelId); }
+    getChatLabel(labelId) { return this.label.getChats(labelId); }
+    addChatLabel(labelId, to) { return this.label.addToChat(labelId, to); }
+    deleteLabel(labelId) { return this.label.delete(labelId); }
+    removeChatLabel(labelId, to) { return this.label.removeFromChat(labelId, to); }
+    // Actions
+    checkRegisteredWhatsapp(number) { return this.action.checkRegistered(number); }
+    downloadMedia(type, message) { return this.action.downloadMedia(type, message); }
+    deleteStorage() { return this.action.deleteStorage(); }
+    // Contacts
+    contacts() { return this.contact.list(); }
+    addContact(number, name) { return this.contact.add(number, name); }
+    contactProfile(id) { return this.contact.profile(id); }
+    removeContact(number) { return this.contact.remove(number); }
+    blockContact(number, action) { return this.contact.block(number, action); }
+    clearContactSession(number) { return this.contact.clearSession(number); }
+    getContactStatus(number) { return this.contact.getStatus(number); }
+    listBlockedContacts() { return this.contact.listBlocked(); }
+    resolveLids(lids) { return this.contact.resolveLids(lids); }
+    // Groups
+    groups() { return this.group.list(); }
+    infoGroup(id) { return this.group.info(id); }
+    createGroup(name, participants) { return this.group.create(name, participants); }
+    updateGroup(id, name, description) { return this.group.update(id, name, description); }
+    changeGroupSettings(id, setting) { return this.group.changeSettings(id, setting); }
+    leaveGroup(id) { return this.group.leave(id); }
+    getGroupMembers(id) { return this.group.getMembers(id); }
+    getGroupInviteInfo(code) { return this.group.getInviteInfo(code); }
+    getInviteGroup(id) { return this.group.getInviteCode(id); }
+    updateGroupPicture(id, url) { return this.group.updatePicture(id, url); }
+    removeGroupPicture(id) { return this.group.removePicture(id); }
+    addParticipantsGroup(id, participants) { return this.group.addParticipants(id, participants); }
+    removeParticipantsGroup(id, participants) { return this.group.removeParticipants(id, participants); }
+    updateGroupParticipantRole(id, action, participants) { return this.group.updateParticipantRole(id, action, participants); }
+    getGroupRequestParticipants(id) { return this.group.getRequestParticipants(id); }
+    updateGroupRequestParticipants(id, data) { return this.group.updateRequestParticipants(id, data); }
+    // Community
+    listCommunities() { return this.community.list(); }
+    createCommunity(data) { return this.community.create(data); }
+    infoCommunity(id) { return this.community.info(id); }
+    updateCommunity(id, data) { return this.community.update(id, data); }
+    leaveCommunity(id) { return this.community.leave(id); }
+    updateCommunityPicture(id, url) { return this.community.updatePicture(id, url); }
+    getCommunityInviteCode(id) { return this.community.getInviteCode(id); }
+    removeCommunityParticipants(id, participants) { return this.community.removeParticipants(id, participants); }
+    getCommunityRequestParticipants(id) { return this.community.getRequestParticipants(id); }
+    updateCommunityRequestParticipants(id, data) { return this.community.updateRequestParticipants(id, data); }
+    acceptCommunityInvite(code) { return this.community.acceptInvite(code); }
+    getCommunityInviteInfo(code) { return this.community.getInviteInfo(code); }
+    createCommunityGroup(id, data) { return this.community.createGroup(id, data); }
+    setCommunityEphemeral(id, expiration) { return this.community.ephemeral(id, expiration); }
+    updateCommunitySettings(id, setting) { return this.community.updateSettings(id, setting); }
+    setCommunityMemberAddMode(id, mode) { return this.community.memberAddMode(id, mode); }
+    setCommunityJoinApproval(id, mode) { return this.community.joinApproval(id, mode); }
+    // Business
+    getCatalog(limit, cursor) { return this.business.getCatalog(limit, cursor); }
+    createProduct(product) { return this.business.createProduct(product); }
+    updateProduct(productId, product) { return this.business.updateProduct(productId, product); }
+    deleteProduct(productId) { return this.business.deleteProduct(productId); }
 }
 exports.WhatsApp = WhatsApp;
 exports.default = WhatsApp;