signal-sdk 0.1.1 → 0.1.3

package/dist/__tests__/SignalCli.methods.test.js

@@ -46,32 +46,32 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Hello',
                 recipients: ['+1234567890'],
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should send message to group', async () => {
             await signalCli.sendMessage('group123==', 'Hello group');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Hello group',
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should send message with attachments', async () => {
             await signalCli.sendMessage('+1234567890', 'Check this', { attachments: ['/path/to/file.jpg'] });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
-                attachments: ['/path/to/file.jpg']
+                attachments: ['/path/to/file.jpg'],
             }));
         });
         it('should send message with expiration', async () => {
             await signalCli.sendMessage('+1234567890', 'Secret', { expiresInSeconds: 3600 });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
-                expiresInSeconds: 3600
+                expiresInSeconds: 3600,
             }));
         });
         it('should send view-once message', async () => {
             await signalCli.sendMessage('+1234567890', 'View once', { isViewOnce: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
-                viewOnce: true
+                viewOnce: true,
             }));
         });
         it('should send reaction', async () => {
@@ -81,39 +81,39 @@ describe('SignalCli Methods Tests', () => {
                 targetAuthor: '+0987654321',
                 targetTimestamp: 123456,
                 remove: false,
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should send reaction with remove flag', async () => {
             await signalCli.sendReaction('+1234567890', '+0987654321', 123456, '👍', true);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendReaction', expect.objectContaining({
-                remove: true
+                remove: true,
             }));
         });
         it('should send reaction to group', async () => {
             await signalCli.sendReaction('group123==', '+0987654321', 123456, '👍');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendReaction', expect.objectContaining({
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should send typing indicator', async () => {
             await signalCli.sendTyping('+1234567890');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendTyping', expect.objectContaining({
                 when: true,
-                recipients: ['+1234567890']
+                recipients: ['+1234567890'],
             }));
         });
         it('should stop typing indicator', async () => {
             await signalCli.sendTyping('+1234567890', true);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendTyping', expect.objectContaining({
-                when: false
+                when: false,
             }));
         });
         it('should remote delete message', async () => {
             await signalCli.remoteDeleteMessage('+1234567890', 123456);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('remoteDelete', expect.objectContaining({
                 targetTimestamp: 123456,
-                recipients: ['+1234567890']
+                recipients: ['+1234567890'],
             }));
         });
     });
@@ -122,7 +122,7 @@ describe('SignalCli Methods Tests', () => {
             await signalCli.updateContact('+1234567890', 'John Doe');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateContact', expect.objectContaining({
                 recipient: '+1234567890',
-                name: 'John Doe'
+                name: 'John Doe',
             }));
         });
         it('should update contact with options', async () => {
@@ -130,25 +130,25 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateContact', expect.objectContaining({
                 name: 'John Doe',
                 color: 'blue',
-                muted: true
+                muted: true,
             }));
         });
         it('should block recipients', async () => {
             await signalCli.block(['+1111111111', '+2222222222']);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('block', expect.objectContaining({
-                recipient: ['+1111111111', '+2222222222']
+                recipient: ['+1111111111', '+2222222222'],
             }));
         });
         it('should block group', async () => {
             await signalCli.block([], 'group123==');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('block', expect.objectContaining({
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should unblock recipients', async () => {
             await signalCli.unblock(['+1111111111']);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('unblock', expect.objectContaining({
-                recipient: ['+1111111111']
+                recipient: ['+1111111111'],
             }));
         });
     });
@@ -156,13 +156,13 @@ describe('SignalCli Methods Tests', () => {
         it('should quit group', async () => {
             await signalCli.quitGroup('group123==');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('quitGroup', expect.objectContaining({
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should join group', async () => {
             await signalCli.joinGroup('https://signal.group/...');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('joinGroup', expect.objectContaining({
-                uri: 'https://signal.group/...'
+                uri: 'https://signal.group/...',
             }));
         });
     });
@@ -170,7 +170,7 @@ describe('SignalCli Methods Tests', () => {
         it('should update profile with name only', async () => {
             await signalCli.updateProfile('John Doe');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateProfile', expect.objectContaining({
-                name: 'John Doe'
+                name: 'John Doe',
             }));
         });
         it('should update profile with all fields', async () => {
@@ -179,7 +179,7 @@ describe('SignalCli Methods Tests', () => {
                 name: 'John Doe',
                 about: 'Hello!',
                 aboutEmoji: '👋',
-                avatar: '/path/to/avatar.jpg'
+                avatar: '/path/to/avatar.jpg',
             }));
         });
     });
@@ -189,13 +189,13 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendReceipt', expect.objectContaining({
                 recipient: '+1234567890',
                 targetTimestamp: 123456,
-                type: 'read'
+                type: 'read',
             }));
         });
         it('should send viewed receipt', async () => {
             await signalCli.sendReceipt('+1234567890', 123456, 'viewed');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendReceipt', expect.objectContaining({
-                type: 'viewed'
+                type: 'viewed',
             }));
         });
     });
@@ -205,14 +205,14 @@ describe('SignalCli Methods Tests', () => {
             const packs = await signalCli.listStickerPacks();
             expect(packs).toHaveLength(1);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listStickerPacks', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should add sticker pack', async () => {
             await signalCli.addStickerPack('packId123', 'packKey456');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('addStickerPack', expect.objectContaining({
                 packId: 'packId123',
-                packKey: 'packKey456'
+                packKey: 'packKey456',
             }));
         });
     });
@@ -220,7 +220,7 @@ describe('SignalCli Methods Tests', () => {
         it('should register account', async () => {
             await signalCli.register('+1234567890');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('register', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should register with voice and captcha', async () => {
@@ -228,32 +228,32 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('register', expect.objectContaining({
                 account: '+1234567890',
                 voice: true,
-                captcha: 'captcha123'
+                captcha: 'captcha123',
             }));
         });
         it('should verify account', async () => {
             await signalCli.verify('+1234567890', 'token123');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('verify', expect.objectContaining({
                 account: '+1234567890',
-                token: 'token123'
+                token: 'token123',
             }));
         });
         it('should verify with PIN', async () => {
             await signalCli.verify('+1234567890', 'token123', '1234');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('verify', expect.objectContaining({
-                pin: '1234'
+                pin: '1234',
             }));
         });
         it('should unregister account', async () => {
             await signalCli.unregister();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('unregister', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should delete local account data', async () => {
             await signalCli.deleteLocalAccountData();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('deleteLocalAccountData', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should update account configuration', async () => {
@@ -261,7 +261,7 @@ describe('SignalCli Methods Tests', () => {
             await signalCli.updateAccountConfiguration(config);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateConfiguration', expect.objectContaining({
                 readReceipts: true,
-                typingIndicators: true
+                typingIndicators: true,
             }));
         });
     });
@@ -269,7 +269,7 @@ describe('SignalCli Methods Tests', () => {
         it('should remove device', async () => {
             await signalCli.removeDevice(2);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('removeDevice', expect.objectContaining({
-                deviceId: 2
+                deviceId: 2,
             }));
         });
     });
@@ -277,13 +277,13 @@ describe('SignalCli Methods Tests', () => {
         it('should set PIN', async () => {
             await signalCli.setPin('1234');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('setPin', expect.objectContaining({
-                pin: '1234'
+                pin: '1234',
             }));
         });
         it('should remove PIN', async () => {
             await signalCli.removePin();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('removePin', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
     });
@@ -293,14 +293,14 @@ describe('SignalCli Methods Tests', () => {
             const identities = await signalCli.listIdentities();
             expect(identities).toHaveLength(1);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listIdentities', expect.objectContaining({
-                account: '+1234567890'
+                account: '+1234567890',
             }));
         });
         it('should list identities for specific number', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue([{ number: '+1111111111' }]);
             await signalCli.listIdentities('+1111111111');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listIdentities', expect.objectContaining({
-                number: '+1111111111'
+                number: '+1111111111',
             }));
         });
         it('should trust identity', async () => {
@@ -308,13 +308,13 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('trust', expect.objectContaining({
                 recipient: '+1111111111',
                 safetyNumber: 'fingerprint123',
-                verified: true
+                verified: true,
             }));
         });
         it('should trust identity with verified flag', async () => {
             await signalCli.trustIdentity('+1111111111', 'fingerprint123', false);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('trust', expect.objectContaining({
-                verified: false
+                verified: false,
             }));
         });
     });
@@ -324,14 +324,14 @@ describe('SignalCli Methods Tests', () => {
             const uri = await signalCli.link('MyDevice');
             expect(uri).toBe('sgnl://link?...');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('link', {
-                deviceName: 'MyDevice'
+                deviceName: 'MyDevice',
             });
         });
         it('should link without device name', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue({ uri: 'sgnl://link?...' });
             await signalCli.link();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('link', {
-                deviceName: undefined
+                deviceName: undefined,
             });
         });
     });
@@ -340,22 +340,22 @@ describe('SignalCli Methods Tests', () => {
             await signalCli.sendPollCreate({
                 question: 'What is your favorite color?',
                 options: ['Red', 'Blue', 'Green'],
-                groupId: 'group123=='
+                groupId: 'group123==',
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollCreate', expect.objectContaining({
                 question: 'What is your favorite color?',
                 options: ['Red', 'Blue', 'Green'],
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should send poll create to recipients', async () => {
             await signalCli.sendPollCreate({
                 question: 'What is your favorite color?',
                 options: ['Red', 'Blue'],
-                recipients: ['+1111111111', '+2222222222']
+                recipients: ['+1111111111', '+2222222222'],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollCreate', expect.objectContaining({
-                recipients: ['+1111111111', '+2222222222']
+                recipients: ['+1111111111', '+2222222222'],
             }));
         });
         it('should send poll create with multiSelect', async () => {
@@ -363,43 +363,127 @@ describe('SignalCli Methods Tests', () => {
                 question: 'Select options',
                 options: ['A', 'B', 'C'],
                 groupId: 'group123==',
-                multiSelect: true
+                multiSelect: true,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollCreate', expect.objectContaining({
-                multiSelect: true
+                multiSelect: true,
             }));
         });
         it('should send poll vote to individual', async () => {
             await signalCli.sendPollVote('+1234567890', {
                 pollAuthor: '+9876543210',
                 pollTimestamp: 123456,
-                optionIndexes: [0, 2]
+                optionIndexes: [0, 2],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollVote', expect.objectContaining({
                 pollAuthor: '+9876543210',
                 pollTimestamp: 123456,
                 options: [0, 2],
-                recipient: '+1234567890'
+                recipient: '+1234567890',
             }));
         });
         it('should send poll vote to group', async () => {
             await signalCli.sendPollVote('group123==', {
                 pollAuthor: '+9876543210',
                 pollTimestamp: 123456,
-                optionIndexes: [1]
+                optionIndexes: [1],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollVote', expect.objectContaining({
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should send poll terminate', async () => {
             await signalCli.sendPollTerminate('+1234567890', {
-                pollTimestamp: 123456
+                pollTimestamp: 123456,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPollTerminate', expect.objectContaining({
-                pollTimestamp: 123456
+                pollTimestamp: 123456,
+            }));
+        });
+    });
+    describe('Update Account Methods', () => {
+        it('should update account with device name', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({ username: 'user.123' });
+            const result = await signalCli.updateAccount({ deviceName: 'New Device' });
+            expect(result.success).toBe(true);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                deviceName: 'New Device',
+            }));
+        });
+        it('should update account with username', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({ username: 'newuser.456', usernameLink: 'link' });
+            const result = await signalCli.updateAccount({ username: 'newuser.456' });
+            expect(result.success).toBe(true);
+            expect(result.username).toBe('newuser.456');
+        });
+        it('should delete username', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({});
+            await signalCli.updateAccount({ deleteUsername: true });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                deleteUsername: true,
             }));
         });
+        it('should update privacy settings', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue({});
+            await signalCli.updateAccount({
+                unrestrictedUnidentifiedSender: true,
+                discoverableByNumber: false,
+                numberSharing: false,
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
+                unrestrictedUnidentifiedSender: true,
+                discoverableByNumber: false,
+                numberSharing: false,
+            }));
+        });
+        it('should handle update account error', async () => {
+            sendJsonRpcRequestSpy.mockRejectedValue(new Error('Update failed'));
+            const result = await signalCli.updateAccount({ deviceName: 'Device' });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('Device Management Methods (v0.13.23+)', () => {
+        it('should list devices', async () => {
+            const mockDevices = [
+                { id: 1, name: 'Primary', lastSeen: Date.now() },
+                { id: 2, name: 'Tablet', lastSeen: Date.now() },
+            ];
+            sendJsonRpcRequestSpy.mockResolvedValue(mockDevices);
+            const result = await signalCli.listDevices();
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('listDevices', {
+                account: '+1234567890',
+            });
+            expect(result).toEqual(mockDevices);
+        });
+        it('should update device name', async () => {
+            sendJsonRpcRequestSpy.mockResolvedValue(undefined);
+            await signalCli.updateDevice({
+                deviceId: 3,
+                deviceName: 'My Laptop',
+            });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateDevice', {
+                account: '+1234567890',
+                deviceId: 3,
+                deviceName: 'My Laptop',
+            });
+        });
+        it('should validate device ID', async () => {
+            await expect(signalCli.updateDevice({
+                deviceId: 0,
+                deviceName: 'Invalid',
+            })).rejects.toThrow();
+            await expect(signalCli.updateDevice({
+                deviceId: -5,
+                deviceName: 'Invalid',
+            })).rejects.toThrow();
+        });
+        it('should validate device name is not too long', async () => {
+            const longName = 'x'.repeat(300);
+            await expect(signalCli.updateDevice({
+                deviceId: 2,
+                deviceName: longName,
+            })).rejects.toThrow();
+        });
     });
     describe('Update Account Methods', () => {
         it('should update account with device name', async () => {
@@ -407,7 +491,7 @@ describe('SignalCli Methods Tests', () => {
             const result = await signalCli.updateAccount({ deviceName: 'New Device' });
             expect(result.success).toBe(true);
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
-                deviceName: 'New Device'
+                deviceName: 'New Device',
             }));
         });
         it('should update account with username', async () => {
@@ -420,7 +504,7 @@ describe('SignalCli Methods Tests', () => {
             sendJsonRpcRequestSpy.mockResolvedValue({});
             await signalCli.updateAccount({ deleteUsername: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
-                deleteUsername: true
+                deleteUsername: true,
             }));
         });
         it('should update privacy settings', async () => {
@@ -428,12 +512,12 @@ describe('SignalCli Methods Tests', () => {
             await signalCli.updateAccount({
                 unrestrictedUnidentifiedSender: true,
                 discoverableByNumber: false,
-                numberSharing: false
+                numberSharing: false,
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('updateAccount', expect.objectContaining({
                 unrestrictedUnidentifiedSender: true,
                 discoverableByNumber: false,
-                numberSharing: false
+                numberSharing: false,
             }));
         });
         it('should handle update account error', async () => {
@@ -449,21 +533,21 @@ describe('SignalCli Methods Tests', () => {
             const data = await signalCli.getAttachment({ id: 'attachment123' });
             expect(data).toBe('base64data...');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAttachment', expect.objectContaining({
-                id: 'attachment123'
+                id: 'attachment123',
             }));
         });
         it('should get attachment with groupId', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue('base64data');
             await signalCli.getAttachment({ id: 'att1', groupId: 'group123==' });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAttachment', expect.objectContaining({
-                groupId: 'group123=='
+                groupId: 'group123==',
             }));
         });
         it('should get attachment with recipient', async () => {
             sendJsonRpcRequestSpy.mockResolvedValue('base64data');
             await signalCli.getAttachment({ id: 'att1', recipient: '+1111111111' });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('getAttachment', expect.objectContaining({
-                recipient: '+1111111111'
+                recipient: '+1111111111',
             }));
         });
     });
@@ -473,7 +557,7 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
                 account: '+1234567890',
                 number: '+33612345678',
-                voice: false
+                voice: false,
             });
         });
         it('should start change number with voice verification', async () => {
@@ -481,7 +565,7 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
                 account: '+1234567890',
                 number: '+33612345678',
-                voice: true
+                voice: true,
             });
         });
         it('should start change number with captcha', async () => {
@@ -491,7 +575,7 @@ describe('SignalCli Methods Tests', () => {
                 account: '+1234567890',
                 number: '+33612345678',
                 voice: false,
-                captcha
+                captcha,
             });
         });
         it('should validate phone number in startChangeNumber', async () => {
@@ -502,7 +586,7 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
                 account: '+1234567890',
                 number: '+33612345678',
-                verificationCode: '123456'
+                verificationCode: '123456',
             });
         });
         it('should finish change number with PIN', async () => {
@@ -511,7 +595,7 @@ describe('SignalCli Methods Tests', () => {
                 account: '+1234567890',
                 number: '+33612345678',
                 verificationCode: '123456',
-                pin: '1234'
+                pin: '1234',
             });
         });
         it('should validate phone number in finishChangeNumber', async () => {
@@ -533,7 +617,7 @@ describe('SignalCli Methods Tests', () => {
                 account: '+1234567890',
                 recipient,
                 receipt,
-                note
+                note,
             });
         });
         it('should send payment notification without note', async () => {
@@ -543,7 +627,7 @@ describe('SignalCli Methods Tests', () => {
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
                 account: '+1234567890',
                 recipient,
-                receipt
+                receipt,
             });
         });
         it('should validate recipient in sendPaymentNotification', async () => {

package/dist/__tests__/SignalCli.parsing.test.js

@@ -95,20 +95,11 @@ describe('SignalCli - Enhanced Parsing (Phase 5)', () => {
                 isMember: true,
                 isBlocked: false,
                 messageExpirationTime: 0,
-                members: [
-                    { number: '+33111111111' },
-                    { number: '+33222222222' },
-                ],
-                pendingMembers: [
-                    { number: '+33333333333' },
-                ],
+                members: [{ number: '+33111111111' }, { number: '+33222222222' }],
+                pendingMembers: [{ number: '+33333333333' }],
                 requestingMembers: [],
-                admins: [
-                    { number: '+33111111111' },
-                ],
-                banned: [
-                    { number: '+33444444444' },
-                ],
+                admins: [{ number: '+33111111111' }],
+                banned: [{ number: '+33444444444' }],
                 permissionAddMember: 'ONLY_ADMINS',
                 permissionEditDetails: 'ONLY_ADMINS',
                 permissionSendMessage: 'EVERY_MEMBER',

package/dist/__tests__/SignalCli.simple.test.d.ts

@@ -0,0 +1 @@
+export {};