@catalisa/wpp-sdk 0.2.2 → 0.3.0

package/dist/resources/whatsapp.test.js

@@ -0,0 +1,780 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const whatsapp_1 = require("./whatsapp");
+// Mock HTTPClient
+vitest_1.vi.mock('../http/client', () => ({
+    HTTPClient: vitest_1.vi.fn().mockImplementation(() => ({
+        get: vitest_1.vi.fn(),
+        post: vitest_1.vi.fn(),
+        put: vitest_1.vi.fn(),
+        patch: vitest_1.vi.fn(),
+        delete: vitest_1.vi.fn(),
+        getBaseURL: vitest_1.vi.fn().mockReturnValue('https://api.example.com'),
+    })),
+}));
+(0, vitest_1.describe)('WhatsAppResource', () => {
+    let whatsapp;
+    let mockHttp;
+    (0, vitest_1.beforeEach)(() => {
+        mockHttp = {
+            get: vitest_1.vi.fn(),
+            post: vitest_1.vi.fn(),
+            getBaseURL: vitest_1.vi.fn().mockReturnValue('https://api.example.com'),
+        };
+        whatsapp = new whatsapp_1.WhatsAppResource(mockHttp);
+    });
+    // ===== Session Management =====
+    (0, vitest_1.describe)('Session Management', () => {
+        (0, vitest_1.it)('should connect with default params', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'corr-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.connect();
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/connect', {});
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should connect with driver and callback params', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'corr-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.connect({
+                driver: 'cloud-api',
+                callbackUrl: 'https://example.com/callback',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/connect', {
+                driver: 'cloud-api',
+                callbackUrl: 'https://example.com/callback',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should connect with cloud API credentials', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'corr-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.connect({
+                driver: 'cloud-api',
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    accessToken: 'EAAG...',
+                    businessAccountId: 'waba-id',
+                },
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/connect', {
+                driver: 'cloud-api',
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    accessToken: 'EAAG...',
+                    businessAccountId: 'waba-id',
+                },
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should reconnect session', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'corr-456' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.reconnect({ force: true });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/reconnect', { force: true });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should reset session', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'corr-789' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.reset();
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/reset', {});
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should logout', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'corr-logout' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.logout();
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/logout', {});
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should ping device', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'ping-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.ping();
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/ping');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get QR code', async () => {
+            const mockResponse = { qr: 'base64-qr-data', status: 'qr', expiresAt: '2024-01-01T00:00:00Z' };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getQR('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/tenant-123/qr');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get device info', async () => {
+            const mockDevice = {
+                id: 'device-1',
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                status: 'open',
+                driver: 'baileys',
+                jid: '5511999999999@s.whatsapp.net',
+                createdAt: '2024-01-01T00:00:00Z',
+                updatedAt: '2024-01-01T00:00:00Z',
+            };
+            mockHttp.get.mockResolvedValue(mockDevice);
+            const result = await whatsapp.getDevice('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/tenant-123/device');
+            (0, vitest_1.expect)(result).toEqual(mockDevice);
+        });
+    });
+    // ===== Driver Configuration =====
+    (0, vitest_1.describe)('Driver Configuration', () => {
+        (0, vitest_1.it)('should configure driver for Baileys', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'baileys',
+                configured: true,
+            };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.configureDriver('tenant-123', {
+                driver: 'baileys',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/tenant-123/driver/default', {
+                driver: 'baileys',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should configure driver for Cloud API with credentials', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                },
+            };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.configureDriver('tenant-123', {
+                driver: 'cloud-api',
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    accessToken: 'EAAG...',
+                    businessAccountId: 'waba-id',
+                    webhookVerifyToken: 'my-verify-token',
+                },
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/tenant-123/driver/default', {
+                driver: 'cloud-api',
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    accessToken: 'EAAG...',
+                    businessAccountId: 'waba-id',
+                    webhookVerifyToken: 'my-verify-token',
+                },
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should configure driver with custom deviceId', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'custom-device',
+                driver: 'baileys',
+                configured: true,
+            };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.configureDriver('tenant-123', { driver: 'baileys' }, 'custom-device');
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/tenant-123/driver/custom-device', {
+                driver: 'baileys',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get driver configuration', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getDriverConfig('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/tenant-123/driver/default');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get driver configuration for custom deviceId', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'custom-device',
+                driver: 'baileys',
+                configured: true,
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getDriverConfig('tenant-123', 'custom-device');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/tenant-123/driver/custom-device');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+    });
+    // ===== Messaging =====
+    (0, vitest_1.describe)('Messaging', () => {
+        (0, vitest_1.it)('should send text message', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'msg-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendMessage({
+                jid: '5511999999999@s.whatsapp.net',
+                text: 'Hello World',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/send', {
+                jid: '5511999999999@s.whatsapp.net',
+                text: 'Hello World',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should send reaction', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'react-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendReaction({
+                key: {
+                    id: 'msg-id-123',
+                    remoteJid: '5511999999999@s.whatsapp.net',
+                    fromMe: false,
+                },
+                emoji: '👍',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/reaction', {
+                key: {
+                    id: 'msg-id-123',
+                    remoteJid: '5511999999999@s.whatsapp.net',
+                    fromMe: false,
+                },
+                emoji: '👍',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should send media with URL', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'media-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendMedia({
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'image',
+                url: 'https://example.com/image.jpg',
+                caption: 'Check this out!',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/media', {
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'image',
+                url: 'https://example.com/image.jpg',
+                caption: 'Check this out!',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should send media with base64', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'media-456' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendMedia({
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'document',
+                base64: 'base64-encoded-content',
+                mimetype: 'application/pdf',
+                filename: 'document.pdf',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/media', {
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'document',
+                base64: 'base64-encoded-content',
+                mimetype: 'application/pdf',
+                filename: 'document.pdf',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+    });
+    // ===== Cloud API Features =====
+    (0, vitest_1.describe)('Cloud API Features', () => {
+        (0, vitest_1.it)('should send template message', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'template-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendTemplate({
+                jid: '5511999999999@s.whatsapp.net',
+                templateName: 'hello_world',
+                languageCode: 'pt_BR',
+                components: [
+                    {
+                        type: 'body',
+                        parameters: [{ type: 'text', text: 'João' }],
+                    },
+                ],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/template', {
+                jid: '5511999999999@s.whatsapp.net',
+                templateName: 'hello_world',
+                languageCode: 'pt_BR',
+                components: [
+                    {
+                        type: 'body',
+                        parameters: [{ type: 'text', text: 'João' }],
+                    },
+                ],
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should send template with header image', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'template-456' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendTemplate({
+                jid: '5511999999999@s.whatsapp.net',
+                templateName: 'order_confirmation',
+                languageCode: 'en',
+                components: [
+                    {
+                        type: 'header',
+                        parameters: [{ type: 'image', image: { link: 'https://example.com/image.jpg' } }],
+                    },
+                    {
+                        type: 'body',
+                        parameters: [
+                            { type: 'text', text: 'Order #12345' },
+                            { type: 'currency', currency: { fallback_value: '$10.00', code: 'USD', amount_1000: 10000 } },
+                        ],
+                    },
+                ],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/template', vitest_1.expect.objectContaining({
+                templateName: 'order_confirmation',
+            }));
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get templates list', async () => {
+            const mockResponse = {
+                templates: [
+                    {
+                        id: 'tmpl-1',
+                        name: 'hello_world',
+                        status: 'APPROVED',
+                        category: 'UTILITY',
+                        language: 'pt_BR',
+                        components: [{ type: 'BODY', text: 'Hello {{1}}!' }],
+                    },
+                    {
+                        id: 'tmpl-2',
+                        name: 'order_update',
+                        status: 'APPROVED',
+                        category: 'UTILITY',
+                        language: 'en',
+                        components: [{ type: 'BODY', text: 'Your order {{1}} has been shipped.' }],
+                    },
+                ],
+                paging: {
+                    cursors: { after: 'cursor-123' },
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getTemplates('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/tenant-123/templates?deviceId=default');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+            (0, vitest_1.expect)(result.templates).toHaveLength(2);
+        });
+        (0, vitest_1.it)('should get templates for specific device', async () => {
+            const mockResponse = { templates: [], paging: {} };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            await whatsapp.getTemplates('tenant-123', 'device-456');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/tenant-123/templates?deviceId=device-456');
+        });
+        (0, vitest_1.it)('should send interactive button message', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'interactive-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendInteractive({
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'button',
+                body: { text: 'Choose an option:' },
+                action: {
+                    buttons: [
+                        { type: 'reply', reply: { id: 'opt1', title: 'Option 1' } },
+                        { type: 'reply', reply: { id: 'opt2', title: 'Option 2' } },
+                    ],
+                },
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/interactive', {
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'button',
+                body: { text: 'Choose an option:' },
+                action: {
+                    buttons: [
+                        { type: 'reply', reply: { id: 'opt1', title: 'Option 1' } },
+                        { type: 'reply', reply: { id: 'opt2', title: 'Option 2' } },
+                    ],
+                },
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should send interactive list message', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'interactive-456' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendInteractive({
+                jid: '5511999999999@s.whatsapp.net',
+                type: 'list',
+                header: { type: 'text', text: 'Our Menu' },
+                body: { text: 'Select from the options below:' },
+                footer: { text: 'Powered by Catalisa' },
+                action: {
+                    button: 'View Menu',
+                    sections: [
+                        {
+                            title: 'Drinks',
+                            rows: [
+                                { id: 'coffee', title: 'Coffee', description: 'Fresh brewed' },
+                                { id: 'tea', title: 'Tea', description: 'Assorted flavors' },
+                            ],
+                        },
+                        {
+                            title: 'Snacks',
+                            rows: [
+                                { id: 'cookie', title: 'Cookie', description: 'Chocolate chip' },
+                            ],
+                        },
+                    ],
+                },
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/interactive', vitest_1.expect.objectContaining({
+                type: 'list',
+                action: vitest_1.expect.objectContaining({
+                    button: 'View Menu',
+                    sections: vitest_1.expect.arrayContaining([
+                        vitest_1.expect.objectContaining({ title: 'Drinks' }),
+                    ]),
+                }),
+            }));
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+    });
+    // ===== Cloud API Receiver =====
+    (0, vitest_1.describe)('Cloud API Receiver', () => {
+        (0, vitest_1.it)('should get Cloud API receiver status', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                    hasWebhookToken: true,
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getCloudApiReceiverStatus('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/cloud-api/receiver/tenant-123/default/status');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get Cloud API receiver status for custom device', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'device-456',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                    hasWebhookToken: true,
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getCloudApiReceiverStatus('tenant-123', 'device-456');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/cloud-api/receiver/tenant-123/device-456/status');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get Cloud API receiver status for unconfigured device', async () => {
+            const mockResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'baileys',
+                configured: false,
+                cloudApi: null,
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getCloudApiReceiverStatus('tenant-123');
+            (0, vitest_1.expect)(result.configured).toBe(false);
+            (0, vitest_1.expect)(result.cloudApi).toBeNull();
+        });
+        (0, vitest_1.it)('should get Cloud API webhook URL using default base URL', async () => {
+            const mockStatusResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                    hasWebhookToken: true,
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockStatusResponse);
+            const result = await whatsapp.getCloudApiWebhookUrl('tenant-123');
+            (0, vitest_1.expect)(mockHttp.getBaseURL).toHaveBeenCalled();
+            (0, vitest_1.expect)(result.webhookUrl).toBe('https://api.example.com/wpp/cloud-api/receiver/tenant-123/default');
+            (0, vitest_1.expect)(result.tenantId).toBe('tenant-123');
+            (0, vitest_1.expect)(result.deviceId).toBe('default');
+        });
+        (0, vitest_1.it)('should get Cloud API webhook URL with custom base URL', async () => {
+            const mockStatusResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'device-456',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                    hasWebhookToken: true,
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockStatusResponse);
+            const result = await whatsapp.getCloudApiWebhookUrl('tenant-123', 'device-456', 'https://custom-api.example.com');
+            (0, vitest_1.expect)(result.webhookUrl).toBe('https://custom-api.example.com/wpp/cloud-api/receiver/tenant-123/device-456');
+            (0, vitest_1.expect)(result.deviceId).toBe('device-456');
+        });
+        (0, vitest_1.it)('should indicate when webhook token is not configured', async () => {
+            const mockStatusResponse = {
+                tenantId: 'tenant-123',
+                deviceId: 'default',
+                driver: 'cloud-api',
+                configured: true,
+                cloudApi: {
+                    phoneNumberId: '123456789',
+                    businessAccountId: 'waba-id',
+                    hasAccessToken: true,
+                    hasWebhookToken: false,
+                },
+            };
+            mockHttp.get.mockResolvedValue(mockStatusResponse);
+            const result = await whatsapp.getCloudApiWebhookUrl('tenant-123');
+            (0, vitest_1.expect)(result.verifyToken).toBe('(not configured)');
+        });
+    });
+    // ===== Group Management =====
+    (0, vitest_1.describe)('Group Management', () => {
+        (0, vitest_1.it)('should create group', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.createGroup({
+                subject: 'Test Group',
+                participants: ['5511999999999@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/create', {
+                subject: 'Test Group',
+                participants: ['5511999999999@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should update group subject', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-subj-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.updateGroupSubject({
+                gid: '123456789@g.us',
+                subject: 'New Group Name',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/subject', {
+                gid: '123456789@g.us',
+                subject: 'New Group Name',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should update group description', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-desc-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.updateGroupDescription({
+                gid: '123456789@g.us',
+                description: 'This is a test group',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/description', {
+                gid: '123456789@g.us',
+                description: 'This is a test group',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should add participants', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-add-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.addGroupParticipants({
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/add', {
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should remove participants', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-rm-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.removeGroupParticipants({
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/remove', {
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should promote participants', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-promo-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.promoteGroupParticipants({
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/promote', {
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should demote participants', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-demo-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.demoteGroupParticipants({
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/demote', {
+                gid: '123456789@g.us',
+                participants: ['5511888888888@s.whatsapp.net'],
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should leave group', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-leave-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.leaveGroup({
+                gid: '123456789@g.us',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/leave', {
+                gid: '123456789@g.us',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should delete group', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'grp-del-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.deleteGroup({
+                gid: '123456789@g.us',
+                removeAll: true,
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/group/delete', {
+                gid: '123456789@g.us',
+                removeAll: true,
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+    });
+    // ===== Query Endpoints =====
+    (0, vitest_1.describe)('Query Endpoints', () => {
+        (0, vitest_1.it)('should list groups', async () => {
+            const mockGroups = [
+                { gid: '123@g.us', subject: 'Group 1' },
+                { gid: '456@g.us', subject: 'Group 2' },
+            ];
+            mockHttp.get.mockResolvedValue(mockGroups);
+            const result = await whatsapp.listGroups('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/groups?tenantId=tenant-123&force=false');
+            (0, vitest_1.expect)(result).toEqual(mockGroups);
+        });
+        (0, vitest_1.it)('should list groups with force refresh', async () => {
+            mockHttp.get.mockResolvedValue([]);
+            await whatsapp.listGroups('tenant-123', true);
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/groups?tenantId=tenant-123&force=true');
+        });
+        (0, vitest_1.it)('should list chats', async () => {
+            const mockChats = [
+                { jid: '5511999999999@s.whatsapp.net', name: 'Contact 1' },
+            ];
+            mockHttp.get.mockResolvedValue(mockChats);
+            const result = await whatsapp.listChats('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/chats?tenantId=tenant-123&force=false');
+            (0, vitest_1.expect)(result).toEqual(mockChats);
+        });
+        (0, vitest_1.it)('should list contacts', async () => {
+            const mockContacts = [
+                { jid: '5511999999999@s.whatsapp.net', name: 'John' },
+            ];
+            mockHttp.get.mockResolvedValue(mockContacts);
+            const result = await whatsapp.listContacts('tenant-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/contacts?tenantId=tenant-123&force=false');
+            (0, vitest_1.expect)(result).toEqual(mockContacts);
+        });
+        (0, vitest_1.it)('should get operation result', async () => {
+            const mockOperation = {
+                correlationId: 'corr-123',
+                status: 'completed',
+                result: { messageId: 'msg-id' },
+            };
+            mockHttp.get.mockResolvedValue(mockOperation);
+            const result = await whatsapp.getOperation('corr-123');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/operation/corr-123');
+            (0, vitest_1.expect)(result).toEqual(mockOperation);
+        });
+    });
+    // ===== QR Link Support =====
+    (0, vitest_1.describe)('QR Link Support', () => {
+        (0, vitest_1.it)('should generate QR link', async () => {
+            const mockResponse = {
+                token: 'abc123',
+                url: 'https://example.com/qr/abc123',
+                expiresAt: '2024-01-02T00:00:00Z',
+            };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.generateQRLink({
+                tenantId: 'tenant-123',
+                expirationHours: 24,
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/generate-qr-link', {
+                tenantId: 'tenant-123',
+                expirationHours: 24,
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should send QR link', async () => {
+            const mockResponse = { enqueued: true, correlationId: 'qrlink-123' };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.sendQRLink({
+                senderTenantId: 'tenant-1',
+                recipientTenantId: 'tenant-2',
+                recipientJid: '5511999999999@s.whatsapp.net',
+            });
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/send-qr-link', {
+                senderTenantId: 'tenant-1',
+                recipientTenantId: 'tenant-2',
+                recipientJid: '5511999999999@s.whatsapp.net',
+            });
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should get public QR', async () => {
+            const mockResponse = {
+                qr: 'base64-qr',
+                status: 'qr',
+                tenant: { name: 'Test Tenant' },
+                expiresAt: '2024-01-02T00:00:00Z',
+            };
+            mockHttp.get.mockResolvedValue(mockResponse);
+            const result = await whatsapp.getPublicQR('token-abc');
+            (0, vitest_1.expect)(mockHttp.get).toHaveBeenCalledWith('/wpp/public/qr/token-abc');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+        (0, vitest_1.it)('should regenerate public QR', async () => {
+            const mockResponse = {
+                qr: 'new-base64-qr',
+                status: 'qr',
+                tenant: { name: 'Test Tenant' },
+                expiresAt: '2024-01-02T00:00:00Z',
+            };
+            mockHttp.post.mockResolvedValue(mockResponse);
+            const result = await whatsapp.regeneratePublicQR('token-abc');
+            (0, vitest_1.expect)(mockHttp.post).toHaveBeenCalledWith('/wpp/public/qr/token-abc/regenerate');
+            (0, vitest_1.expect)(result).toEqual(mockResponse);
+        });
+    });
+});
+//# sourceMappingURL=whatsapp.test.js.map