signal-sdk 0.1.1 → 0.1.3

package/dist/__tests__/config.test.js

@@ -14,7 +14,7 @@ describe('Config Additional Tests', () => {
         test('should merge user config with defaults', () => {
             const userConfig = {
                 verbose: true,
-                maxRetries: 5
+                maxRetries: 5,
             };
             const config = (0, config_1.validateConfig)(userConfig);
             expect(config.verbose).toBe(true);
@@ -22,38 +22,28 @@ describe('Config Additional Tests', () => {
             expect(config.connectionTimeout).toBe(config_1.DEFAULT_CONFIG.connectionTimeout);
         });
         test('should throw error for negative connectionTimeout', () => {
-            expect(() => (0, config_1.validateConfig)({ connectionTimeout: -1 }))
-                .toThrow('connectionTimeout must be non-negative');
+            expect(() => (0, config_1.validateConfig)({ connectionTimeout: -1 })).toThrow('connectionTimeout must be non-negative');
         });
         test('should throw error for negative requestTimeout', () => {
-            expect(() => (0, config_1.validateConfig)({ requestTimeout: -100 }))
-                .toThrow('requestTimeout must be non-negative');
+            expect(() => (0, config_1.validateConfig)({ requestTimeout: -100 })).toThrow('requestTimeout must be non-negative');
         });
         test('should throw error for negative maxRetries', () => {
-            expect(() => (0, config_1.validateConfig)({ maxRetries: -5 }))
-                .toThrow('maxRetries must be non-negative');
+            expect(() => (0, config_1.validateConfig)({ maxRetries: -5 })).toThrow('maxRetries must be non-negative');
         });
         test('should throw error for negative retryDelay', () => {
-            expect(() => (0, config_1.validateConfig)({ retryDelay: -1000 }))
-                .toThrow('retryDelay must be non-negative');
+            expect(() => (0, config_1.validateConfig)({ retryDelay: -1000 })).toThrow('retryDelay must be non-negative');
         });
         test('should throw error for maxConcurrentRequests less than 1', () => {
-            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: 0 }))
-                .toThrow('maxConcurrentRequests must be at least 1');
-            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: -1 }))
-                .toThrow('maxConcurrentRequests must be at least 1');
+            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: 0 })).toThrow('maxConcurrentRequests must be at least 1');
+            expect(() => (0, config_1.validateConfig)({ maxConcurrentRequests: -1 })).toThrow('maxConcurrentRequests must be at least 1');
         });
         test('should throw error for negative minRequestInterval', () => {
-            expect(() => (0, config_1.validateConfig)({ minRequestInterval: -50 }))
-                .toThrow('minRequestInterval must be non-negative');
+            expect(() => (0, config_1.validateConfig)({ minRequestInterval: -50 })).toThrow('minRequestInterval must be non-negative');
         });
         test('should accept all valid trustNewIdentities values', () => {
-            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'on-first-use' }))
-                .not.toThrow();
-            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'always' }))
-                .not.toThrow();
-            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'never' }))
-                .not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'on-first-use' })).not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'always' })).not.toThrow();
+            expect(() => (0, config_1.validateConfig)({ trustNewIdentities: 'never' })).not.toThrow();
         });
         test('should accept zero values for valid fields', () => {
             const config = (0, config_1.validateConfig)({
@@ -61,7 +51,7 @@ describe('Config Additional Tests', () => {
                 requestTimeout: 0,
                 maxRetries: 0,
                 retryDelay: 0,
-                minRequestInterval: 0
+                minRequestInterval: 0,
             });
             expect(config.connectionTimeout).toBe(0);
             expect(config.requestTimeout).toBe(0);
@@ -84,7 +74,7 @@ describe('Config Additional Tests', () => {
                 minRequestInterval: 200,
                 autoReconnect: false,
                 trustNewIdentities: 'never',
-                disableSendLog: true
+                disableSendLog: true,
             };
             const config = (0, config_1.validateConfig)(fullConfig);
             expect(config).toMatchObject(fullConfig);
@@ -98,7 +88,7 @@ describe('Config Additional Tests', () => {
                 enableConsole: true,
                 enableFile: false,
                 includeTimestamp: true,
-                includeLevel: true
+                includeLevel: true,
             });
         });
         test('should create logger with default config', () => {
@@ -144,7 +134,7 @@ describe('Config Additional Tests', () => {
                 enableConsole: false,
                 enableFile: false,
                 includeTimestamp: true,
-                includeLevel: true
+                includeLevel: true,
             });
             const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
             consoleLogger.info('Should not appear in console');
@@ -157,7 +147,7 @@ describe('Config Additional Tests', () => {
                 enableConsole: true,
                 enableFile: false,
                 includeTimestamp: false,
-                includeLevel: true
+                includeLevel: true,
             });
             const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation();
             const consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
@@ -182,7 +172,7 @@ describe('Config Additional Tests', () => {
                 enableConsole: true,
                 enableFile: false,
                 includeTimestamp: false,
-                includeLevel: true
+                includeLevel: true,
             });
             const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
             const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
@@ -204,7 +194,7 @@ describe('Config Additional Tests', () => {
                 enableConsole: true,
                 enableFile: false,
                 includeTimestamp: false,
-                includeLevel: true
+                includeLevel: true,
             });
             const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
             noTimestampLogger.info('No timestamp');
@@ -219,7 +209,7 @@ describe('Config Additional Tests', () => {
                 enableConsole: true,
                 enableFile: false,
                 includeTimestamp: false,
-                includeLevel: false
+                includeLevel: false,
             });
             const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
             noLevelLogger.info('No level');

package/dist/__tests__/errors.test.js

@@ -224,9 +224,9 @@ describe('Error Classes Additional Tests', () => {
                 new errors_1.ValidationError('test'),
                 new errors_1.TimeoutError('test'),
                 new errors_1.GroupError('test'),
-                new errors_1.MessageError('test')
+                new errors_1.MessageError('test'),
             ];
-            errors.forEach(error => {
+            errors.forEach((error) => {
                 expect(error.stack).toBeDefined();
                 expect(error.stack?.length).toBeGreaterThan(0);
             });

package/dist/__tests__/retry.test.js

@@ -17,12 +17,13 @@ describe('Retry utilities', () => {
             expect(operation).toHaveBeenCalledTimes(1);
         });
         it('should retry on failure', async () => {
-            const operation = jest.fn()
+            const operation = jest
+                .fn()
                 .mockRejectedValueOnce(new Error('Connection failed'))
                 .mockResolvedValue('success');
             const result = await (0, retry_1.withRetry)(operation, {
                 maxAttempts: 2,
-                initialDelay: 10
+                initialDelay: 10,
             });
             expect(result).toBe('success');
             expect(operation).toHaveBeenCalledTimes(2);
@@ -32,7 +33,7 @@ describe('Retry utilities', () => {
             await expect((0, retry_1.withRetry)(operation, {
                 maxAttempts: 3,
                 initialDelay: 10,
-                isRetryable: () => true // Force retry for test
+                isRetryable: () => true, // Force retry for test
             })).rejects.toThrow('Connection timeout');
             expect(operation).toHaveBeenCalledTimes(3);
         });
@@ -40,12 +41,13 @@ describe('Retry utilities', () => {
             const operation = jest.fn().mockRejectedValue({ code: 401, message: 'Unauthorized' });
             await expect((0, retry_1.withRetry)(operation, {
                 maxAttempts: 3,
-                initialDelay: 10
+                initialDelay: 10,
             })).rejects.toMatchObject({ code: 401 });
             expect(operation).toHaveBeenCalledTimes(1);
         });
         it('should call onRetry callback', async () => {
-            const operation = jest.fn()
+            const operation = jest
+                .fn()
                 .mockRejectedValueOnce(new Error('Connection failed'))
                 .mockResolvedValue('success');
             const onRetry = jest.fn();
@@ -53,7 +55,7 @@ describe('Retry utilities', () => {
                 maxAttempts: 2,
                 initialDelay: 10,
                 isRetryable: () => true, // Force retry for test
-                onRetry
+                onRetry,
             });
             expect(onRetry).toHaveBeenCalledTimes(1);
             expect(onRetry).toHaveBeenCalledWith(1, expect.any(Error));
@@ -66,7 +68,7 @@ describe('Retry utilities', () => {
             expect(result).toBe('success');
         });
         it('should reject with TimeoutError if operation takes too long', async () => {
-            const operation = new Promise(resolve => setTimeout(resolve, 1000));
+            const operation = new Promise((resolve) => setTimeout(resolve, 1000));
             await expect((0, retry_1.withTimeout)(operation, 100)).rejects.toThrow(errors_1.TimeoutError);
         });
     });
@@ -95,7 +97,7 @@ describe('Retry utilities', () => {
                 limiter.execute(operation),
                 limiter.execute(operation),
                 limiter.execute(operation),
-                limiter.execute(operation)
+                limiter.execute(operation),
             ];
             await Promise.all(promises);
             // Allow some tolerance for race conditions

package/dist/__tests__/robustness.test.d.ts

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

package/dist/__tests__/robustness.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+const errors_1 = require("../errors");
+// Mock dependencies
+jest.mock('child_process');
+jest.mock('../config', () => ({
+    Logger: jest.fn().mockImplementation(() => ({
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    })),
+    validateConfig: jest.fn().mockImplementation((config) => ({
+        verbose: false,
+        requestTimeout: config.requestTimeout || 1000,
+        maxConcurrentRequests: 10,
+        minRequestInterval: 100,
+    })),
+}));
+describe('SignalCli - Robustness', () => {
+    let signalCli;
+    const mockAccount = '+1234567890';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Set a short timeout for tests
+        signalCli = new SignalCli_1.SignalCli(mockAccount, undefined, { requestTimeout: 100 });
+    });
+    describe('RPC Timeouts', () => {
+        it('should throw ConnectionError when RPC request times out', async () => {
+            // Mock cliProcess to simulate a slow response
+            signalCli.cliProcess = {
+                stdin: { write: jest.fn() },
+                killed: false,
+            };
+            // We don't call handleRpcResponse, so the promise will never resolve
+            // but the timeout should trigger
+            await expect(signalCli.getVersion()).rejects.toThrow(errors_1.ConnectionError);
+            await expect(signalCli.getVersion()).rejects.toThrow(/RPC request timeout/);
+        });
+    });
+    describe('Exponential Backoff Reconnection', () => {
+        it('should attempt reconnection when process closes', async () => {
+            // Spy on connect
+            const connectSpy = jest.spyOn(signalCli, 'connect').mockResolvedValue(undefined);
+            const loggerSpy = jest.spyOn(signalCli.logger, 'warn');
+            jest.useFakeTimers();
+            // Simulate process close
+            signalCli.handleProcessClose(1);
+            expect(loggerSpy).toHaveBeenCalledWith(expect.stringContaining('Reconnecting in 1000ms'));
+            // Advance timers by 1s
+            jest.advanceTimersByTime(1000);
+            // Wait for any microtasks to clear
+            await Promise.resolve();
+            expect(connectSpy).toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+    });
+});

package/dist/__tests__/security.test.d.ts

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

package/dist/__tests__/security.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+const validators_1 = require("../validators");
+const errors_1 = require("../errors");
+describe('Security - Injection Prevention', () => {
+    describe('validateSanitizedString', () => {
+        const unsafeStrings = [
+            'device; rm -rf /',
+            'device & echo "hacked"',
+            'device | cat /etc/passwd',
+            'device && ls',
+            '$(whoami)',
+            '`id`',
+            'device > output.txt',
+            'device < input.txt',
+            'device\nnewline',
+            'device\rreturn',
+            'device\ttab',
+            'device"quote',
+            "device'quote",
+            'device(paren)',
+            'device{brace}',
+            'device[bracket]',
+            'device\\backslash',
+            'device!exclamation',
+            'device$dollar',
+        ];
+        unsafeStrings.forEach((input) => {
+            it(`should throw ValidationError for unsafe input: "${input}"`, () => {
+                expect(() => (0, validators_1.validateSanitizedString)(input)).toThrow(errors_1.ValidationError);
+            });
+        });
+        it('should allow safe alphanumeric strings', () => {
+            expect(() => (0, validators_1.validateSanitizedString)('MyDevice123')).not.toThrow();
+            expect(() => (0, validators_1.validateSanitizedString)('device-name_dot.123')).not.toThrow();
+        });
+    });
+    describe('SignalCli Security', () => {
+        it('should throw error if account number contains injection in constructor', () => {
+            const maliciousAccount = '+33123456789; rm -rf /';
+            expect(() => new SignalCli_1.SignalCli(maliciousAccount)).toThrow();
+        });
+        it('should throw error if device name contains injection in deviceLink', async () => {
+            const signal = new SignalCli_1.SignalCli('+1234567890');
+            const maliciousName = 'phone & echo hacked';
+            await expect(signal.deviceLink({ name: maliciousName })).rejects.toThrow(/contains unsafe characters/);
+        });
+    });
+});

package/dist/config.js

@@ -25,7 +25,7 @@ exports.DEFAULT_CONFIG = {
     socketPath: '/tmp/signal-cli.sock',
     tcpHost: 'localhost',
     tcpPort: 7583,
-    httpBaseUrl: 'http://localhost:8080'
+    httpBaseUrl: 'http://localhost:8080',
 };
 /**
  * Validates and merges configuration with defaults
@@ -60,7 +60,7 @@ exports.DEFAULT_LOGGER_CONFIG = {
     enableConsole: true,
     enableFile: false,
     includeTimestamp: true,
-    includeLevel: true
+    includeLevel: true,
 };
 /**
  * Simple logger implementation
@@ -71,7 +71,7 @@ class Logger {
             debug: 0,
             info: 1,
             warn: 2,
-            error: 3
+            error: 3,
         };
         this.config = { ...exports.DEFAULT_LOGGER_CONFIG, ...config };
     }

package/dist/interfaces.d.ts

@@ -108,6 +108,11 @@ export interface JsonRpcSendParams {
     expiresInSeconds?: number;
     /** Whether this is a view-once message */
     isViewOnce?: boolean;
+    /** Link preview information */
+    previewUrl?: string;
+    previewTitle?: string;
+    previewDescription?: string;
+    previewImage?: string;
 }
 /**
  * Parameters for the 'send_reaction' JSON-RPC method.
@@ -125,6 +130,8 @@ export interface JsonRpcReactionParams {
     emoji: string;
     /** Whether to remove the reaction */
     remove?: boolean;
+    /** Whether this is a reaction to a story */
+    story?: boolean;
 }
 /**
  * Parameters for the 'send_typing' JSON-RPC method.
@@ -512,6 +519,9 @@ export interface SendMessageOptions {
     isViewOnce?: boolean;
     linkPreview?: boolean;
     previewUrl?: string;
+    previewTitle?: string;
+    previewDescription?: string;
+    previewImage?: string;
     editTimestamp?: number;
     storyTimestamp?: number;
     storyAuthor?: string;
@@ -523,6 +533,8 @@ export interface SendMessageOptions {
  */
 export interface Profile {
     name?: string;
+    givenName?: string;
+    familyName?: string;
     about?: string;
     aboutEmoji?: string;
     avatar?: string;
@@ -535,6 +547,11 @@ export interface Profile {
  */
 export interface ContactUpdateOptions {
     name?: string;
+    givenName?: string;
+    familyName?: string;
+    nickGivenName?: string;
+    nickFamilyName?: string;
+    note?: string;
     color?: string;
     block?: boolean;
     unblock?: boolean;
@@ -542,6 +559,7 @@ export interface ContactUpdateOptions {
     muted?: boolean;
     mutedUntil?: number;
     hideStory?: boolean;
+    expiration?: number;
 }
 /**
  * Represents account configuration.
@@ -1095,6 +1113,15 @@ export interface AccountUpdateResult {
     /** Error message if failed */
     error?: string;
 }
+/**
+ * Options for updating a linked device
+ */
+export interface UpdateDeviceOptions {
+    /** Device ID to update */
+    deviceId: number;
+    /** New device name */
+    deviceName: string;
+}
 /**
  * Options for receiving messages
  */

package/dist/managers/AccountManager.d.ts

@@ -0,0 +1,27 @@
+import { BaseManager } from './BaseManager';
+import { AccountConfiguration, UpdateAccountOptions, AccountUpdateResult, PaymentNotificationData, SendResponse, RateLimitChallengeResult } from '../interfaces';
+export declare class AccountManager extends BaseManager {
+    register(number: string, voice?: boolean, captcha?: string): Promise<void>;
+    verify(number: string, token: string, pin?: string): Promise<void>;
+    updateProfile(name: string, about?: string, aboutEmoji?: string, avatar?: string, options?: {
+        familyName?: string;
+        mobileCoinAddress?: string;
+        removeAvatar?: boolean;
+    }): Promise<void>;
+    unregister(): Promise<void>;
+    deleteLocalAccountData(): Promise<void>;
+    updateAccountConfiguration(config: AccountConfiguration): Promise<void>;
+    setPin(pin: string): Promise<void>;
+    removePin(): Promise<void>;
+    listAccounts(): Promise<string[]>;
+    listAccountsDetailed(): Promise<Array<{
+        number: string;
+        name?: string;
+        uuid?: string;
+    }>>;
+    updateAccount(options: UpdateAccountOptions): Promise<AccountUpdateResult>;
+    sendPaymentNotification(recipient: string, paymentData: PaymentNotificationData): Promise<SendResponse>;
+    submitRateLimitChallenge(challenge: string, captcha: string): Promise<RateLimitChallengeResult>;
+    startChangeNumber(newNumber: string, voice?: boolean, captcha?: string): Promise<void>;
+    finishChangeNumber(newNumber: string, verificationCode: string, pin?: string): Promise<void>;
+}

package/dist/managers/AccountManager.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const validators_1 = require("../validators");
+class AccountManager extends BaseManager_1.BaseManager {
+    async register(number, voice, captcha) {
+        await this.sendRequest('register', { account: number, voice, captcha });
+    }
+    async verify(number, token, pin) {
+        await this.sendRequest('verify', { account: number, token, pin });
+    }
+    async updateProfile(name, about, aboutEmoji, avatar, options = {}) {
+        const params = { account: this.account, name };
+        if (about)
+            params.about = about;
+        if (aboutEmoji)
+            params.aboutEmoji = aboutEmoji;
+        if (avatar)
+            params.avatar = avatar;
+        if (options.familyName)
+            params.familyName = options.familyName;
+        if (options.mobileCoinAddress)
+            params.mobileCoinAddress = options.mobileCoinAddress;
+        if (options.removeAvatar)
+            params.removeAvatar = true;
+        await this.sendRequest('updateProfile', params);
+    }
+    async unregister() {
+        await this.sendRequest('unregister', { account: this.account });
+    }
+    async deleteLocalAccountData() {
+        await this.sendRequest('deleteLocalAccountData', { account: this.account });
+    }
+    async updateAccountConfiguration(config) {
+        await this.sendRequest('updateConfiguration', { account: this.account, ...config });
+    }
+    async setPin(pin) {
+        await this.sendRequest('setPin', { account: this.account, pin });
+    }
+    async removePin() {
+        await this.sendRequest('removePin', { account: this.account });
+    }
+    async listAccounts() {
+        const result = await this.sendRequest('listAccounts');
+        return result.accounts.map((acc) => acc.number);
+    }
+    async listAccountsDetailed() {
+        this.logger.debug('Listing all accounts');
+        const result = await this.sendRequest('listAccounts');
+        return result.accounts || [];
+    }
+    async updateAccount(options) {
+        this.logger.debug('Updating account', options);
+        const params = { account: this.account };
+        if (options.deviceName)
+            params.deviceName = options.deviceName;
+        if (options.username)
+            params.username = options.username;
+        if (options.deleteUsername)
+            params.deleteUsername = true;
+        if (options.unrestrictedUnidentifiedSender !== undefined) {
+            params.unrestrictedUnidentifiedSender = options.unrestrictedUnidentifiedSender;
+        }
+        if (options.discoverableByNumber !== undefined) {
+            params.discoverableByNumber = options.discoverableByNumber;
+        }
+        if (options.numberSharing !== undefined) {
+            params.numberSharing = options.numberSharing;
+        }
+        try {
+            const result = await this.sendRequest('updateAccount', params);
+            return {
+                success: true,
+                username: result.username,
+                usernameLink: result.usernameLink,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    async sendPaymentNotification(recipient, paymentData) {
+        this.logger.info(`Sending payment notification to ${recipient}`);
+        (0, validators_1.validateRecipient)(recipient);
+        if (!paymentData.receipt || paymentData.receipt.trim().length === 0) {
+            throw new Error('Payment receipt is required');
+        }
+        const params = {
+            receipt: paymentData.receipt,
+            account: this.account,
+        };
+        if (paymentData.note)
+            params.note = paymentData.note;
+        if (this.isGroupId(recipient)) {
+            params.groupId = recipient;
+        }
+        else {
+            params.recipient = recipient;
+        }
+        return this.sendRequest('sendPaymentNotification', params);
+    }
+    async submitRateLimitChallenge(challenge, captcha) {
+        const params = {
+            account: this.account,
+            challenge,
+            captcha,
+        };
+        const result = await this.sendRequest('submitRateLimitChallenge', params);
+        return {
+            success: result.success || false,
+            retryAfter: result.retryAfter,
+            message: result.message,
+        };
+    }
+    async startChangeNumber(newNumber, voice = false, captcha) {
+        this.logger.info(`Starting change number to ${newNumber} (voice: ${voice})`);
+        (0, validators_1.validatePhoneNumber)(newNumber);
+        const params = {
+            account: this.account,
+            number: newNumber,
+            voice,
+        };
+        if (captcha)
+            params.captcha = captcha;
+        await this.sendRequest('startChangeNumber', params);
+    }
+    async finishChangeNumber(newNumber, verificationCode, pin) {
+        this.logger.info(`Finishing change number to ${newNumber}`);
+        (0, validators_1.validatePhoneNumber)(newNumber);
+        if (!verificationCode || verificationCode.trim().length === 0) {
+            throw new Error('Verification code is required');
+        }
+        const params = {
+            account: this.account,
+            number: newNumber,
+            verificationCode,
+        };
+        if (pin)
+            params.pin = pin;
+        await this.sendRequest('finishChangeNumber', params);
+    }
+}
+exports.AccountManager = AccountManager;

package/dist/managers/BaseManager.d.ts

@@ -0,0 +1,9 @@
+import { SignalCliConfig, Logger } from '../config';
+export declare abstract class BaseManager {
+    protected readonly sendRequest: (method: string, params?: any) => Promise<any>;
+    protected readonly account: string | undefined;
+    protected readonly logger: Logger;
+    protected readonly config: Required<SignalCliConfig>;
+    constructor(sendRequest: (method: string, params?: any) => Promise<any>, account: string | undefined, logger: Logger, config: Required<SignalCliConfig>);
+    protected isGroupId(recipient: string): boolean;
+}

package/dist/managers/BaseManager.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseManager = void 0;
+class BaseManager {
+    constructor(sendRequest, account, logger, config) {
+        this.sendRequest = sendRequest;
+        this.account = account;
+        this.logger = logger;
+        this.config = config;
+    }
+    isGroupId(recipient) {
+        return (recipient.includes('=') ||
+            recipient.includes('/') ||
+            (recipient.includes('+') && !recipient.startsWith('+')));
+    }
+}
+exports.BaseManager = BaseManager;

package/dist/managers/ContactManager.d.ts

@@ -0,0 +1,15 @@
+import { BaseManager } from './BaseManager';
+import { Contact, ContactUpdateOptions, RemoveContactOptions, IdentityKey, UserStatusResult, GetAvatarOptions } from '../interfaces';
+export declare class ContactManager extends BaseManager {
+    updateContact(number: string, name?: string, options?: Omit<ContactUpdateOptions, 'name'>): Promise<void>;
+    block(recipients: string[], groupId?: string): Promise<void>;
+    unblock(recipients: string[], groupId?: string): Promise<void>;
+    listContacts(): Promise<Contact[]>;
+    removeContact(number: string, options?: RemoveContactOptions): Promise<void>;
+    getUserStatus(numbers?: string[], usernames?: string[]): Promise<UserStatusResult[]>;
+    listIdentities(number?: string): Promise<IdentityKey[]>;
+    trustIdentity(number: string, safetyNumber: string, verified?: boolean): Promise<void>;
+    getAvatar(options: GetAvatarOptions): Promise<string>;
+    parseContactProfile(contact: Contact): Contact;
+    getContactsWithProfiles(): Promise<Contact[]>;
+}